lprhandler.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "lprhandler.h"
00021 #include "kmprinter.h"
00022 #include "printcapentry.h"
00023 #include "kmmanager.h"
00024 #include "lprsettings.h"
00025 #include "driver.h"
00026
00027 #include <qfile.h>
00028 #include <qtextstream.h>
00029 #include <qvaluestack.h>
00030 #include <klocale.h>
00031
00032 #include <unistd.h>
00033
00034 LprHandler::LprHandler(const QString& name, KMManager *mgr)
00035 : m_name(name), m_manager(mgr)
00036 {
00037 }
00038
00039 LprHandler::~LprHandler()
00040 {
00041 }
00042
00043 bool LprHandler::validate(PrintcapEntry*)
00044 {
00045 return true;
00046 }
00047
00048 KMPrinter* LprHandler::createPrinter(PrintcapEntry *entry)
00049 {
00050 KMPrinter *prt = new KMPrinter;
00051 prt->setPrinterName(entry->name);
00052 prt->setName(entry->name);
00053 prt->setType(KMPrinter::Printer);
00054 return prt;
00055 }
00056
00057 bool LprHandler::completePrinter(KMPrinter *prt, PrintcapEntry *entry, bool)
00058 {
00059 prt->setDescription(i18n("Unknown (unrecognized entry)"));
00060 QString val = entry->field("lp");
00061 KURL uri;
00062 if (!val.isEmpty() && val != "/dev/null")
00063 {
00064 int p = val.find('@');
00065 if (p != -1)
00066 {
00067 prt->setLocation(i18n("Remote queue (%1) on %2").arg(val.left(p)).arg(val.mid(p+1)));
00068 uri.setProtocol("lpd");
00069 uri.setHost(val.mid(p+1));
00070 uri.setPath("/" + val.left(p));
00071 }
00072 else if ((p = val.find('%')) != -1)
00073 {
00074 prt->setLocation(i18n("Network printer (%1)").arg("socket"));
00075 uri.setProtocol("socket");
00076 uri.setHost(val.left(p));
00077 uri.setPort(val.mid(p+1).toInt());
00078 }
00079 else
00080 {
00081 prt->setLocation(i18n("Local printer on %1").arg(val));
00082 uri.setProtocol("parallel");
00083 uri.setPath(val);
00084 }
00085 }
00086 else if (!(val = entry->field("rp")).isEmpty())
00087 {
00088 QString rm = entry->has("rm") ?
00089 entry->field("rm") :
00090 LprSettings::self()->defaultRemoteHost();
00091 prt->setLocation(i18n("Remote queue (%1) on %2").arg(val).arg(rm));
00092 uri.setProtocol("lpd");
00093 uri.setHost(rm);
00094 uri.setPath("/" + val);
00095 }
00096 else
00097 prt->setLocation(i18n("Unknown (unrecognized entry)"));
00098 prt->setDevice(uri.url());
00099 return true;
00100 }
00101
00102 DrMain* LprHandler::loadDriver(KMPrinter*, PrintcapEntry*, bool)
00103 {
00104 manager()->setErrorMsg(i18n("Unrecognized entry."));
00105 return NULL;
00106 }
00107
00108 bool LprHandler::savePrinterDriver(KMPrinter*, PrintcapEntry*, DrMain*, bool*)
00109 {
00110 manager()->setErrorMsg(i18n("Unrecognized entry."));
00111 return false;
00112 }
00113
00114 DrMain* LprHandler::loadDbDriver(const QString&)
00115 {
00116 manager()->setErrorMsg(i18n("Unrecognized entry."));
00117 return NULL;
00118 }
00119
00120 PrintcapEntry* LprHandler::createEntry(KMPrinter *prt)
00121 {
00122
00123 KURL uri ( prt->device() );
00124 QString prot = uri.protocol();
00125 if (!prot.isEmpty() && prot != "parallel" && prot != "file" && prot != "lpd" && prot != "socket")
00126 {
00127 manager()->setErrorMsg(i18n("Unsupported backend: %1.").arg(prot));
00128 return NULL;
00129 }
00130 PrintcapEntry *entry = new PrintcapEntry;
00131 entry->comment = "# Default handler";
00132 if (prot == "lpd")
00133 {
00134 entry->addField("rm", Field::String, uri.host());
00135 QString rp = uri.path();
00136 if (rp[0] == '/')
00137 rp = rp.mid(1);
00138 entry->addField("rp", Field::String, rp);
00139
00140
00141 entry->addField("lp", Field::String, QString::null);
00142 }
00143 else if ( prot == "socket" )
00144 {
00145 QString lp = uri.host();
00146 if ( uri.port() == 0 )
00147 lp.append( "%9100" );
00148 else
00149 lp.append( "%" ).append( QString::number( uri.port() ) );
00150 }
00151 else
00152 {
00153 entry->addField("lp", Field::String, uri.path());
00154 }
00155 return entry;
00156 }
00157
00158 bool LprHandler::removePrinter(KMPrinter*, PrintcapEntry*)
00159 {
00160 return true;
00161 }
00162
00163 QString LprHandler::printOptions(KPrinter*)
00164 {
00165 return QString::null;
00166 }
00167
00168 void LprHandler::reset()
00169 {
00170 }
00171
00172 DrMain* LprHandler::loadToolDriver(const QString& filename)
00173 {
00174 QFile f(filename);
00175 if (f.open(IO_ReadOnly))
00176 {
00177 DrMain *driver = new DrMain;
00178 QValueStack<DrGroup*> groups;
00179 QTextStream t(&f);
00180 QStringList l;
00181 DrListOption *lopt(0);
00182 DrBase *opt(0);
00183
00184 groups.push(driver);
00185 driver->set("text", "Tool Driver");
00186 while (!t.atEnd())
00187 {
00188 l = QStringList::split('|', t.readLine().stripWhiteSpace(), false);
00189 if (l.count() == 0)
00190 continue;
00191 if (l[0] == "GROUP")
00192 {
00193 DrGroup *grp = new DrGroup;
00194 grp->setName(l[1]);
00195 grp->set("text", l[2]);
00196 groups.top()->addGroup(grp);
00197 groups.push(grp);
00198 }
00199 else if (l[0] == "ENDGROUP")
00200 {
00201 groups.pop();
00202 }
00203 else if (l[0] == "OPTION")
00204 {
00205 opt = 0;
00206 lopt = 0;
00207 if (l.count() > 3)
00208 {
00209 if (l[3] == "STRING")
00210 opt = new DrStringOption;
00211 else if (l[3] == "BOOLEAN")
00212 {
00213 lopt = new DrBooleanOption;
00214 opt = lopt;
00215 }
00216 }
00217 else
00218 {
00219 lopt = new DrListOption;
00220 opt = lopt;
00221 }
00222 if (opt)
00223 {
00224 opt->setName(l[1]);
00225 opt->set("text", l[2]);
00226 groups.top()->addOption(opt);
00227 }
00228 }
00229 else if (l[0] == "CHOICE" && lopt)
00230 {
00231 DrBase *ch = new DrBase;
00232 ch->setName(l[1]);
00233 ch->set("text", l[2]);
00234 lopt->addChoice(ch);
00235 }
00236 else if (l[0] == "DEFAULT" && opt)
00237 {
00238 opt->setValueText(l[1]);
00239 opt->set("default", l[1]);
00240 }
00241 }
00242 return driver;
00243 }
00244 return NULL;
00245 }
00246
00247 QString LprHandler::driverDirectory()
00248 {
00249 if (m_cacheddriverdir.isEmpty())
00250 m_cacheddriverdir = driverDirInternal();
00251 return m_cacheddriverdir;
00252 }
00253
00254 QString LprHandler::driverDirInternal()
00255 {
00256 return QString::null;
00257 }
00258
00259 QString LprHandler::locateDir(const QString& dirname, const QString& paths)
00260 {
00261 QStringList pathlist = QStringList::split(':', paths, false);
00262 for (QStringList::ConstIterator it=pathlist.begin(); it!=pathlist.end(); ++it)
00263 {
00264 QString testpath = *it + "/" + dirname;
00265 if (::access(QFile::encodeName(testpath), F_OK) == 0)
00266 return testpath;
00267 }
00268 return QString::null;
00269 }
This file is part of the documentation for kdeprint Library Version 3.3.90.