summaryrefslogtreecommitdiffstats
path: root/tdeprint/kxmlcommand.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeprint/kxmlcommand.cpp
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeprint/kxmlcommand.cpp')
-rw-r--r--tdeprint/kxmlcommand.cpp830
1 files changed, 830 insertions, 0 deletions
diff --git a/tdeprint/kxmlcommand.cpp b/tdeprint/kxmlcommand.cpp
new file mode 100644
index 000000000..81dc5d3d5
--- /dev/null
+++ b/tdeprint/kxmlcommand.cpp
@@ -0,0 +1,830 @@
+/*
+ * This file is part of the KDE libraries
+ * Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ **/
+
+#include "kxmlcommand.h"
+#include "driver.h"
+#include "kmfactory.h"
+#include "tdeprintcheck.h"
+#include "driverview.h"
+
+#include <tqfile.h>
+#include <tqregexp.h>
+#include <tqdir.h>
+#include <tqinputdialog.h>
+#include <tqmap.h>
+#include <tqvaluelist.h>
+#include <kstandarddirs.h>
+#include <klocale.h>
+#include <ksimpleconfig.h>
+#include <kdialogbase.h>
+#include <kdebug.h>
+#include <kprocess.h>
+#include <klibloader.h>
+#include <kmessagebox.h>
+
+static void setOptionText(DrBase *opt, const TQString& s)
+{
+ if (s.isEmpty())
+ opt->set("text", opt->name());
+ else
+ opt->set("text", i18n(s.utf8()));
+}
+
+class KXmlCommand::KXmlCommandPrivate
+{
+public:
+ TQString m_name;
+ TQString m_command;
+ DrMain *m_driver;
+ struct
+ {
+ TQString m_format[2]; // 0 -> file, 1 -> pipe
+ } m_io[2]; // 0 -> input, 1 -> output
+ TQString m_description;
+ TQString m_outputMime;
+ TQStringList m_inputMime;
+ TQStringList m_requirements;
+ bool m_loaded[2]; // 0 -> Desktop, 1 -> XML
+ TQString m_comment;
+};
+
+KXmlCommand::KXmlCommand(const TQString& xmlId)
+: TQObject(KXmlCommandManager::self(), "XmlCommand")
+{
+ init();
+ d->m_name = xmlId;
+}
+
+KXmlCommand::~KXmlCommand()
+{
+ //kdDebug(500) << "deleting driver" << endl;
+ delete d->m_driver;
+ //kdDebug(500) << "deleting private data" << endl;
+ delete d;
+ //kdDebug(500) << "finished" << endl;
+}
+
+void KXmlCommand::init()
+{
+ d = new KXmlCommandPrivate;
+ d->m_driver = 0;
+ d->m_loaded[0] = d->m_loaded[1] = false;
+}
+
+TQString KXmlCommand::name() const
+{ return d->m_name; }
+
+void KXmlCommand::setName(const TQString& s)
+{ d->m_name = s; }
+
+TQString KXmlCommand::command()
+{
+ check(true);
+ return d->m_command;
+}
+
+void KXmlCommand::setCommand(const TQString& s)
+{
+ d->m_command = s;
+}
+
+DrMain* KXmlCommand::driver()
+{
+ check(true);
+ return d->m_driver;
+}
+
+DrMain* KXmlCommand::takeDriver()
+{
+ check(true);
+ DrMain *dr = d->m_driver;
+ d->m_driver = 0;
+ d->m_loaded[1] = false;
+ return dr;
+}
+
+void KXmlCommand::setDriver(DrMain *driver)
+{
+ delete d->m_driver;
+ d->m_driver = driver;
+}
+
+TQString KXmlCommand::io(bool io_input, bool io_pipe)
+{
+ check(true);
+ return d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)];
+}
+
+void KXmlCommand::setIo(const TQString& s, bool io_input, bool io_pipe)
+{
+ d->m_io[(io_input?0:1)].m_format[(io_pipe?1:0)] = s;
+}
+
+TQString KXmlCommand::description()
+{
+ check();
+ return d->m_description;
+}
+
+void KXmlCommand::setDescription(const TQString& s)
+{
+ d->m_description = s;
+}
+
+TQString KXmlCommand::mimeType()
+{
+ check();
+ return d->m_outputMime;
+}
+
+void KXmlCommand::setMimeType(const TQString& s)
+{
+ d->m_outputMime = s;
+}
+
+bool KXmlCommand::acceptMimeType(const TQString& s)
+{
+ check();
+ return (d->m_inputMime.find(s) != d->m_inputMime.end());
+}
+
+TQStringList KXmlCommand::inputMimeTypes()
+{
+ check();
+ return d->m_inputMime;
+}
+
+void KXmlCommand::setInputMimeTypes(const TQStringList& l)
+{
+ d->m_inputMime = l;
+}
+
+TQStringList KXmlCommand::requirements()
+{
+ check();
+ return d->m_requirements;
+}
+
+void KXmlCommand::setRequirements(const TQStringList& l)
+{
+ d->m_requirements = l;
+}
+
+TQString KXmlCommand::comment()
+{
+ check();
+ return d->m_comment;
+}
+
+void KXmlCommand::setComment( const TQString& s )
+{
+ d->m_comment = s;
+}
+
+bool KXmlCommand::isValid()
+{
+ return (!locate("data", "tdeprint/filters/"+name()+".desktop").isEmpty());
+}
+
+void KXmlCommand::check(bool use_xml)
+{
+ if (!d->m_loaded[0])
+ {
+ loadDesktop();
+ d->m_loaded[0] = true;
+ }
+ if (use_xml && !d->m_loaded[1])
+ {
+ loadXml();
+ d->m_loaded[1] = true;
+ }
+}
+
+void KXmlCommand::loadDesktop()
+{
+ KSimpleConfig conf(locate("data", "tdeprint/filters/"+name()+".desktop"));
+ conf.setGroup("KDE Print Filter Entry");
+ d->m_description = conf.readEntry("Comment");
+ d->m_outputMime = conf.readEntry("MimeTypeOut");
+ d->m_inputMime = conf.readListEntry("MimeTypeIn");
+ d->m_requirements = conf.readListEntry("Require");
+ d->m_comment = conf.readEntry( "Description" );
+}
+
+void KXmlCommand::saveDesktop()
+{
+ KSimpleConfig conf(locateLocal("data", "tdeprint/filters/"+name()+".desktop"));
+ conf.setGroup("KDE Print Filter Entry");
+ conf.writeEntry("Comment", d->m_description);
+ conf.writeEntry("MimeTypeIn", d->m_inputMime);
+ conf.writeEntry("MimeTypeOut", d->m_outputMime);
+ conf.writeEntry("Require", d->m_requirements);
+ conf.writeEntry( "Description", d->m_comment );
+}
+
+void KXmlCommand::loadXml()
+{
+ TQFile f(locate("data", "tdeprint/filters/"+name()+".xml"));
+ TQDomDocument doc;
+ if (f.open(IO_ReadOnly) && doc.setContent(&f) && doc.documentElement().tagName() == "kprintfilter")
+ {
+ TQDomElement e, docElem = doc.documentElement();
+ d->m_name = docElem.attribute("name");
+
+ // command
+ e = docElem.namedItem("filtercommand").toElement();
+ if (!e.isNull())
+ d->m_command = e.attribute("data");
+
+ // arguments
+ e = docElem.namedItem("filterargs").toElement();
+ if (!e.isNull())
+ {
+ d->m_driver = new DrMain;
+ d->m_driver->setName(d->m_name);
+ parseGroup(e, d->m_driver);
+ setOptionText(d->m_driver, d->m_description);
+ }
+
+ // input/output
+ e = docElem.namedItem("filterinput").toElement();
+ if (!e.isNull())
+ parseIO(e, 0);
+ e = docElem.namedItem("filteroutput").toElement();
+ if (!e.isNull())
+ parseIO(e, 1);
+ }
+}
+
+void KXmlCommand::parseIO(const TQDomElement& e, int n)
+{
+ TQDomElement elem = e.firstChild().toElement();
+ while (!elem.isNull())
+ {
+ if (elem.tagName() == "filterarg")
+ {
+ int format = (elem.attribute("name") == "file" ? 0 : 1);
+ d->m_io[n].m_format[format] = elem.attribute("format");
+ }
+ elem = elem.nextSibling().toElement();
+ }
+}
+
+DrGroup* KXmlCommand::parseGroup(const TQDomElement& e, DrGroup *grp)
+{
+ if (!grp)
+ grp = new DrGroup;
+ grp->setName(e.attribute("name"));
+ setOptionText(grp, e.attribute("description"));
+
+ TQDomElement elem = e.firstChild().toElement();
+ while (!elem.isNull())
+ {
+ if (elem.tagName() == "filterarg")
+ {
+ DrBase *opt = parseArgument(elem);
+ if (opt)
+ grp->addOption(opt);
+ }
+ else if (elem.tagName() == "filtergroup")
+ {
+ DrGroup *group = parseGroup(elem, 0);
+ if (group)
+ grp->addGroup(group);
+ }
+ elem = elem.nextSibling().toElement();
+ }
+
+ return grp;
+}
+
+DrBase* KXmlCommand::parseArgument(const TQDomElement& e)
+{
+ DrBase *opt(0);
+ TQString type = e.attribute("type");
+
+ if (type == "int" || type == "float")
+ {
+ if (type == "int")
+ opt = new DrIntegerOption;
+ else
+ opt = new DrFloatOption;
+ opt->set("minval", e.attribute("min"));
+ opt->set("maxval", e.attribute("max"));
+ }
+ else if (type == "string")
+ opt = new DrStringOption;
+ else if (type == "list" || type == "bool")
+ {
+ if (type == "list")
+ opt = new DrListOption;
+ else
+ opt = new DrBooleanOption;
+ DrListOption *lopt = static_cast<DrListOption*>(opt);
+ TQDomElement elem = e.firstChild().toElement();
+ while (!elem.isNull())
+ {
+ if (elem.tagName() == "value")
+ {
+ DrBase *choice = new DrBase;
+ choice->setName(elem.attribute("name"));
+ setOptionText(choice, elem.attribute("description"));
+ lopt->addChoice(choice);
+ }
+ elem = elem.nextSibling().toElement();
+ }
+ }
+ else
+ return 0;
+
+ opt->setName("_kde-" + d->m_name + "-" + e.attribute("name"));
+ setOptionText(opt, e.attribute("description"));
+ opt->set("format", e.attribute("format"));
+ opt->set("default", e.attribute("default"));
+ opt->set( "persistent", e.attribute( "persistent" ) );
+ opt->setValueText(opt->get("default"));
+
+ return opt;
+}
+
+TQString KXmlCommand::buildCommand(const TQMap<TQString,TQString>& opts, bool pipein, bool pipeout)
+{
+ check(true);
+
+ TQString str, cmd = d->m_command;
+ TQString re( "%value" ), quotedRe( "'%value'" );
+
+ if (d->m_driver)
+ {
+ TQMap<TQString,TQString> fopts;
+
+ d->m_driver->setOptions(opts);
+ d->m_driver->getOptions(fopts, false);
+ for (TQMap<TQString,TQString>::ConstIterator it=fopts.begin(); it!=fopts.end(); ++it)
+ {
+ DrBase *dopt = d->m_driver->findOption(it.key());
+ if (dopt)
+ {
+ TQString format = dopt->get("format");
+ TQString value = dopt->valueText();
+ if ( format.find( quotedRe ) != -1 )
+ {
+ if ( ( value.right( 1 ) == "'" && value.left( 1 ) == "'" ) ||
+ ( value.right( 1 ) == "\"" && value.left( 1 ) == "\"" ) )
+ format.replace( quotedRe, value );
+ else
+ format.replace( re, value );
+ }
+ else
+ {
+ format.replace( re, KProcess::quote( dopt->valueText() ) );
+ }
+ str.append(format).append(" ");
+ }
+ }
+ cmd.replace("%filterargs", str);
+ }
+
+ cmd.replace("%filterinput", d->m_io[0].m_format[(pipein?1:0)]);
+ cmd.replace("%filteroutput", d->m_io[1].m_format[(pipeout?1:0)]);
+
+ return cmd;
+}
+
+void KXmlCommand::setOptions(const TQMap<TQString,TQString>& opts)
+{
+ if (opts.count() == 0)
+ return;
+ // force loading the driver if needed
+ if (driver())
+ d->m_driver->setOptions(opts);
+}
+
+void KXmlCommand::getOptions(TQMap<TQString,TQString>& opts, bool incldef)
+{
+ // force loading the driver
+ if (driver())
+ d->m_driver->getOptions(opts, incldef);
+}
+
+void KXmlCommand::saveXml()
+{
+ TQFile f(locateLocal("data", "tdeprint/filters/"+name()+".xml"));
+ if (!f.open(IO_WriteOnly))
+ return;
+
+ TQDomDocument doc("kprintfilter");
+ TQDomElement root = doc.createElement("kprintfilter"), elem;
+
+ root.setAttribute("name", d->m_name);
+ doc.appendChild(root);
+
+ // command
+ elem = doc.createElement("filtercommand");
+ elem.setAttribute("data", d->m_command);
+ root.appendChild(elem);
+
+ // options
+ if (d->m_driver)
+ {
+ elem = createGroup(doc, d->m_driver);
+ elem.setTagName("filterargs");
+ root.appendChild(elem);
+ }
+
+ // IO
+ if (!(elem=createIO(doc, 0, "filterinput")).isNull())
+ root.appendChild(elem);
+ if (!(elem=createIO(doc, 1, "filteroutput")).isNull())
+ root.appendChild(elem);
+
+ // save to file (and close it)
+ TQTextStream t(&f);
+ t << doc.toString();
+ f.close();
+}
+
+TQDomElement KXmlCommand::createIO(TQDomDocument& doc, int n, const TQString& tag)
+{
+ TQDomElement elem = doc.createElement(tag);
+ if (d->m_command.find("%"+tag) != -1)
+ {
+ for (int i=0; i<2; i++)
+ {
+ TQDomElement io = doc.createElement("filterarg");
+ io.setAttribute("name", (i ? "pipe" : "file"));
+ io.setAttribute("format", d->m_io[n].m_format[i]);
+ elem.appendChild(io);
+ }
+ }
+
+ return elem;
+}
+
+TQDomElement KXmlCommand::createGroup(TQDomDocument& doc, DrGroup *group)
+{
+ TQDomElement elem = doc.createElement("filtergroup");
+ elem.setAttribute("name", group->name());
+ elem.setAttribute("description", group->get("text"));
+
+ TQPtrListIterator<DrGroup> git(group->groups());
+ for (; git.current(); ++git)
+ elem.appendChild(createGroup(doc, git.current()));
+
+ TQPtrListIterator<DrBase> oit(group->options());
+ for (; oit.current(); ++oit)
+ elem.appendChild(createElement(doc, oit.current()));
+
+ return elem;
+}
+
+TQDomElement KXmlCommand::createElement(TQDomDocument& doc, DrBase *opt)
+{
+ TQDomElement elem = doc.createElement("filterarg");
+ TQString elemName = opt->name();
+ if (elemName.startsWith("_kde-"))
+ elemName.replace(0, name().length()+6, "");
+ elem.setAttribute("name", elemName);
+ elem.setAttribute("format", opt->get("format"));
+ elem.setAttribute("description", opt->get("text"));
+ elem.setAttribute("default", opt->get("default"));
+ elem.setAttribute( "persistent", opt->get( "persistent" ) == "1" ? "1" : "0");
+
+ switch (opt->type())
+ {
+ case DrBase::String:
+ elem.setAttribute("type", "string");
+ break;
+ case DrBase::Integer:
+ case DrBase::Float:
+ elem.setAttribute("type", (opt->type() == DrBase::Integer ? "int" : "float"));
+ elem.setAttribute("min", opt->get("minval"));
+ elem.setAttribute("max", opt->get("maxval"));
+ break;
+ case DrBase::Boolean:
+ case DrBase::List:
+ elem.setAttribute("type", (opt->type() == DrBase::List ? "list" : "bool"));
+ {
+ TQPtrListIterator<DrBase> it(*(static_cast<DrListOption*>(opt)->choices()));
+ for (; it.current(); ++it)
+ {
+ TQDomElement chElem = doc.createElement("value");
+ chElem.setAttribute("name", it.current()->name());
+ chElem.setAttribute("description", it.current()->get("text"));
+ elem.appendChild(chElem);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ return elem;
+}
+
+//---------------------------------------------------------------------------------------------------
+
+class KXmlCommandManager::KXmlCommandManagerPrivate
+{
+public:
+ TQStringList m_cmdlist;
+ TQMap<TQString, TQValueList<KXmlCommand*> > m_mimemap;
+ TQMap<TQString, KXmlCommand*> m_cmdmap;
+};
+
+KXmlCommandManager* KXmlCommandManager::m_self = 0;
+
+KXmlCommandManager* KXmlCommandManager::self()
+{
+ if (!m_self)
+ {
+ m_self = new KXmlCommandManager;
+ Q_CHECK_PTR(m_self);
+ }
+ return m_self;
+}
+
+KXmlCommandManager::KXmlCommandManager()
+: TQObject(KMFactory::self(), "XmlCommandManager")
+{
+ d = new KXmlCommandManagerPrivate;
+}
+
+KXmlCommandManager::~KXmlCommandManager()
+{
+ cleanUp();
+ delete d;
+}
+
+KXmlCommand* KXmlCommandManager::loadCommand(const TQString& xmlId, bool check)
+{
+ if (check)
+ {
+ TQString desktopFile = locate("data", "tdeprint/filters/"+xmlId+".desktop");
+ if (desktopFile.isEmpty())
+ return 0;
+ }
+ return new KXmlCommand(xmlId);
+}
+
+void KXmlCommandManager::saveCommand(KXmlCommand *xmlCmd)
+{
+ xmlCmd->saveDesktop();
+ xmlCmd->saveXml();
+
+ cleanUp();
+}
+
+void KXmlCommandManager::cleanUp()
+{
+ for (TQMap<TQString, KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
+ delete (*it);
+ d->m_cmdmap.clear();
+ d->m_mimemap.clear();
+ d->m_cmdlist.clear();
+}
+
+void KXmlCommandManager::preload()
+{
+ if (d->m_cmdmap.count() == 0)
+ {
+ commandList();
+ for (TQStringList::Iterator it=d->m_cmdlist.begin(); it!=d->m_cmdlist.end(); ++it)
+ {
+ KXmlCommand *xmlCmd = loadCommand(*it);
+ if (!xmlCmd) continue; // Error!
+
+ TQStringList inputMime = xmlCmd->inputMimeTypes();
+ for (TQStringList::ConstIterator mime=inputMime.begin(); mime!=inputMime.end(); ++mime)
+ {
+ d->m_mimemap[*mime].append(xmlCmd);
+ d->m_cmdmap[*it] = xmlCmd;
+ }
+ }
+ }
+}
+
+TQStringList KXmlCommandManager::commandList()
+{
+ if (d->m_cmdlist.isEmpty())
+ {
+ TQStringList dirs = KGlobal::dirs()->findDirs("data", "tdeprint/filters/");
+
+ for (TQStringList::ConstIterator it=dirs.begin(); it!=dirs.end(); ++it)
+ {
+ TQStringList list = TQDir(*it).entryList("*.desktop", TQDir::Files, TQDir::Unsorted);
+ for (TQStringList::ConstIterator it2=list.begin(); it2!=list.end(); ++it2)
+ {
+ TQString cmdName = (*it2).left((*it2).length()-8);
+ if (d->m_cmdlist.find(cmdName) == d->m_cmdlist.end())
+ d->m_cmdlist.append(cmdName);
+ }
+ }
+
+ d->m_cmdlist.sort();
+ }
+
+ return d->m_cmdlist;
+}
+
+TQStringList KXmlCommandManager::commandListWithDescription()
+{
+ preload();
+ TQStringList l;
+ for (TQMap<TQString,KXmlCommand*>::ConstIterator it=d->m_cmdmap.begin(); it!=d->m_cmdmap.end(); ++it)
+ l << (*it)->name() << (*it)->description();
+
+ return l;
+}
+
+TQString KXmlCommandManager::selectCommand(TQWidget *parent)
+{
+ KLibrary *lib = KLibLoader::self()->library( "libtdeprint_management_module" );
+ if ( !lib )
+ {
+ KMessageBox::error( parent, i18n( "Unable to load KDE print management library: %1" ).arg( KLibLoader::self()->lastErrorMessage() ) );
+ return TQString::null;
+ }
+ else
+ {
+ TQString ( *func )( TQWidget* ) = ( TQString( * )( TQWidget* ) )lib->symbol( "select_command" );
+ if ( !func )
+ {
+ KMessageBox::error( parent, i18n( "Unable to find wizard object in management library." ) );
+ return TQString::null;
+ }
+ else
+ return func( parent );
+ }
+}
+
+KXmlCommand* KXmlCommandManager::command(const TQString& xmlId) const
+{
+ return (d->m_cmdmap.contains(xmlId) ? d->m_cmdmap[xmlId] : 0);
+}
+
+int KXmlCommandManager::insertCommand(TQStringList& list, const TQString& filtername, bool defaultToStart)
+{
+ preload();
+
+ int pos(0);
+ KXmlCommand *f1 = command(filtername), *f2 = 0;
+ if (f1 && f1->inputMimeTypes().count() > 0)
+ {
+ TQString mimetype = f1->inputMimeTypes()[0];
+ for (TQStringList::Iterator it=list.begin(); it!=list.end(); ++it, pos++)
+ {
+ f2 = command(*it);
+ if (!f2)
+ return -1; // Shouldn't happen
+
+ if (f2->acceptMimeType(f1->mimeType()) && f1->acceptMimeType(mimetype))
+ {
+ list.insert(it, filtername);
+ break;
+ }
+ else
+ {
+ mimetype = f2->mimeType();
+ f2 = 0;
+ }
+ }
+ if (pos == (int)(list.count()))
+ {
+ if (list.count() == 0 || f1->acceptMimeType(mimetype))
+ list.append(filtername);
+ else if (defaultToStart)
+ {
+ pos = 0;
+ list.prepend(filtername);
+ }
+ else
+ pos = -1;
+ }
+ }
+ return pos;
+}
+
+TQStringList KXmlCommandManager::autoConvert(const TQString& mimesrc, const TQString& mimedest)
+{
+ TQStringList chain;
+ uint score(0);
+
+ preload();
+
+ if (d->m_mimemap.contains(mimesrc))
+ {
+ const TQValueList<KXmlCommand*> l = d->m_mimemap[mimesrc];
+ for (TQValueList<KXmlCommand*>::ConstIterator it=l.begin(); it!=l.end(); ++it)
+ {
+ // check filter availability
+ if (!KdeprintChecker::check((*it)->requirements()))
+ continue;
+
+ // direct filter: shortest path => return immediately
+ if ((*it)->mimeType() == mimedest)
+ {
+ chain = TQStringList((*it)->name());
+ break;
+ }
+ // non direct filter: find the shortest way between
+ // its output and mimedest (do not consider cyling filters)
+ else if ((*it)->mimeType() != mimesrc)
+ {
+ TQStringList subchain = autoConvert((*it)->mimeType(), mimedest);
+ // If chain length is 0, then there's no possible filter between those 2
+ // mime types. Just discard it. If the subchain contains also the current
+ // considered filter, then discard it: it denotes of a cycle in filter
+ // chain.
+ if (subchain.count() > 0 && subchain.findIndex((*it)->name()) == -1)
+ {
+ subchain.prepend((*it)->name());
+ if (subchain.count() < score || score == 0)
+ {
+ chain = subchain;
+ score = subchain.count();
+ }
+ }
+ }
+ }
+ }
+ // At this point, either we have the shortest path, or empty
+ // list if nothing could be found
+ return chain;
+}
+
+bool KXmlCommandManager::checkCommand(const TQString& xmlId, int inputCheck, int outputCheck, TQString *msg)
+{
+ KXmlCommand *xmlCmd = command(xmlId);
+ TQString errmsg;
+ bool needDestroy(false);
+ //kdDebug(500) << "checking command: " << xmlId << " (" << (xmlCmd != NULL) << ")" << endl;
+ if (!xmlCmd)
+ {
+ xmlCmd = loadCommand(xmlId, true);
+ needDestroy = (xmlCmd != 0);
+ }
+
+ bool status(true);
+ if (xmlCmd)
+ {
+ status = (xmlCmd->isValid() && KdeprintChecker::check(xmlCmd->requirements()));
+ if (!status)
+ errmsg = i18n("One of the command object's requirements is not met.");
+ }
+ TQString cmd = (xmlCmd ? xmlCmd->command() : xmlId);
+ if (status && !cmd.isEmpty() && (inputCheck > None || outputCheck > None))
+ {
+ if (inputCheck > None && (cmd.find("%in") == -1 || inputCheck == Advanced) && cmd.find("%filterinput") == -1)
+ {
+ status = false;
+ errmsg = i18n("The command does not contain the required tag %1.").arg(inputCheck == Advanced ? "%filterinput" : "{%in,%filterinput}");
+ }
+ if (status && outputCheck > None && (cmd.find("%out") == -1 || outputCheck == Advanced) && cmd.find("filteroutput") == -1)
+ {
+ status = false;
+ errmsg = i18n("The command does not contain the required tag %1.").arg(outputCheck == Advanced ? "%filteroutput" : "{%out,%filteroutput}");
+ }
+ }
+
+ if (needDestroy)
+ delete xmlCmd;
+
+ if (msg)
+ *msg = errmsg;
+
+ return status;
+}
+
+bool KXmlCommandManager::configure(KXmlCommand *xmlCmd, TQWidget *parent)
+{
+ if (xmlCmd->driver())
+ {
+ KDialogBase dlg(parent, 0, true, xmlCmd->description(), KDialogBase::Ok);
+ DriverView view(&dlg);
+
+ dlg.setMainWidget(&view);
+ view.setDriver(xmlCmd->driver());
+ dlg.resize(350,400);
+ dlg.exec();
+
+ return true;
+ }
+ return false;
+}