00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "kxmlcommand.h"
00021
#include "driver.h"
00022
#include "kmfactory.h"
00023
#include "kdeprintcheck.h"
00024
#include "driverview.h"
00025
00026
#include <qfile.h>
00027
#include <qregexp.h>
00028
#include <qdir.h>
00029
#include <qinputdialog.h>
00030
#include <qmap.h>
00031
#include <qvaluelist.h>
00032
#include <kstandarddirs.h>
00033
#include <klocale.h>
00034
#include <ksimpleconfig.h>
00035
#include <kdialogbase.h>
00036
#include <kdebug.h>
00037
#include <kprocess.h>
00038
#include <klibloader.h>
00039
#include <kmessagebox.h>
00040
00041
static void setOptionText(DrBase *opt,
const QString& s)
00042 {
00043
if (s.isEmpty())
00044 opt->set(
"text", opt->name());
00045
else
00046 opt->set(
"text", i18n(s.utf8()));
00047 }
00048
00049
class KXmlCommand::KXmlCommandPrivate
00050 {
00051
public:
00052
QString m_name;
00053
QString m_command;
00054 DrMain *m_driver;
00055
struct
00056
{
00057
QString m_format[2];
00058 } m_io[2];
00059
QString m_description;
00060
QString m_outputMime;
00061
QStringList m_inputMime;
00062
QStringList m_requirements;
00063
bool m_loaded[2];
00064
QString m_comment;
00065 };
00066
00067 KXmlCommand::KXmlCommand(
const QString& xmlId)
00068 :
QObject(KXmlCommandManager::self(),
"XmlCommand")
00069 {
00070 init();
00071 d->m_name = xmlId;
00072 }
00073
00074 KXmlCommand::~KXmlCommand()
00075 {
00076
00077
delete d->m_driver;
00078
00079
delete d;
00080
00081 }
00082
00083
void KXmlCommand::init()
00084 {
00085 d =
new KXmlCommandPrivate;
00086 d->m_driver = 0;
00087 d->m_loaded[0] = d->m_loaded[1] =
false;
00088 }
00089
00090
QString KXmlCommand::name()
const
00091
{
return d->m_name; }
00092
00093
void KXmlCommand::setName(
const QString& s)
00094 { d->m_name = s; }
00095
00096
QString KXmlCommand::command()
00097 {
00098 check(
true);
00099
return d->m_command;
00100 }
00101
00102
void KXmlCommand::setCommand(
const QString& s)
00103 {
00104 d->m_command = s;
00105 }
00106
00107 DrMain* KXmlCommand::driver()
00108 {
00109 check(
true);
00110
return d->m_driver;
00111 }
00112
00113 DrMain* KXmlCommand::takeDriver()
00114 {
00115 check(
true);
00116 DrMain *dr = d->m_driver;
00117 d->m_driver = 0;
00118 d->m_loaded[1] =
false;
00119
return dr;
00120 }
00121
00122
void KXmlCommand::setDriver(DrMain *driver)
00123 {
00124
delete d->m_driver;
00125 d->m_driver = driver;
00126 }
00127
00128
QString KXmlCommand::io(
bool io_input,
bool io_pipe)
00129 {
00130 check(
true);
00131
return d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)];
00132 }
00133
00134
void KXmlCommand::setIo(
const QString& s,
bool io_input,
bool io_pipe)
00135 {
00136 d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)] = s;
00137 }
00138
00139
QString KXmlCommand::description()
00140 {
00141 check();
00142
return d->m_description;
00143 }
00144
00145
void KXmlCommand::setDescription(
const QString& s)
00146 {
00147 d->m_description = s;
00148 }
00149
00150
QString KXmlCommand::mimeType()
00151 {
00152 check();
00153
return d->m_outputMime;
00154 }
00155
00156
void KXmlCommand::setMimeType(
const QString& s)
00157 {
00158 d->m_outputMime = s;
00159 }
00160
00161
bool KXmlCommand::acceptMimeType(
const QString& s)
00162 {
00163 check();
00164
return (d->m_inputMime.find(s) != d->m_inputMime.end());
00165 }
00166
00167
QStringList KXmlCommand::inputMimeTypes()
00168 {
00169 check();
00170
return d->m_inputMime;
00171 }
00172
00173
void KXmlCommand::setInputMimeTypes(
const QStringList& l)
00174 {
00175 d->m_inputMime = l;
00176 }
00177
00178
QStringList KXmlCommand::requirements()
00179 {
00180 check();
00181
return d->m_requirements;
00182 }
00183
00184
void KXmlCommand::setRequirements(
const QStringList& l)
00185 {
00186 d->m_requirements = l;
00187 }
00188
00189
QString KXmlCommand::comment()
00190 {
00191 check();
00192
return d->m_comment;
00193 }
00194
00195
void KXmlCommand::setComment(
const QString& s )
00196 {
00197 d->m_comment = s;
00198 }
00199
00200
bool KXmlCommand::isValid()
00201 {
00202
return (!locate(
"data",
"kdeprint/filters/"+name()+
".desktop").isEmpty());
00203 }
00204
00205
void KXmlCommand::check(
bool use_xml)
00206 {
00207
if (!d->m_loaded[0])
00208 {
00209 loadDesktop();
00210 d->m_loaded[0] =
true;
00211 }
00212
if (use_xml && !d->m_loaded[1])
00213 {
00214 loadXml();
00215 d->m_loaded[1] =
true;
00216 }
00217 }
00218
00219
void KXmlCommand::loadDesktop()
00220 {
00221 KSimpleConfig conf(locate(
"data",
"kdeprint/filters/"+name()+
".desktop"));
00222 conf.setGroup(
"KDE Print Filter Entry");
00223 d->m_description = conf.readEntry(
"Comment");
00224 d->m_outputMime = conf.readEntry(
"MimeTypeOut");
00225 d->m_inputMime = conf.readListEntry(
"MimeTypeIn");
00226 d->m_requirements = conf.readListEntry(
"Require");
00227 d->m_comment = conf.readEntry(
"Description" );
00228 }
00229
00230
void KXmlCommand::saveDesktop()
00231 {
00232 KSimpleConfig conf(locateLocal(
"data",
"kdeprint/filters/"+name()+
".desktop"));
00233 conf.setGroup(
"KDE Print Filter Entry");
00234 conf.writeEntry(
"Comment", d->m_description);
00235 conf.writeEntry(
"MimeTypeIn", d->m_inputMime);
00236 conf.writeEntry(
"MimeTypeOut", d->m_outputMime);
00237 conf.writeEntry(
"Require", d->m_requirements);
00238 conf.writeEntry(
"Description", d->m_comment );
00239 }
00240
00241
void KXmlCommand::loadXml()
00242 {
00243
QFile f(locate(
"data",
"kdeprint/filters/"+name()+
".xml"));
00244
QDomDocument doc;
00245
if (f.open(IO_ReadOnly) && doc.setContent(&f) && doc.documentElement().tagName() ==
"kprintfilter")
00246 {
00247
QDomElement e, docElem = doc.documentElement();
00248 d->m_name = docElem.attribute(
"name");
00249
00250
00251 e = docElem.namedItem(
"filtercommand").toElement();
00252
if (!e.isNull())
00253 d->m_command = e.attribute(
"data");
00254
00255
00256 e = docElem.namedItem(
"filterargs").toElement();
00257
if (!e.isNull())
00258 {
00259 d->m_driver =
new DrMain;
00260 d->m_driver->setName(d->m_name);
00261 parseGroup(e, d->m_driver);
00262 setOptionText(d->m_driver, d->m_description);
00263 }
00264
00265
00266 e = docElem.namedItem(
"filterinput").toElement();
00267
if (!e.isNull())
00268 parseIO(e, 0);
00269 e = docElem.namedItem(
"filteroutput").toElement();
00270
if (!e.isNull())
00271 parseIO(e, 1);
00272 }
00273 }
00274
00275
void KXmlCommand::parseIO(
const QDomElement& e,
int n)
00276 {
00277
QDomElement elem = e.firstChild().toElement();
00278
while (!elem.isNull())
00279 {
00280
if (elem.tagName() ==
"filterarg")
00281 {
00282
int format = (elem.attribute(
"name") ==
"file" ? 0 : 1);
00283 d->m_io[n].m_format[format] = elem.attribute(
"format");
00284 }
00285 elem = elem.nextSibling().toElement();
00286 }
00287 }
00288
00289 DrGroup* KXmlCommand::parseGroup(
const QDomElement& e, DrGroup *grp)
00290 {
00291
if (!grp)
00292 grp =
new DrGroup;
00293 grp->setName(e.attribute(
"name"));
00294 setOptionText(grp, e.attribute(
"description"));
00295
00296
QDomElement elem = e.firstChild().toElement();
00297
while (!elem.isNull())
00298 {
00299
if (elem.tagName() ==
"filterarg")
00300 {
00301 DrBase *opt = parseArgument(elem);
00302
if (opt)
00303 grp->addOption(opt);
00304 }
00305
else if (elem.tagName() ==
"filtergroup")
00306 {
00307 DrGroup *group = parseGroup(elem, 0);
00308
if (group)
00309 grp->addGroup(group);
00310 }
00311 elem = elem.nextSibling().toElement();
00312 }
00313
00314
return grp;
00315 }
00316
00317 DrBase* KXmlCommand::parseArgument(
const QDomElement& e)
00318 {
00319 DrBase *opt(0);
00320
QString type = e.attribute(
"type");
00321
00322
if (type ==
"int" || type ==
"float")
00323 {
00324
if (type ==
"int")
00325 opt =
new DrIntegerOption;
00326
else
00327 opt =
new DrFloatOption;
00328 opt->set(
"minval", e.attribute(
"min"));
00329 opt->set(
"maxval", e.attribute(
"max"));
00330 }
00331
else if (type ==
"string")
00332 opt =
new DrStringOption;
00333
else if (type ==
"list" || type ==
"bool")
00334 {
00335
if (type ==
"list")
00336 opt =
new DrListOption;
00337
else
00338 opt =
new DrBooleanOption;
00339 DrListOption *lopt = static_cast<DrListOption*>(opt);
00340
QDomElement elem = e.firstChild().toElement();
00341
while (!elem.isNull())
00342 {
00343
if (elem.tagName() ==
"value")
00344 {
00345 DrBase *choice =
new DrBase;
00346 choice->setName(elem.attribute(
"name"));
00347 setOptionText(choice, elem.attribute(
"description"));
00348 lopt->addChoice(choice);
00349 }
00350 elem = elem.nextSibling().toElement();
00351 }
00352 }
00353
else
00354
return 0;
00355
00356 opt->setName(
"_kde-" + d->m_name +
"-" + e.attribute(
"name"));
00357 setOptionText(opt, e.attribute(
"description"));
00358 opt->set(
"format", e.attribute(
"format"));
00359 opt->set(
"default", e.attribute(
"default"));
00360 opt->set(
"persistent", e.attribute(
"persistent" ) );
00361 opt->setValueText(opt->get(
"default"));
00362
00363
return opt;
00364 }
00365
00366
QString KXmlCommand::buildCommand(
const QMap<QString,QString>& opts,
bool pipein,
bool pipeout)
00367 {
00368 check(
true);
00369
00370
QString str, cmd = d->m_command;
00371
QString re(
"%value" ), quotedRe(
"'%value'" );
00372
00373
if (d->m_driver)
00374 {
00375
QMap<QString,QString> fopts;
00376
00377 d->m_driver->setOptions(opts);
00378 d->m_driver->getOptions(fopts,
false);
00379
for (
QMap<QString,QString>::ConstIterator it=fopts.begin(); it!=fopts.end(); ++it)
00380 {
00381 DrBase *dopt = d->m_driver->findOption(it.key());
00382
if (dopt)
00383 {
00384
QString format = dopt->get(
"format");
00385
QString value = dopt->valueText();
00386
if ( format.find( quotedRe ) != -1 )
00387 {
00388
if ( ( value.right( 1 ) ==
"'" && value.left( 1 ) ==
"'" ) ||
00389 ( value.right( 1 ) ==
"\"" && value.left( 1 ) ==
"\"" ) )
00390 format.replace( quotedRe, value );
00391
else
00392 format.replace( re, value );
00393 }
00394
else
00395 {
00396 format.replace( re, KProcess::quote( dopt->valueText() ) );
00397 }
00398 str.append(format).append(
" ");
00399 }
00400 }
00401 cmd.replace(
"%filterargs", str);
00402 }
00403
00404 cmd.replace(
"%filterinput", d->m_io[0].m_format[(pipein?1:0)]);
00405 cmd.replace(
"%filteroutput", d->m_io[1].m_format[(pipeout?1:0)]);
00406
00407
return cmd;
00408 }
00409
00410
void KXmlCommand::setOptions(
const QMap<QString,QString>& opts)
00411 {
00412
if (opts.count() == 0)
00413
return;
00414
00415
if (driver())
00416 d->m_driver->setOptions(opts);
00417 }
00418
00419
void KXmlCommand::getOptions(
QMap<QString,QString>& opts,
bool incldef)
00420 {
00421
00422
if (driver())
00423 d->m_driver->getOptions(opts, incldef);
00424 }
00425
00426
void KXmlCommand::saveXml()
00427 {
00428
QFile f(locateLocal(
"data",
"kdeprint/filters/"+name()+
".xml"));
00429
if (!f.open(IO_WriteOnly))
00430
return;
00431
00432
QDomDocument doc(
"kprintfilter");
00433
QDomElement root = doc.createElement(
"kprintfilter"), elem;
00434
00435 root.setAttribute(
"name", d->m_name);
00436 doc.appendChild(root);
00437
00438
00439 elem = doc.createElement(
"filtercommand");
00440 elem.setAttribute(
"data", d->m_command);
00441 root.appendChild(elem);
00442
00443
00444
if (d->m_driver)
00445 {
00446 elem = createGroup(doc, d->m_driver);
00447 elem.setTagName(
"filterargs");
00448 root.appendChild(elem);
00449 }
00450
00451
00452
if (!(elem=createIO(doc, 0,
"filterinput")).isNull())
00453 root.appendChild(elem);
00454
if (!(elem=createIO(doc, 1,
"filteroutput")).isNull())
00455 root.appendChild(elem);
00456
00457
00458
QTextStream t(&f);
00459 t << doc.toString();
00460 f.close();
00461 }
00462
00463
QDomElement KXmlCommand::createIO(
QDomDocument& doc,
int n,
const QString& tag)
00464 {
00465
QDomElement elem = doc.createElement(tag);
00466
if (d->m_command.find(
"%"+tag) != -1)
00467 {
00468
for (
int i=0; i<2; i++)
00469 {
00470
QDomElement io = doc.createElement(
"filterarg");
00471 io.setAttribute(
"name", (i ?
"pipe" :
"file"));
00472 io.setAttribute(
"format", d->m_io[n].m_format[i]);
00473 elem.appendChild(io);
00474 }
00475 }
00476
00477
return elem;
00478 }
00479
00480
QDomElement KXmlCommand::createGroup(
QDomDocument& doc, DrGroup *group)
00481 {
00482
QDomElement elem = doc.createElement(
"filtergroup");
00483 elem.setAttribute(
"name", group->name());
00484 elem.setAttribute(
"description", group->get(
"text"));
00485
00486
QPtrListIterator<DrGroup> git(group->groups());
00487
for (; git.current(); ++git)
00488 elem.appendChild(createGroup(doc, git.current()));
00489
00490
QPtrListIterator<DrBase> oit(group->options());
00491
for (; oit.current(); ++oit)
00492 elem.appendChild(createElement(doc, oit.current()));
00493
00494
return elem;
00495 }
00496
00497
QDomElement KXmlCommand::createElement(
QDomDocument& doc, DrBase *opt)
00498 {
00499
QDomElement elem = doc.createElement(
"filterarg");
00500
QString elemName = opt->name();
00501
if (elemName.startsWith(
"_kde-"))
00502 elemName.replace(0, name().length()+6,
"");
00503 elem.setAttribute(
"name", elemName);
00504 elem.setAttribute(
"format", opt->get(
"format"));
00505 elem.setAttribute(
"description", opt->get(
"text"));
00506 elem.setAttribute(
"default", opt->get(
"default"));
00507 elem.setAttribute(
"persistent", opt->get(
"persistent" ) ==
"1" ?
"1" :
"0");
00508
00509
switch (opt->type())
00510 {
00511
case DrBase::String:
00512 elem.setAttribute(
"type",
"string");
00513
break;
00514
case DrBase::Integer:
00515
case DrBase::Float:
00516 elem.setAttribute(
"type", (opt->type() == DrBase::Integer ?
"int" :
"float"));
00517 elem.setAttribute(
"min", opt->get(
"minval"));
00518 elem.setAttribute(
"max", opt->get(
"maxval"));
00519
break;
00520
case DrBase::Boolean:
00521
case DrBase::List:
00522 elem.setAttribute(
"type", (opt->type() == DrBase::List ?
"list" :
"bool"));
00523 {
00524
QPtrListIterator<DrBase> it(*(static_cast<DrListOption*>(opt)->choices()));
00525
for (; it.current(); ++it)
00526 {
00527
QDomElement chElem = doc.createElement(
"value");
00528 chElem.setAttribute(
"name", it.current()->name());
00529 chElem.setAttribute(
"description", it.current()->get(
"text"));
00530 elem.appendChild(chElem);
00531 }
00532 }
00533
break;
00534
default:
00535
break;
00536 }
00537
00538
return elem;
00539 }
00540
00541
00542
00543
class KXmlCommandManager::KXmlCommandManagerPrivate
00544 {
00545
public:
00546
QStringList m_cmdlist;
00547
QMap<QString, QValueList<KXmlCommand*> > m_mimemap;
00548
QMap<QString, KXmlCommand*> m_cmdmap;
00549 };
00550
00551 KXmlCommandManager* KXmlCommandManager::m_self = 0;
00552
00553 KXmlCommandManager* KXmlCommandManager::self()
00554 {
00555
if (!m_self)
00556 {
00557 m_self =
new KXmlCommandManager;
00558 Q_CHECK_PTR(m_self);
00559 }
00560
return m_self;
00561 }
00562
00563 KXmlCommandManager::KXmlCommandManager()
00564 :
QObject(KMFactory::self(),
"XmlCommandManager")
00565 {
00566 d =
new KXmlCommandManagerPrivate;
00567 }
00568
00569 KXmlCommandManager::~KXmlCommandManager()
00570 {
00571 cleanUp();
00572
delete d;
00573 }
00574
00575 KXmlCommand* KXmlCommandManager::loadCommand(
const QString& xmlId,
bool check)
00576 {
00577
if (check)
00578 {
00579
QString desktopFile = locate(
"data",
"kdeprint/filters/"+xmlId+
".desktop");
00580
if (desktopFile.isEmpty())
00581
return 0;
00582 }
00583
return new KXmlCommand(xmlId);
00584 }
00585
00586
void KXmlCommandManager::saveCommand(KXmlCommand *xmlCmd)
00587 {
00588 xmlCmd->saveDesktop();
00589 xmlCmd->saveXml();
00590
00591 cleanUp();
00592 }
00593
00594
void KXmlCommandManager::cleanUp()
00595 {
00596
for (
QMap<QString, KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
00597
delete (*it);
00598 d->m_cmdmap.clear();
00599 d->m_mimemap.clear();
00600 d->m_cmdlist.clear();
00601 }
00602
00603
void KXmlCommandManager::preload()
00604 {
00605
if (d->m_cmdmap.count() == 0)
00606 {
00607 commandList();
00608
for (QStringList::Iterator it=d->m_cmdlist.begin(); it!=d->m_cmdlist.end(); ++it)
00609 {
00610 KXmlCommand *xmlCmd = loadCommand(*it);
00611
if (!xmlCmd)
continue;
00612
00613
QStringList inputMime = xmlCmd->inputMimeTypes();
00614
for (QStringList::ConstIterator mime=inputMime.begin(); mime!=inputMime.end(); ++mime)
00615 {
00616 d->m_mimemap[*mime].append(xmlCmd);
00617 d->m_cmdmap[*it] = xmlCmd;
00618 }
00619 }
00620 }
00621 }
00622
00623
QStringList KXmlCommandManager::commandList()
00624 {
00625
if (d->m_cmdlist.isEmpty())
00626 {
00627
QStringList dirs = KGlobal::dirs()->findDirs(
"data",
"kdeprint/filters/");
00628
00629
for (QStringList::ConstIterator it=dirs.begin(); it!=dirs.end(); ++it)
00630 {
00631
QStringList list =
QDir(*it).entryList(
"*.desktop", QDir::Files, QDir::Unsorted);
00632
for (QStringList::ConstIterator it2=list.begin(); it2!=list.end(); ++it2)
00633 {
00634
QString cmdName = (*it2).left((*it2).length()-8);
00635
if (d->m_cmdlist.find(cmdName) == d->m_cmdlist.end())
00636 d->m_cmdlist.append(cmdName);
00637 }
00638 }
00639
00640 d->m_cmdlist.sort();
00641 }
00642
00643
return d->m_cmdlist;
00644 }
00645
00646
QStringList KXmlCommandManager::commandListWithDescription()
00647 {
00648 preload();
00649
QStringList l;
00650
for (
QMap<QString,KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
00651 l << (*it)->name() << (*it)->description();
00652
00653
return l;
00654 }
00655
00656
QString KXmlCommandManager::selectCommand(
QWidget *parent)
00657 {
00658 KLibrary *lib = KLibLoader::self()->library(
"libkdeprint_management_module" );
00659
if ( !lib )
00660 {
00661 KMessageBox::error( parent, i18n(
"Unable to load KDE print management library: %1" ).arg( KLibLoader::self()->lastErrorMessage() ) );
00662
return QString::null;
00663 }
00664
else
00665 {
00666
QString ( *func )(
QWidget* ) = (
QString( * )(
QWidget* ) )lib->symbol(
"select_command" );
00667
if ( !func )
00668 {
00669 KMessageBox::error( parent, i18n(
"Unable to find wizard object in management library." ) );
00670
return QString::null;
00671 }
00672
else
00673
return func( parent );
00674 }
00675 }
00676
00677 KXmlCommand* KXmlCommandManager::command(
const QString& xmlId)
const
00678
{
00679
return (d->m_cmdmap.contains(xmlId) ? d->m_cmdmap[xmlId] : 0);
00680 }
00681
00682
int KXmlCommandManager::insertCommand(
QStringList& list,
const QString& filtername,
bool defaultToStart)
00683 {
00684 preload();
00685
00686
int pos(0);
00687 KXmlCommand *f1 = command(filtername), *f2 = 0;
00688
if (f1 && f1->inputMimeTypes().count() > 0)
00689 {
00690
QString mimetype = f1->inputMimeTypes()[0];
00691
for (QStringList::Iterator it=list.begin(); it!=list.end(); ++it, pos++)
00692 {
00693 f2 = command(*it);
00694
if (!f2)
00695
return -1;
00696
00697
if (f2->acceptMimeType(f1->mimeType()) && f1->acceptMimeType(mimetype))
00698 {
00699 list.insert(it, filtername);
00700
break;
00701 }
00702
else
00703 {
00704 mimetype = f2->mimeType();
00705 f2 = 0;
00706 }
00707 }
00708
if (pos == (
int)(list.count()))
00709 {
00710
if (list.count() == 0 || f1->acceptMimeType(mimetype))
00711 list.append(filtername);
00712
else if (defaultToStart)
00713 {
00714 pos = 0;
00715 list.prepend(filtername);
00716 }
00717
else
00718 pos = -1;
00719 }
00720 }
00721
return pos;
00722 }
00723
00724
QStringList KXmlCommandManager::autoConvert(
const QString& mimesrc,
const QString& mimedest)
00725 {
00726
QStringList chain;
00727 uint score(0);
00728
00729 preload();
00730
00731
if (d->m_mimemap.contains(mimesrc))
00732 {
00733
const QValueList<KXmlCommand*> l = d->m_mimemap[mimesrc];
00734
for (
QValueList<KXmlCommand*>::ConstIterator it=l.begin(); it!=l.end(); ++it)
00735 {
00736
00737
if ((*it)->mimeType() == mimedest)
00738 {
00739 chain =
QStringList((*it)->name());
00740
break;
00741 }
00742
00743
00744
else if ((*it)->mimeType() != mimesrc)
00745 {
00746
QStringList subchain = autoConvert((*it)->mimeType(), mimedest);
00747
00748
00749
00750
00751
if (subchain.count() > 0 && subchain.findIndex((*it)->name()) == -1)
00752 {
00753 subchain.prepend((*it)->name());
00754
if (subchain.count() < score || score == 0)
00755 {
00756 chain = subchain;
00757 score = subchain.count();
00758 }
00759 }
00760 }
00761 }
00762 }
00763
00764
00765
return chain;
00766 }
00767
00768
bool KXmlCommandManager::checkCommand(
const QString& xmlId,
int inputCheck,
int outputCheck,
QString *msg)
00769 {
00770 KXmlCommand *xmlCmd = command(xmlId);
00771
QString errmsg;
00772
bool needDestroy(
false);
00773
00774
if (!xmlCmd)
00775 {
00776 xmlCmd = loadCommand(xmlId,
true);
00777 needDestroy = (xmlCmd != 0);
00778 }
00779
00780
bool status(
true);
00781
if (xmlCmd)
00782 {
00783 status = (xmlCmd->isValid() && KdeprintChecker::check(xmlCmd->requirements()));
00784
if (!status)
00785 errmsg = i18n(
"One of the command object's requirements is not met.");
00786 }
00787
QString cmd = (xmlCmd ? xmlCmd->command() : xmlId);
00788
if (status && !cmd.isEmpty() && (inputCheck > None || outputCheck > None))
00789 {
00790
if (inputCheck > None && (cmd.find(
"%in") == -1 || inputCheck == Advanced) && cmd.find(
"%filterinput") == -1)
00791 {
00792 status =
false;
00793 errmsg = i18n(
"The command does not contain the required tag %1.").arg(inputCheck == Advanced ?
"%filterinput" :
"{%in,%filterinput}");
00794 }
00795
if (status && outputCheck > None && (cmd.find(
"%out") == -1 || outputCheck == Advanced) && cmd.find(
"filteroutput") == -1)
00796 {
00797 status =
false;
00798 errmsg = i18n(
"The command does not contain the required tag %1.").arg(outputCheck == Advanced ?
"%filteroutput" :
"{%out,%filteroutput}");
00799 }
00800 }
00801
00802
if (needDestroy)
00803
delete xmlCmd;
00804
00805
if (msg)
00806 *msg = errmsg;
00807
00808
return status;
00809 }
00810
00811
bool KXmlCommandManager::configure(KXmlCommand *xmlCmd,
QWidget *parent)
00812 {
00813
if (xmlCmd->driver())
00814 {
00815 KDialogBase dlg(parent, 0,
true, xmlCmd->description(), KDialogBase::Ok);
00816 DriverView view(&dlg);
00817
00818 dlg.setMainWidget(&view);
00819 view.setDriver(xmlCmd->driver());
00820 dlg.resize(350,400);
00821 dlg.exec();
00822
00823
return true;
00824 }
00825
return false;
00826 }