DrMain* ApsHandler::loadApsDriver(bool config)
{
DrMain *driver = loadToolDriver(locate("data", (config ? "tdeprint/apsdriver1" : "tdeprint/apsdriver2")));
if (driver)
driver->set("text", "APS Common Driver");
return driver;
}
DrMain* KMLpdManager::loadPrinterDriver(KMPrinter *printer, bool config)
{
PrintcapEntry *entry = findPrintcapEntry(printer->name());
if (!entry)
return NULL;
// check for printtool driver (only for configuration)
QString sd = entry->arg("sd"), dr(entry->comment(7));
if (QFile::exists(sd+"/postscript.cfg") && config && !dr.isEmpty())
{
QMap<QString,QString> map = loadPrinttoolCfgFile(sd+"/postscript.cfg");
PrinttoolEntry *ptentry = findPrinttoolEntry(dr);
if (!ptentry)
return NULL;
DrMain *dr = ptentry->createDriver();
dr->setOptions(map);
map = loadPrinttoolCfgFile(sd+"/general.cfg");
dr->setOptions(map);
map = loadPrinttoolCfgFile(sd+"/textonly.cfg");
dr->setOptions(map);
return dr;
}
// default
if (entry->m_comment.startsWith("##PRINTTOOL3##"))
setErrorMsg(i18n("No driver found (raw printer)"));
else
setErrorMsg(i18n("Printer type not recognized."));
return NULL;
}
DrMain* ApsHandler::loadDbDriver(const TQString& s)
{
int p = s.find('/');
DrMain *driver = loadApsDriver(true);
if (driver)
driver->set("gsdriver", s.mid(p+1));
return driver;
}
DrMain* LPRngToolHandler::loadDbDriver(const QString& s)
{
int p = s.find('/');
DrMain* driver = loadToolDriver(locate("data", "kdeprint/lprngtooldriver1"));
if (driver)
driver->set("driverID", s.mid(p+1));
return driver;
}
bool PPDLoader::putConstraint(const QString &opt1, const QString &opt2, const QString &ch1, const QString &ch2)
{
if(!m_option && m_groups.size() == 1)
{
DrMain *driver = static_cast< DrMain * >(m_groups.top());
driver->addConstraint(new DrConstraint(opt1, opt2, ch1, ch2));
}
return true;
}
DrMain *DrMain::cloneDriver()
{
DrMain *driver = static_cast< DrMain * >(clone());
QPtrListIterator< DrConstraint > cit(m_constraints);
for(; cit.current(); ++cit)
driver->addConstraint(new DrConstraint(*(cit.current())));
QDictIterator< DrPageSize > pit(m_pagesizes);
for(; pit.current(); ++pit)
driver->addPageSize(new DrPageSize(*(pit.current())));
return driver;
}
DrMain *PPDLoader::readFromFile(const QString &filename)
{
// Initialization
m_groups.clear();
m_option = NULL;
m_fonts.clear();
// Open driver file
QIODevice *d = KFilterDev::deviceForFile(filename);
if(d && d->open(IO_ReadOnly))
{
DrMain *driver = new DrMain;
bool result = true;
m_groups.push(driver);
kdeprint_ppdscanner_init(d);
if(kdeprint_ppdparse(this) != 0)
result = false;
kdeprint_ppdscanner_terminate(true);
if(result)
{
if(m_groups.size() > 1)
kdWarning(500) << "PPD syntax error, GROUP specification not correctly closed" << endl;
if(driver->has("foodata"))
{
Foomatic2Loader loader;
if(loader.readFromBuffer(driver->get("foodata")))
{
driver = loader.modifyDriver(driver);
}
else
kdWarning(500) << "PPD syntax error, Foomatic data read failed" << endl;
}
processPageSizes(driver);
if(!m_fonts.isEmpty())
driver->set("fonts", m_fonts.join(","));
return driver;
}
else
kdWarning(500) << "PPD syntax error, PPD parse failed" << endl;
delete driver;
m_ps.clear();
}
else
kdWarning(500) << "PPD read error, unable to open device for file " << filename << endl;
return 0;
}
void KXmlCommandAdvancedDlg::parseXmlCommand(KXmlCommand *xmlcmd)
{
m_view->clear();
TQListViewItem *root = new TQListViewItem(m_view, xmlcmd->name(), xmlcmd->name());
DrMain *driver = xmlcmd->driver();
root->setPixmap(0, SmallIcon("fileprint"));
root->setOpen(true);
if (driver)
{
DrMain *clone = driver->cloneDriver();
if (!clone->get("text").isEmpty())
root->setText(0, clone->get("text"));
root->setText(1, "__root__");
clone->setName("__root__");
m_opts["__root__"] = clone;
parseGroupItem(clone, root);
clone->flatten();
}
m_command->setText(xmlcmd->command());
m_inputfile->setText(xmlcmd->io(true, false));
m_inputpipe->setText(xmlcmd->io(true, true));
m_outputfile->setText(xmlcmd->io(false, false));
m_outputpipe->setText(xmlcmd->io(false, true));
m_comment->setText( xmlcmd->comment() );
viewItem(0);
}
bool KXmlCommandAdvancedDlg::editCommand(KXmlCommand *xmlcmd, TQWidget *parent)
{
if (!xmlcmd)
return false;
KDialogBase dlg(parent, 0, true, i18n("Command Edit for %1").arg(xmlcmd->name()), KDialogBase::Ok|KDialogBase::Cancel, KDialogBase::Ok, false);
KXmlCommandAdvancedDlg *xmldlg = new KXmlCommandAdvancedDlg(&dlg);
dlg.setMainWidget(xmldlg);
//dlg.enableButton(KDialogBase::Ok, false);
xmldlg->setCommand(xmlcmd);
if (dlg.exec())
{
xmlcmd->setCommand(xmldlg->m_command->text());
xmlcmd->setIo(xmldlg->m_inputfile->text(), true, false);
xmlcmd->setIo(xmldlg->m_inputpipe->text(), true, true);
xmlcmd->setIo(xmldlg->m_outputfile->text(), false, false);
xmlcmd->setIo(xmldlg->m_outputpipe->text(), false, true);
xmlcmd->setComment( xmldlg->m_comment->text().replace( TQRegExp( "\n" ), " " ) );
// need to recreate the driver tree structure
DrMain *driver = (xmldlg->m_opts.contains("__root__") ? static_cast<DrMain*>(xmldlg->m_opts["__root__"]) : 0);
if (!driver && xmldlg->m_opts.count() > 0)
{
kdDebug() << "KXmlCommandAdvancedDlg: driver structure not found, creating one" << endl;
driver = new DrMain;
driver->setName(xmlcmd->name());
}
xmldlg->recreateGroup(xmldlg->m_view->firstChild(), driver);
xmldlg->m_opts.remove("__root__");
xmlcmd->setDriver(driver);
// remaining options will be removed in destructor
return true;
}
return false;
}
DrMain* LPRngToolHandler::loadDriver(KMPrinter *prt, PrintcapEntry *entry, bool config)
{
if (entry->field("lprngtooloptions").isEmpty())
{
manager()->setErrorMsg(i18n("No driver defined for that printer. It might be a raw printer."));
return NULL;
}
DrMain* driver = loadToolDriver(locate("data", "kdeprint/lprngtooldriver1"));
if (driver)
{
QString model = prt->option("driverID");
driver->set("text", i18n("LPRngTool Common Driver (%1)").arg((model.isEmpty() ? i18n("unknown") : model)));
if (!model.isEmpty())
driver->set("driverID", model);
QMap<QString,QString> opts = parseZOptions(entry->field("prefix_z"));
opts["lpr"] = entry->field("lpr");
driver->setOptions(opts);
// if not configuring, don't show the "lpr" options
if (!config)
driver->removeOptionGlobally("lpr");
}
return driver;
}
void KMDriverDbWidget::slotOtherClicked()
{
if(m_external.isEmpty())
{
KFileDialog dlg(QString::null, QString::null, this, 0, true);
KURL url;
dlg.setMode(KFile::File);
dlg.setCaption(i18n("Select Driver"));
if(dlg.exec())
url = dlg.selectedURL();
if(!url.isEmpty())
{
QString filename;
if(KIO::NetAccess::download(url, filename, this))
{
DrMain *driver = KMFactory::self()->manager()->loadFileDriver(filename);
if(driver)
{
m_external = filename;
disconnect(m_manu, SIGNAL(highlighted(const QString &)), this, SLOT(slotManufacturerSelected(const QString &)));
m_manu->clear();
m_model->clear();
QString s = driver->get("manufacturer");
m_manu->insertItem((s.isEmpty() ? i18n("<Unknown>") : s));
s = driver->get("model");
m_model->insertItem((s.isEmpty() ? i18n("<Unknown>") : s));
m_manu->setCurrentItem(0);
m_model->setCurrentItem(0);
m_other->setText(i18n("Database"));
m_desc = driver->get("description");
delete driver;
}
else
{
DrMain* ApsHandler::loadDriver(KMPrinter *prt, PrintcapEntry *entry, bool config)
{
DrMain *driver = loadApsDriver(config);
if (driver /* && config */ ) // Load resources in all case, to get the correct page size
{
TQMap<TQString,TQString> opts = loadResources(entry);
if ( !config && opts.contains( "PAPERSIZE" ) )
{
// this is needed to keep applications informed
// about the current selected page size
opts[ "PageSize" ] = opts[ "PAPERSIZE" ];
// default page size needs to be set to the actual
// value of the printer driver, otherwise it's blocked
// to A4
DrBase *opt = driver->findOption( "PageSize" );
if ( opt )
opt->set( "default", opts[ "PageSize" ] );
}
driver->setOptions(opts);
driver->set("gsdriver", opts["PRINTER"]);
}
return driver;
}
DrMain* LprHandler::loadToolDriver(const QString& filename)
{
QFile f(filename);
if (f.open(IO_ReadOnly))
{
DrMain *driver = new DrMain;
QValueStack<DrGroup*> groups;
QTextStream t(&f);
QStringList l;
DrListOption *lopt(0);
DrBase *opt(0);
groups.push(driver);
driver->set("text", "Tool Driver");
while (!t.atEnd())
{
l = QStringList::split('|', t.readLine().stripWhiteSpace(), false);
if (l.count() == 0)
continue;
if (l[0] == "GROUP")
{
DrGroup *grp = new DrGroup;
grp->setName(l[1]);
grp->set("text", l[2]);
groups.top()->addGroup(grp);
groups.push(grp);
}
else if (l[0] == "ENDGROUP")
{
groups.pop();
}
else if (l[0] == "OPTION")
{
opt = 0;
lopt = 0;
if (l.count() > 3)
{
if (l[3] == "STRING")
opt = new DrStringOption;
else if (l[3] == "BOOLEAN")
{
lopt = new DrBooleanOption;
opt = lopt;
}
}
else
{
lopt = new DrListOption;
opt = lopt;
}
if (opt)
{
opt->setName(l[1]);
opt->set("text", l[2]);
groups.top()->addOption(opt);
}
}
else if (l[0] == "CHOICE" && lopt)
{
DrBase *ch = new DrBase;
ch->setName(l[1]);
ch->set("text", l[2]);
lopt->addChoice(ch);
}
else if (l[0] == "DEFAULT" && opt)
{
opt->setValueText(l[1]);
opt->set("default", l[1]);
}
}
return driver;
}
return NULL;
}
DrMain* Foomatic2Loader::buildDriver() const
{
if ( m_foodata.isEmpty() )
return NULL;
QVariant v = m_foodata.find( "VAR" ).data();
if ( !v.isNull() && v.type() == QVariant::Map )
{
DrMain *driver = new DrMain;
QMap<QString,DrGroup*> groups;
driver->set( "manufacturer", v.mapFind( "make" ).data().toString() );
driver->set( "model", v.mapFind( "model" ).data().toString() );
driver->set( "matic_printer", v.mapFind( "id" ).data().toString() );
driver->set( "matic_driver", v.mapFind( "driver" ).data().toString() );
driver->set( "text", QString( "%1 %2 (%3)" ).arg( driver->get( "manufacturer" ) ).arg( driver->get( "model" ) ).arg( driver->get( "matic_driver" ) ) );
if ( m_foodata.contains( "POSTPIPE" ) )
driver->set( "postpipe", m_foodata.find( "POSTPIPE" ).data().toString() );
v = v.mapFind( "args" ).data();
if ( !v.isNull() && v.type() == QVariant::List )
{
QValueList<QVariant>::ConstIterator it = v.listBegin();
for ( ; it!=v.listEnd(); ++it )
{
if ( ( *it ).type() != QVariant::Map )
continue;
DrBase *opt = createOption( ( *it ).toMap() );
if ( opt )
{
QString group = DrGroup::groupForOption( opt->name() );
DrGroup *grp = NULL;
if ( !groups.contains( group ) )
{
grp = new DrGroup;
grp->set( "text", group );
driver->addGroup( grp );
groups.insert( group, grp );
}
else
grp = groups[ group ];
grp->addOption( opt );
if ( opt->name() == "PageSize" )
{
// try to add the corresponding page sizes
QVariant choices = ( *it ).mapFind( "vals_byname" ).data();
QRegExp re( "(\\d+) +(\\d+)" );
if ( choices.type() == QVariant::Map )
{
QMap<QString,QVariant>::ConstIterator it = choices.mapBegin();
for ( ; it!=choices.mapEnd(); ++it )
{
QString driverval = ( *it ).mapFind( "driverval" ).data().toString();
if ( re.exactMatch( driverval ) )
{
driver->addPageSize( new DrPageSize( it.key(), re.cap( 1 ).toInt(), re.cap( 2 ).toInt(), 36, 24, 36, 24 ) );
}
}
}
}
}
else
kdWarning( 500 ) << "Failed to create option: " << ( *it ).toMap()[ "name" ].toString() << endl;
}
}
return driver;
}
return NULL;
}
PrintcapEntry* LPRngToolHandler::createEntry(KMPrinter *prt)
{
QString prot = prt->deviceProtocol();
if (prot != "parallel" && prot != "lpd" && prot != "smb" && prot != "socket")
{
manager()->setErrorMsg(i18n("Unsupported backend: %1.").arg(prot));
return NULL;
}
PrintcapEntry *entry = new PrintcapEntry;
entry->addField("cm", Field::String, prt->description());
QString lp, comment("##LPRNGTOOL## ");
if (prot == "parallel")
{
comment.append("DEVICE ");
lp = prt->device().mid( 9 );
entry->addField("rw@", Field::Boolean);
}
else if (prot == "socket")
{
comment.append("SOCKET ");
KURL url( prt->device() );
lp = url.host();
if (url.port() == 0)
lp.append("%9100");
else
lp.append("%").append(QString::number(url.port()));
}
else if (prot == "lpd")
{
comment.append("QUEUE ");
KURL url( prt->device() );
lp = url.path().mid(1) + "@" + url.host();
}
else if (prot == "smb")
{
comment.append("SMB ");
lp = "| " + filterDir() + "/smbprint";
QString work, server, printer, user, passwd;
if ( splitSmbURI( prt->device(), work, server, printer, user, passwd ) )
{
entry->addField("xfer_options", Field::String, QString::fromLatin1("authfile=\"auth\" crlf=\"0\" hostip=\"\" host=\"%1\" printer=\"%2\" remote_mode=\"SMB\" share=\"//%3/%4\" workgroup=\"%5\"").arg(server).arg(printer).arg(server).arg(printer).arg(work));
QFile authfile(LprSettings::self()->baseSpoolDir() + "/" + prt->printerName() + "/auth");
if (authfile.open(IO_WriteOnly))
{
QTextStream t(&authfile);
t << "username="******"password="******"Invalid printer backend specification: %1" ).arg( prt->device() ) );
delete entry;
return NULL;
}
}
if (prt->driver())
{
DrMain *driver = prt->driver();
comment.append("filtertype=IFHP ifhp_options=status@,sync@,pagecount@,waitend@ printerdb_entry=");
comment.append(driver->get("driverID"));
entry->addField("ifhp", Field::String, QString::fromLatin1("model=%1,status@,sync@,pagecount@,waitend@").arg(driver->get("driverID")));
entry->addField("lprngtooloptions", Field::String, QString::fromLatin1("FILTERTYPE=\"IFHP\" IFHP_OPTIONS=\"status@,sync@,pagecount@,waitend@\" PRINTERDB_ENTRY=\"%1\"").arg(driver->get("driverID")));
QMap<QString,QString> opts;
QString optstr;
driver->getOptions(opts, false);
for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
if (it.key() != "lpr")
optstr.append(*it).append(",");
if (!optstr.isEmpty())
{
optstr.truncate(optstr.length()-1);
entry->addField("prefix_z", Field::String, optstr);
}
if (!opts["lpr"].isEmpty())
entry->addField("lpr", Field::String, opts["lpr"]);
}
entry->addField("lp", Field::String, lp);
entry->comment = comment;
return entry;
}
DrMain *PrinttoolEntry::createDriver()
{
// create driver
DrMain *dr = new DrMain();
dr->setName(m_name);
dr->set("description", m_description);
dr->set("text", m_description);
dr->set("drtype", "printtool");
DrGroup *gr(0);
DrListOption *lopt(0);
DrStringOption *sopt(0);
DrBooleanOption *bopt(0);
DrBase *ch(0);
if(m_gsdriver != "TEXT")
{
// create GS group
gr = new DrGroup();
gr->set("text", i18n("GhostScript settings"));
dr->addGroup(gr);
// Pseudo option to have access to GS driver
lopt = new DrListOption();
lopt->setName("GSDEVICE");
lopt->set("text", i18n("Driver"));
lopt->set("default", m_gsdriver);
gr->addOption(lopt);
ch = new DrBase();
ch->setName(m_gsdriver);
ch->set("text", m_gsdriver);
lopt->addChoice(ch);
lopt->setValueText(m_gsdriver);
// Resolutions
if(m_resolutions.count() > 0)
{
lopt = new DrListOption();
lopt->setName("RESOLUTION");
lopt->set("text", i18n("Resolution"));
gr->addOption(lopt);
QPtrListIterator< Resolution > it(m_resolutions);
for(int i = 0; it.current(); ++it, i++)
{
ch = new DrBase;
ch->setName(QString::fromLatin1("%1x%2").arg(it.current()->xdpi).arg(it.current()->ydpi));
if(it.current()->comment.isEmpty())
ch->set("text", QString::fromLatin1("%1x%2 DPI").arg(it.current()->xdpi).arg(it.current()->ydpi));
else
ch->set("text", QString::fromLatin1("%2x%3 DPI (%1)").arg(it.current()->comment).arg(it.current()->xdpi).arg(it.current()->ydpi));
lopt->addChoice(ch);
}
QString defval = lopt->choices()->first()->name();
lopt->set("default", defval);
lopt->setValueText(defval);
}
// BitsPerPixels
if(m_depths.count() > 0)
{
lopt = new DrListOption();
lopt->setName("COLOR");
lopt->set("text", i18n("Color depth"));
gr->addOption(lopt);
QPtrListIterator< BitsPerPixel > it(m_depths);
for(int i = 0; it.current(); ++it, i++)
{
ch = new DrBase;
if(m_gsdriver != "uniprint")
ch->setName(QString::fromLatin1("-dBitsPerPixel=%1").arg(it.current()->bpp));
else
ch->setName(it.current()->bpp);
if(it.current()->comment.isEmpty())
ch->set("text", it.current()->bpp);
else
ch->set("text", QString::fromLatin1("%1 - %2").arg(it.current()->bpp).arg(it.current()->comment));
lopt->addChoice(ch);
}
QString defval = lopt->choices()->first()->name();
lopt->set("default", defval);
lopt->setValueText(defval);
}
// additional GS options
sopt = new DrStringOption;
sopt->setName("EXTRA_GS_OPTIONS");
sopt->set("text", i18n("Additional GS options"));
gr->addOption(sopt);
}
// General group
gr = new DrGroup();
gr->set("text", i18n("General"));
dr->addGroup(gr);
// Page size
lopt = new DrListOption();
lopt->setName("PAPERSIZE");
lopt->set("text", i18n("Page size"));
lopt->set("default", "letter");
gr->addOption(lopt);
int i(0);
while(pt_pagesize[i])
{
ch = new DrBase();
ch->setName(pt_pagesize[i++]);
ch->set("text", i18n(pt_pagesize[i++]));
lopt->addChoice(ch);
}
lopt->setValueText("letter");
// Nup
lopt = new DrListOption();
lopt->setName("NUP");
lopt->set("text", i18n("Pages per sheet"));
lopt->set("default", "1");
gr->addOption(lopt);
i = 0;
while(pt_nup[i] != -1)
{
ch = new DrBase();
ch->setName(QString::number(pt_nup[i++]));
ch->set("text", ch->name());
lopt->addChoice(ch);
}
lopt->setValueText("1");
// Margins
sopt = new DrStringOption();
sopt->setName("RTLFTMAR");
sopt->set("text", i18n("Left/right margin (1/72 in)"));
sopt->setValueText("18");
gr->addOption(sopt);
sopt = new DrStringOption();
sopt->setName("TOPBOTMAR");
sopt->set("text", i18n("Top/bottom margin (1/72 in)"));
sopt->setValueText("18");
gr->addOption(sopt);
// Text group
gr = new DrGroup();
gr->set("text", i18n("Text options"));
dr->addGroup(gr);
// Send EOF
bopt = new DrBooleanOption();
bopt->setName("TEXT_SEND_EOF");
bopt->set("text", i18n("Send EOF after job to eject page"));
gr->addOption(bopt);
setupBooleanOption(bopt);
bopt->setValueText("NO");
// Fix stair-stepping
bopt = new DrBooleanOption();
bopt->setName("CRLFTRANS");
bopt->set("text", i18n("Fix stair-stepping text"));
gr->addOption(bopt);
setupBooleanOption(bopt);
bopt->choices()->first()->setName("1");
bopt->choices()->last()->setName("0");
bopt->setValueText("0");
if(m_gsdriver != "POSTSCRIPT")
{
// Fast text printing
bopt = new DrBooleanOption();
bopt->setName("ASCII_TO_PS");
bopt->set("text", i18n("Fast text printing (non-PS printers only)"));
gr->addOption(bopt);
setupBooleanOption(bopt);
bopt->choices()->first()->setName("NO");
bopt->choices()->last()->setName("YES");
bopt->setValueText("NO");
}
return dr;
}
DrMain *KMFoomaticManager::createDriverFromXML(QDomElement *elem)
{
DrMain *driver = new DrMain();
QDomElement pelem = elem->namedItem("printer").toElement(), delem = elem->namedItem("driver").toElement();
if(!pelem.isNull() && !delem.isNull())
{
driver->set("manufacturer", pelem.namedItem("make").toElement().text());
driver->set("model", pelem.namedItem("model").toElement().text());
QString s = QString::fromLatin1("%1 %2 (%3)")
.arg(driver->get("manufacturer"))
.arg(driver->get("model"))
.arg(delem.namedItem("name").toElement().text());
driver->set("description", s);
driver->set("text", s);
QDomElement opts = elem->namedItem("options").toElement();
if(!opts.isNull())
{
QDomElement o = opts.firstChild().toElement();
while(!o.isNull())
{
if(o.tagName() == "option")
{
QString type = o.attribute("type");
DrBase *dropt(0);
if(type == "bool" || type == "enum")
{
if(type == "bool")
dropt = new DrBooleanOption();
else
dropt = new DrListOption();
QString defval = o.namedItem("arg_defval").toElement().text(), valuetext;
QDomNode val = o.namedItem("enum_vals").firstChild();
while(!val.isNull())
{
DrBase *choice = new DrBase();
choice->setName(val.namedItem("ev_shortname").namedItem("en").toElement().text());
choice->set("text", i18n(val.namedItem("ev_longname").namedItem("en").toElement().text().latin1()));
static_cast< DrListOption * >(dropt)->addChoice(choice);
if(val.toElement().attribute("id") == defval)
valuetext = choice->name();
val = val.nextSibling();
}
dropt->set("default", valuetext);
dropt->setValueText(valuetext);
}
else if(type == "int" || type == "float")
{
if(type == "int")
dropt = new DrIntegerOption();
else
dropt = new DrFloatOption();
dropt->set("minval", o.namedItem("arg_min").toElement().text());
dropt->set("maxval", o.namedItem("arg_max").toElement().text());
QString defval = o.namedItem("arg_defval").toElement().text();
dropt->set("default", defval);
dropt->setValueText(defval);
}
if(dropt)
{
dropt->setName(o.namedItem("arg_shortname").namedItem("en").toElement().text());
dropt->set("text", i18n(o.namedItem("arg_longname").namedItem("en").toElement().text().latin1()));
driver->addOption(dropt);
}
}
o = o.nextSibling().toElement();
}
}
}
return driver;
}
void KPrinterImpl::preparePrinting(KPrinter *printer)
{
// page size -> try to find page size and margins from driver file
// use "PageSize" as option name to find the wanted page size. It's
// up to the driver loader to use that option name.
KMManager *mgr = KMFactory::self()->manager();
DrMain *driver = mgr->loadPrinterDriver(mgr->findPrinter(printer->printerName()), false);
if (driver)
{
// Find the page size:
// 1) print option
// 2) default driver option
QString psname = printer->option("PageSize");
if (psname.isEmpty())
{
DrListOption *opt = (DrListOption*)driver->findOption("PageSize");
if (opt) psname = opt->get("default");
}
if (!psname.isEmpty())
{
printer->setOption("kde-pagesize",TQString::number((int)pageNameToPageSize(psname)));
DrPageSize *ps = driver->findPageSize(psname);
if (ps)
{
printer->setRealPageSize( ps );
}
}
// Find the numerical resolution
// 1) print option (Resolution)
// 2) default driver option (Resolution)
// 3) default printer resolution
// The resolution must have the format: XXXdpi or XXXxYYYdpi. In the second
// case the YYY value is used as resolution.
TQString res = printer->option( "Resolution" );
if ( res.isEmpty() )
{
DrBase *opt = driver->findOption( "Resolution" );
if ( opt )
res = opt->get( "default" );
if ( res.isEmpty() )
res = driver->get( "resolution" );
}
if ( !res.isEmpty() )
{
TQRegExp re( "(\\d+)(?:x(\\d+))?dpi" );
if ( re.search( res ) != -1 )
{
if ( !re.cap( 2 ).isEmpty() )
printer->setOption( "kde-resolution", re.cap( 2 ) );
else
printer->setOption( "kde-resolution", re.cap( 1 ) );
}
}
// Find the supported fonts
TQString fonts = driver->get( "fonts" );
if ( !fonts.isEmpty() )
printer->setOption( "kde-fonts", fonts );
delete driver;
}
}
