• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdeprint
 

tdeprint

  • tdeprint
kxmlcommand.cpp
1 /*
2  * This file is part of the KDE libraries
3  * Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License version 2 as published by the Free Software Foundation.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB. If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  **/
19 
20 #include "kxmlcommand.h"
21 #include "driver.h"
22 #include "kmfactory.h"
23 #include "tdeprintcheck.h"
24 #include "driverview.h"
25 
26 #include <tqfile.h>
27 #include <tqregexp.h>
28 #include <tqdir.h>
29 #include <tqinputdialog.h>
30 #include <tqmap.h>
31 #include <tqvaluelist.h>
32 #include <kstandarddirs.h>
33 #include <tdelocale.h>
34 #include <ksimpleconfig.h>
35 #include <kdialogbase.h>
36 #include <kdebug.h>
37 #include <tdeprocess.h>
38 #include <klibloader.h>
39 #include <tdemessagebox.h>
40 
41 static void setOptionText(DrBase *opt, const TQString& s)
42 {
43  if (s.isEmpty())
44  opt->set("text", opt->name());
45  else
46  opt->set("text", i18n(s.utf8()));
47 }
48 
49 class KXmlCommand::KXmlCommandPrivate
50 {
51 public:
52  TQString m_name;
53  TQString m_command;
54  DrMain *m_driver;
55  struct
56  {
57  TQString m_format[2]; // 0 -> file, 1 -> pipe
58  } m_io[2]; // 0 -> input, 1 -> output
59  TQString m_description;
60  TQString m_outputMime;
61  TQStringList m_inputMime;
62  TQStringList m_requirements;
63  bool m_loaded[2]; // 0 -> Desktop, 1 -> XML
64  TQString m_comment;
65 };
66 
67 KXmlCommand::KXmlCommand(const TQString& xmlId)
68 : TQObject(KXmlCommandManager::self(), "XmlCommand")
69 {
70  init();
71  d->m_name = xmlId;
72 }
73 
74 KXmlCommand::~KXmlCommand()
75 {
76  //kdDebug(500) << "deleting driver" << endl;
77  delete d->m_driver;
78  //kdDebug(500) << "deleting private data" << endl;
79  delete d;
80  //kdDebug(500) << "finished" << endl;
81 }
82 
83 void KXmlCommand::init()
84 {
85  d = new KXmlCommandPrivate;
86  d->m_driver = 0;
87  d->m_loaded[0] = d->m_loaded[1] = false;
88 }
89 
90 TQString KXmlCommand::name() const
91 { return d->m_name; }
92 
93 void KXmlCommand::setName(const TQString& s)
94 { d->m_name = s; }
95 
96 TQString KXmlCommand::command()
97 {
98  check(true);
99  return d->m_command;
100 }
101 
102 void KXmlCommand::setCommand(const TQString& s)
103 {
104  d->m_command = s;
105 }
106 
107 DrMain* KXmlCommand::driver()
108 {
109  check(true);
110  return d->m_driver;
111 }
112 
113 DrMain* KXmlCommand::takeDriver()
114 {
115  check(true);
116  DrMain *dr = d->m_driver;
117  d->m_driver = 0;
118  d->m_loaded[1] = false;
119  return dr;
120 }
121 
122 void KXmlCommand::setDriver(DrMain *driver)
123 {
124  delete d->m_driver;
125  d->m_driver = driver;
126 }
127 
128 TQString KXmlCommand::io(bool io_input, bool io_pipe)
129 {
130  check(true);
131  return d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)];
132 }
133 
134 void KXmlCommand::setIo(const TQString& s, bool io_input, bool io_pipe)
135 {
136  d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)] = s;
137 }
138 
139 TQString KXmlCommand::description()
140 {
141  check();
142  return d->m_description;
143 }
144 
145 void KXmlCommand::setDescription(const TQString& s)
146 {
147  d->m_description = s;
148 }
149 
150 TQString KXmlCommand::mimeType()
151 {
152  check();
153  return d->m_outputMime;
154 }
155 
156 void KXmlCommand::setMimeType(const TQString& s)
157 {
158  d->m_outputMime = s;
159 }
160 
161 bool KXmlCommand::acceptMimeType(const TQString& s)
162 {
163  check();
164  return (d->m_inputMime.find(s) != d->m_inputMime.end());
165 }
166 
167 TQStringList KXmlCommand::inputMimeTypes()
168 {
169  check();
170  return d->m_inputMime;
171 }
172 
173 void KXmlCommand::setInputMimeTypes(const TQStringList& l)
174 {
175  d->m_inputMime = l;
176 }
177 
178 TQStringList KXmlCommand::requirements()
179 {
180  check();
181  return d->m_requirements;
182 }
183 
184 void KXmlCommand::setRequirements(const TQStringList& l)
185 {
186  d->m_requirements = l;
187 }
188 
189 TQString KXmlCommand::comment()
190 {
191  check();
192  return d->m_comment;
193 }
194 
195 void KXmlCommand::setComment( const TQString& s )
196 {
197  d->m_comment = s;
198 }
199 
200 bool KXmlCommand::isValid()
201 {
202  return (!locate("data", "tdeprint/filters/"+name()+".desktop").isEmpty());
203 }
204 
205 void KXmlCommand::check(bool use_xml)
206 {
207  if (!d->m_loaded[0])
208  {
209  loadDesktop();
210  d->m_loaded[0] = true;
211  }
212  if (use_xml && !d->m_loaded[1])
213  {
214  loadXml();
215  d->m_loaded[1] = true;
216  }
217 }
218 
219 void KXmlCommand::loadDesktop()
220 {
221  KSimpleConfig conf(locate("data", "tdeprint/filters/"+name()+".desktop"));
222  conf.setGroup("TDE Print Filter Entry");
223  d->m_description = conf.readEntry("Comment");
224  d->m_outputMime = conf.readEntry("MimeTypeOut");
225  d->m_inputMime = conf.readListEntry("MimeTypeIn");
226  d->m_requirements = conf.readListEntry("Require");
227  d->m_comment = conf.readEntry( "Description" );
228 }
229 
230 void KXmlCommand::saveDesktop()
231 {
232  KSimpleConfig conf(locateLocal("data", "tdeprint/filters/"+name()+".desktop"));
233  conf.setGroup("TDE Print Filter Entry");
234  conf.writeEntry("Comment", d->m_description);
235  conf.writeEntry("MimeTypeIn", d->m_inputMime);
236  conf.writeEntry("MimeTypeOut", d->m_outputMime);
237  conf.writeEntry("Require", d->m_requirements);
238  conf.writeEntry( "Description", d->m_comment );
239 }
240 
241 void KXmlCommand::loadXml()
242 {
243  TQFile f(locate("data", "tdeprint/filters/"+name()+".xml"));
244  TQDomDocument doc;
245  if (f.open(IO_ReadOnly) && doc.setContent(&f) && doc.documentElement().tagName() == "kprintfilter")
246  {
247  TQDomElement e, docElem = doc.documentElement();
248  d->m_name = docElem.attribute("name");
249 
250  // command
251  e = docElem.namedItem("filtercommand").toElement();
252  if (!e.isNull())
253  d->m_command = e.attribute("data");
254 
255  // arguments
256  e = docElem.namedItem("filterargs").toElement();
257  if (!e.isNull())
258  {
259  d->m_driver = new DrMain;
260  d->m_driver->setName(d->m_name);
261  parseGroup(e, d->m_driver);
262  setOptionText(d->m_driver, d->m_description);
263  }
264 
265  // input/output
266  e = docElem.namedItem("filterinput").toElement();
267  if (!e.isNull())
268  parseIO(e, 0);
269  e = docElem.namedItem("filteroutput").toElement();
270  if (!e.isNull())
271  parseIO(e, 1);
272  }
273 }
274 
275 void KXmlCommand::parseIO(const TQDomElement& e, int n)
276 {
277  TQDomElement elem = e.firstChild().toElement();
278  while (!elem.isNull())
279  {
280  if (elem.tagName() == "filterarg")
281  {
282  int format = (elem.attribute("name") == "file" ? 0 : 1);
283  d->m_io[n].m_format[format] = elem.attribute("format");
284  }
285  elem = elem.nextSibling().toElement();
286  }
287 }
288 
289 DrGroup* KXmlCommand::parseGroup(const TQDomElement& e, DrGroup *grp)
290 {
291  if (!grp)
292  grp = new DrGroup;
293  grp->setName(e.attribute("name"));
294  setOptionText(grp, e.attribute("description"));
295 
296  TQDomElement elem = e.firstChild().toElement();
297  while (!elem.isNull())
298  {
299  if (elem.tagName() == "filterarg")
300  {
301  DrBase *opt = parseArgument(elem);
302  if (opt)
303  grp->addOption(opt);
304  }
305  else if (elem.tagName() == "filtergroup")
306  {
307  DrGroup *group = parseGroup(elem, 0);
308  if (group)
309  grp->addGroup(group);
310  }
311  elem = elem.nextSibling().toElement();
312  }
313 
314  return grp;
315 }
316 
317 DrBase* KXmlCommand::parseArgument(const TQDomElement& e)
318 {
319  DrBase *opt(0);
320  TQString type = e.attribute("type");
321 
322  if (type == "int" || type == "float")
323  {
324  if (type == "int")
325  opt = new DrIntegerOption;
326  else
327  opt = new DrFloatOption;
328  opt->set("minval", e.attribute("min"));
329  opt->set("maxval", e.attribute("max"));
330  }
331  else if (type == "string")
332  opt = new DrStringOption;
333  else if (type == "list" || type == "bool")
334  {
335  if (type == "list")
336  opt = new DrListOption;
337  else
338  opt = new DrBooleanOption;
339  DrListOption *lopt = static_cast<DrListOption*>(opt);
340  TQDomElement elem = e.firstChild().toElement();
341  while (!elem.isNull())
342  {
343  if (elem.tagName() == "value")
344  {
345  DrBase *choice = new DrBase;
346  choice->setName(elem.attribute("name"));
347  setOptionText(choice, elem.attribute("description"));
348  lopt->addChoice(choice);
349  }
350  elem = elem.nextSibling().toElement();
351  }
352  }
353  else
354  return 0;
355 
356  opt->setName("_kde-" + d->m_name + "-" + e.attribute("name"));
357  setOptionText(opt, e.attribute("description"));
358  opt->set("format", e.attribute("format"));
359  opt->set("default", e.attribute("default"));
360  opt->set( "persistent", e.attribute( "persistent" ) );
361  opt->setValueText(opt->get("default"));
362 
363  return opt;
364 }
365 
366 TQString KXmlCommand::buildCommand(const TQMap<TQString,TQString>& opts, bool pipein, bool pipeout)
367 {
368  check(true);
369 
370  TQString str, cmd = d->m_command;
371  TQString re( "%value" ), quotedRe( "'%value'" );
372 
373  if (d->m_driver)
374  {
375  TQMap<TQString,TQString> fopts;
376 
377  d->m_driver->setOptions(opts);
378  d->m_driver->getOptions(fopts, false);
379  for (TQMap<TQString,TQString>::ConstIterator it=fopts.begin(); it!=fopts.end(); ++it)
380  {
381  DrBase *dopt = d->m_driver->findOption(it.key());
382  if (dopt)
383  {
384  TQString format = dopt->get("format");
385  TQString value = dopt->valueText();
386  if ( format.find( quotedRe ) != -1 )
387  {
388  if ( ( value.right( 1 ) == "'" && value.left( 1 ) == "'" ) ||
389  ( value.right( 1 ) == "\"" && value.left( 1 ) == "\"" ) )
390  format.replace( quotedRe, value );
391  else
392  format.replace( re, value );
393  }
394  else
395  {
396  format.replace( re, TDEProcess::quote( dopt->valueText() ) );
397  }
398  str.append(format).append(" ");
399  }
400  }
401  cmd.replace("%filterargs", str);
402  }
403 
404  cmd.replace("%filterinput", d->m_io[0].m_format[(pipein?1:0)]);
405  cmd.replace("%filteroutput", d->m_io[1].m_format[(pipeout?1:0)]);
406 
407  return cmd;
408 }
409 
410 void KXmlCommand::setOptions(const TQMap<TQString,TQString>& opts)
411 {
412  if (opts.count() == 0)
413  return;
414  // force loading the driver if needed
415  if (driver())
416  d->m_driver->setOptions(opts);
417 }
418 
419 void KXmlCommand::getOptions(TQMap<TQString,TQString>& opts, bool incldef)
420 {
421  // force loading the driver
422  if (driver())
423  d->m_driver->getOptions(opts, incldef);
424 }
425 
426 void KXmlCommand::saveXml()
427 {
428  TQFile f(locateLocal("data", "tdeprint/filters/"+name()+".xml"));
429  if (!f.open(IO_WriteOnly))
430  return;
431 
432  TQDomDocument doc("kprintfilter");
433  TQDomElement root = doc.createElement("kprintfilter"), elem;
434 
435  root.setAttribute("name", d->m_name);
436  doc.appendChild(root);
437 
438  // command
439  elem = doc.createElement("filtercommand");
440  elem.setAttribute("data", d->m_command);
441  root.appendChild(elem);
442 
443  // options
444  if (d->m_driver)
445  {
446  elem = createGroup(doc, d->m_driver);
447  elem.setTagName("filterargs");
448  root.appendChild(elem);
449  }
450 
451  // IO
452  if (!(elem=createIO(doc, 0, "filterinput")).isNull())
453  root.appendChild(elem);
454  if (!(elem=createIO(doc, 1, "filteroutput")).isNull())
455  root.appendChild(elem);
456 
457  // save to file (and close it)
458  TQTextStream t(&f);
459  t << doc.toString();
460  f.close();
461 }
462 
463 TQDomElement KXmlCommand::createIO(TQDomDocument& doc, int n, const TQString& tag)
464 {
465  TQDomElement elem = doc.createElement(tag);
466  if (d->m_command.find("%"+tag) != -1)
467  {
468  for (int i=0; i<2; i++)
469  {
470  TQDomElement io = doc.createElement("filterarg");
471  io.setAttribute("name", (i ? "pipe" : "file"));
472  io.setAttribute("format", d->m_io[n].m_format[i]);
473  elem.appendChild(io);
474  }
475  }
476 
477  return elem;
478 }
479 
480 TQDomElement KXmlCommand::createGroup(TQDomDocument& doc, DrGroup *group)
481 {
482  TQDomElement elem = doc.createElement("filtergroup");
483  elem.setAttribute("name", group->name());
484  elem.setAttribute("description", group->get("text"));
485 
486  TQPtrListIterator<DrGroup> git(group->groups());
487  for (; git.current(); ++git)
488  elem.appendChild(createGroup(doc, git.current()));
489 
490  TQPtrListIterator<DrBase> oit(group->options());
491  for (; oit.current(); ++oit)
492  elem.appendChild(createElement(doc, oit.current()));
493 
494  return elem;
495 }
496 
497 TQDomElement KXmlCommand::createElement(TQDomDocument& doc, DrBase *opt)
498 {
499  TQDomElement elem = doc.createElement("filterarg");
500  TQString elemName = opt->name();
501  if (elemName.startsWith("_kde-"))
502  elemName.replace(0, name().length()+6, "");
503  elem.setAttribute("name", elemName);
504  elem.setAttribute("format", opt->get("format"));
505  elem.setAttribute("description", opt->get("text"));
506  elem.setAttribute("default", opt->get("default"));
507  elem.setAttribute( "persistent", opt->get( "persistent" ) == "1" ? "1" : "0");
508 
509  switch (opt->type())
510  {
511  case DrBase::String:
512  elem.setAttribute("type", "string");
513  break;
514  case DrBase::Integer:
515  case DrBase::Float:
516  elem.setAttribute("type", (opt->type() == DrBase::Integer ? "int" : "float"));
517  elem.setAttribute("min", opt->get("minval"));
518  elem.setAttribute("max", opt->get("maxval"));
519  break;
520  case DrBase::Boolean:
521  case DrBase::List:
522  elem.setAttribute("type", (opt->type() == DrBase::List ? "list" : "bool"));
523  {
524  TQPtrListIterator<DrBase> it(*(static_cast<DrListOption*>(opt)->choices()));
525  for (; it.current(); ++it)
526  {
527  TQDomElement chElem = doc.createElement("value");
528  chElem.setAttribute("name", it.current()->name());
529  chElem.setAttribute("description", it.current()->get("text"));
530  elem.appendChild(chElem);
531  }
532  }
533  break;
534  default:
535  break;
536  }
537 
538  return elem;
539 }
540 
541 //---------------------------------------------------------------------------------------------------
542 
543 class KXmlCommandManager::KXmlCommandManagerPrivate
544 {
545 public:
546  TQStringList m_cmdlist;
547  TQMap<TQString, TQValueList<KXmlCommand*> > m_mimemap;
548  TQMap<TQString, KXmlCommand*> m_cmdmap;
549 };
550 
551 KXmlCommandManager* KXmlCommandManager::m_self = 0;
552 
553 KXmlCommandManager* KXmlCommandManager::self()
554 {
555  if (!m_self)
556  {
557  m_self = new KXmlCommandManager;
558  TQ_CHECK_PTR(m_self);
559  }
560  return m_self;
561 }
562 
563 KXmlCommandManager::KXmlCommandManager()
564 : TQObject(KMFactory::self(), "XmlCommandManager")
565 {
566  d = new KXmlCommandManagerPrivate;
567 }
568 
569 KXmlCommandManager::~KXmlCommandManager()
570 {
571  cleanUp();
572  delete d;
573 }
574 
575 KXmlCommand* KXmlCommandManager::loadCommand(const TQString& xmlId, bool check)
576 {
577  if (check)
578  {
579  TQString desktopFile = locate("data", "tdeprint/filters/"+xmlId+".desktop");
580  if (desktopFile.isEmpty())
581  return 0;
582  }
583  return new KXmlCommand(xmlId);
584 }
585 
586 void KXmlCommandManager::saveCommand(KXmlCommand *xmlCmd)
587 {
588  xmlCmd->saveDesktop();
589  xmlCmd->saveXml();
590 
591  cleanUp();
592 }
593 
594 void KXmlCommandManager::cleanUp()
595 {
596  for (TQMap<TQString, KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
597  delete (*it);
598  d->m_cmdmap.clear();
599  d->m_mimemap.clear();
600  d->m_cmdlist.clear();
601 }
602 
603 void KXmlCommandManager::preload()
604 {
605  if (d->m_cmdmap.count() == 0)
606  {
607  commandList();
608  for (TQStringList::Iterator it=d->m_cmdlist.begin(); it!=d->m_cmdlist.end(); ++it)
609  {
610  KXmlCommand *xmlCmd = loadCommand(*it);
611  if (!xmlCmd) continue; // Error!
612 
613  TQStringList inputMime = xmlCmd->inputMimeTypes();
614  for (TQStringList::ConstIterator mime=inputMime.begin(); mime!=inputMime.end(); ++mime)
615  {
616  d->m_mimemap[*mime].append(xmlCmd);
617  d->m_cmdmap[*it] = xmlCmd;
618  }
619  }
620  }
621 }
622 
623 TQStringList KXmlCommandManager::commandList()
624 {
625  if (d->m_cmdlist.isEmpty())
626  {
627  TQStringList dirs = TDEGlobal::dirs()->findDirs("data", "tdeprint/filters/");
628 
629  for (TQStringList::ConstIterator it=dirs.begin(); it!=dirs.end(); ++it)
630  {
631  TQStringList list = TQDir(*it).entryList("*.desktop", TQDir::Files, TQDir::Unsorted);
632  for (TQStringList::ConstIterator it2=list.begin(); it2!=list.end(); ++it2)
633  {
634  TQString cmdName = (*it2).left((*it2).length()-8);
635  if (d->m_cmdlist.find(cmdName) == d->m_cmdlist.end())
636  d->m_cmdlist.append(cmdName);
637  }
638  }
639 
640  d->m_cmdlist.sort();
641  }
642 
643  return d->m_cmdlist;
644 }
645 
646 TQStringList KXmlCommandManager::commandListWithDescription()
647 {
648  preload();
649  TQStringList l;
650  for (TQMap<TQString,KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
651  l << (*it)->name() << (*it)->description();
652 
653  return l;
654 }
655 
656 TQString KXmlCommandManager::selectCommand(TQWidget *parent)
657 {
658  KLibrary *lib = KLibLoader::self()->library( "libtdeprint_management_module" );
659  if ( !lib )
660  {
661  KMessageBox::error( parent, i18n( "Unable to load TDE print management library: %1" ).arg( KLibLoader::self()->lastErrorMessage() ) );
662  return TQString::null;
663  }
664  else
665  {
666  TQString ( *func )( TQWidget* ) = ( TQString( * )( TQWidget* ) )lib->symbol( "select_command" );
667  if ( !func )
668  {
669  KMessageBox::error( parent, i18n( "Unable to find wizard object in management library." ) );
670  return TQString::null;
671  }
672  else
673  return func( parent );
674  }
675 }
676 
677 KXmlCommand* KXmlCommandManager::command(const TQString& xmlId) const
678 {
679  return (d->m_cmdmap.contains(xmlId) ? d->m_cmdmap[xmlId] : 0);
680 }
681 
682 int KXmlCommandManager::insertCommand(TQStringList& list, const TQString& filtername, bool defaultToStart)
683 {
684  preload();
685 
686  int pos(0);
687  KXmlCommand *f1 = command(filtername), *f2 = 0;
688  if (f1 && f1->inputMimeTypes().count() > 0)
689  {
690  TQString mimetype = f1->inputMimeTypes()[0];
691  for (TQStringList::Iterator it=list.begin(); it!=list.end(); ++it, pos++)
692  {
693  f2 = command(*it);
694  if (!f2)
695  return -1; // Shouldn't happen
696 
697  if (f2->acceptMimeType(f1->mimeType()) && f1->acceptMimeType(mimetype))
698  {
699  list.insert(it, filtername);
700  break;
701  }
702  else
703  {
704  mimetype = f2->mimeType();
705  f2 = 0;
706  }
707  }
708  if (pos == (int)(list.count()))
709  {
710  if (list.count() == 0 || f1->acceptMimeType(mimetype))
711  list.append(filtername);
712  else if (defaultToStart)
713  {
714  pos = 0;
715  list.prepend(filtername);
716  }
717  else
718  pos = -1;
719  }
720  }
721  return pos;
722 }
723 
724 TQStringList KXmlCommandManager::autoConvert(const TQString& mimesrc, const TQString& mimedest)
725 {
726  TQStringList chain;
727  uint score(0);
728 
729  preload();
730 
731  if (d->m_mimemap.contains(mimesrc))
732  {
733  const TQValueList<KXmlCommand*> l = d->m_mimemap[mimesrc];
734  for (TQValueList<KXmlCommand*>::ConstIterator it=l.begin(); it!=l.end(); ++it)
735  {
736  // check filter availability
737  if (!KdeprintChecker::check((*it)->requirements()))
738  continue;
739 
740  // direct filter: shortest path => return immediately
741  if ((*it)->mimeType() == mimedest)
742  {
743  chain = TQStringList((*it)->name());
744  break;
745  }
746  // non direct filter: find the shortest way between
747  // its output and mimedest (do not consider cyling filters)
748  else if ((*it)->mimeType() != mimesrc)
749  {
750  TQStringList subchain = autoConvert((*it)->mimeType(), mimedest);
751  // If chain length is 0, then there's no possible filter between those 2
752  // mime types. Just discard it. If the subchain contains also the current
753  // considered filter, then discard it: it denotes of a cycle in filter
754  // chain.
755  if (subchain.count() > 0 && subchain.findIndex((*it)->name()) == -1)
756  {
757  subchain.prepend((*it)->name());
758  if (subchain.count() < score || score == 0)
759  {
760  chain = subchain;
761  score = subchain.count();
762  }
763  }
764  }
765  }
766  }
767  // At this point, either we have the shortest path, or empty
768  // list if nothing could be found
769  return chain;
770 }
771 
772 bool KXmlCommandManager::checkCommand(const TQString& xmlId, int inputCheck, int outputCheck, TQString *msg)
773 {
774  KXmlCommand *xmlCmd = command(xmlId);
775  TQString errmsg;
776  bool needDestroy(false);
777  //kdDebug(500) << "checking command: " << xmlId << " (" << (xmlCmd != NULL) << ")" << endl;
778  if (!xmlCmd)
779  {
780  xmlCmd = loadCommand(xmlId, true);
781  needDestroy = (xmlCmd != 0);
782  }
783 
784  bool status(true);
785  if (xmlCmd)
786  {
787  status = (xmlCmd->isValid() && KdeprintChecker::check(xmlCmd->requirements()));
788  if (!status)
789  errmsg = i18n("One of the command object's requirements is not met.");
790  }
791  TQString cmd = (xmlCmd ? xmlCmd->command() : xmlId);
792  if (status && !cmd.isEmpty() && (inputCheck > None || outputCheck > None))
793  {
794  if (inputCheck > None && (cmd.find("%in") == -1 || inputCheck == Advanced) && cmd.find("%filterinput") == -1)
795  {
796  status = false;
797  errmsg = i18n("The command does not contain the required tag %1.").arg(inputCheck == Advanced ? "%filterinput" : "{%in,%filterinput}");
798  }
799  if (status && outputCheck > None && (cmd.find("%out") == -1 || outputCheck == Advanced) && cmd.find("filteroutput") == -1)
800  {
801  status = false;
802  errmsg = i18n("The command does not contain the required tag %1.").arg(outputCheck == Advanced ? "%filteroutput" : "{%out,%filteroutput}");
803  }
804  }
805 
806  if (needDestroy)
807  delete xmlCmd;
808 
809  if (msg)
810  *msg = errmsg;
811 
812  return status;
813 }
814 
815 bool KXmlCommandManager::configure(KXmlCommand *xmlCmd, TQWidget *parent)
816 {
817  if (xmlCmd->driver())
818  {
819  KDialogBase dlg(parent, 0, true, xmlCmd->description(), KDialogBase::Ok);
820  DriverView view(&dlg);
821 
822  dlg.setMainWidget(&view);
823  view.setDriver(xmlCmd->driver());
824  dlg.resize(350,400);
825  dlg.exec();
826 
827  return true;
828  }
829  return false;
830 }

tdeprint

Skip menu "tdeprint"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

tdeprint

Skip menu "tdeprint"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeprint by doxygen 1.9.1
This website is maintained by Timothy Pearson.