kdeprint Library API Documentation

kprinter.cpp

00001 /*
00002  *  This file is part of the KDE libraries
00003  *  Copyright (c) 2001 Michael Goffioul <kdeprint@swing.be>
00004  *
00005  *  This library is free software; you can redistribute it and/or
00006  *  modify it under the terms of the GNU Library General Public
00007  *  License version 2 as published by the Free Software Foundation.
00008  *
00009  *  This library is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  *  Library General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU Library General Public License
00015  *  along with this library; see the file COPYING.LIB.  If not, write to
00016  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017  *  Boston, MA 02111-1307, USA.
00018  **/
00019 
00020 #include <config.h>
00021 
00022 #include "kprinter.h"
00023 #include "kprinterimpl.h"
00024 #include "kprintdialog.h"
00025 #include "kprintpreview.h"
00026 #include "kmfactory.h"
00027 #include "kmuimanager.h"
00028 #include "kmmanager.h"
00029 #include "driver.h"
00030 
00031 #include <qpaintdevicemetrics.h>
00032 #include <qfile.h>
00033 #include <qtl.h>
00034 #include <qdir.h>
00035 #include <qguardedptr.h>
00036 #include <kapplication.h>
00037 #include <kstandarddirs.h>
00038 #include <kglobal.h>
00039 #include <kconfig.h>
00040 #include <krun.h>
00041 #include <knotifyclient.h>
00042 #include <kdebug.h>
00043 #include <klocale.h>
00044 #include <kprocess.h>
00045 #include <klibloader.h>
00046 #include <kmessagebox.h>
00047 
00048 static void dumpOptions(const QMap<QString,QString>& opts);
00049 static void reportError(KPrinter*);
00050 
00051 //**************************************************************************************
00052 // KPrinterWrapper class
00053 //**************************************************************************************
00054 
00055 class KPrinterWrapper : public QPrinter
00056 {
00057 friend class KPrinter;
00058 public:
00059     KPrinterWrapper(KPrinter*, PrinterMode m = ScreenResolution);
00060     ~KPrinterWrapper();
00061 protected:
00062     virtual bool cmd(int, QPainter*, QPDevCmdParam*);
00063     virtual int metric(int) const;
00064     int qprinterMetric(int) const;
00065 private:
00066     KPrinter    *m_printer;
00067 };
00068 
00069 KPrinterWrapper::KPrinterWrapper(KPrinter *prt, QPrinter::PrinterMode m)
00070 : QPrinter(m), m_printer(prt)
00071 {
00072 }
00073 
00074 KPrinterWrapper::~KPrinterWrapper()
00075 {
00076 }
00077 
00078 bool KPrinterWrapper::cmd(int c, QPainter *painter, QPDevCmdParam *p)
00079 {
00080     return QPrinter::cmd(c,painter,p);
00081 }
00082 
00083 int KPrinterWrapper::metric(int m) const
00084 {
00085     return m_printer->metric(m);
00086 }
00087 
00088 int KPrinterWrapper::qprinterMetric(int m) const
00089 {
00090     return QPrinter::metric(m);
00091 }
00092 
00093 //**************************************************************************************
00094 // KPrinterPrivate class
00095 //**************************************************************************************
00096 
00097 class KPrinterPrivate
00098 {
00099 public:
00100     QGuardedPtr<KPrinterImpl>   m_impl;
00101     bool        m_restore;
00102     bool        m_previewonly;
00103     WId     m_parentId;
00104     QString     m_docfilename;
00105     QString m_docdirectory;
00106     KPrinterWrapper     *m_wrapper;
00107     QMap<QString,QString>   m_options;
00108     QString         m_tmpbuffer;
00109     QString         m_printername;
00110     QString         m_searchname;
00111     QString         m_errormsg;
00112     bool            m_ready;
00113     int     m_pagenumber;
00114     DrPageSize *m_pagesize;
00115     bool m_useprinterres;
00116     int m_defaultres;
00117 };
00118 
00119 //**************************************************************************************
00120 // KPrinter class
00121 //**************************************************************************************
00122 
00123 KPrinter::KPrinter(bool restore, QPrinter::PrinterMode m)
00124 : QPaintDevice(QInternal::Printer|QInternal::ExternalDevice)
00125 {
00126     init(restore, m);
00127 }
00128 
00129 KPrinter::~KPrinter()
00130 {
00131     // delete Wrapper object
00132     delete d->m_wrapper;
00133 
00134     // save current options
00135     if (d->m_restore)
00136         saveSettings();
00137 
00138     // delete private data (along any data allocated internally)
00139     delete d->m_pagesize;
00140     delete d;
00141 }
00142 
00143 void KPrinter::init(bool restore, QPrinter::PrinterMode m)
00144 {
00145     // Private data initialization
00146     d = new KPrinterPrivate;
00147     d->m_impl = KMFactory::self()->printerImplementation();
00148     d->m_restore = restore;
00149     d->m_previewonly = false;
00150     d->m_parentId = 0;
00151     d->m_pagesize = 0;
00152 
00153     // initialize QPrinter wrapper
00154     d->m_wrapper = new KPrinterWrapper(this, m);
00155 
00156     // other initialization
00157     d->m_tmpbuffer = d->m_impl->tempFile();
00158     d->m_ready = false;
00159     d->m_defaultres = d->m_wrapper->resolution();
00160     d->m_useprinterres = false;
00161 
00162     // reload options from implementation (static object)
00163     if (d->m_restore)
00164         loadSettings();
00165 }
00166 
00167 void KPrinter::loadSettings()
00168 {
00169     d->m_options = d->m_impl->loadOptions();
00170 
00171     // load the last printer used in the current process (if any)
00172     // and remove the corresponding entry in the option map, as it
00173     // is not needed anymore
00174     setSearchName(option("kde-searchname"));
00175     d->m_options.remove("kde-searchname");
00176 
00177     KConfig *conf = KGlobal::config(), *pconf = KMFactory::self()->printConfig();
00178     conf->setGroup("KPrinter Settings");
00179     pconf->setGroup("General");
00180 
00181     // load latest used printer from config file, if required in the options
00182     if (searchName().isEmpty() && pconf->readBoolEntry("UseLast", true))
00183         setSearchName(conf->readEntry("Printer"));
00184 
00185     // latest used print command
00186     setOption("kde-printcommand",conf->readPathEntry("PrintCommand"));
00187 
00188     // latest used document directory
00189     setDocDirectory( conf->readPathEntry( "DocDirectory" ) );
00190     setDocFileName( "print" );
00191 }
00192 
00193 void KPrinter::saveSettings()
00194 {
00195     if (d->m_impl)
00196     {
00197         setOption("kde-searchname", searchName());
00198         d->m_impl->saveOptions(d->m_options);
00199     }
00200 
00201     // save latest used printer to config file
00202     KConfig *conf = KGlobal::config();
00203     conf->setGroup("KPrinter Settings");
00204     conf->writeEntry("Printer",searchName());
00205     // latest used print command
00206     conf->writePathEntry("PrintCommand",option("kde-printcommand"));
00207 
00208     // latest used document directory
00209     if ( d->m_docdirectory.isEmpty() )
00210     {
00211         KURL url( outputFileName() );
00212         if ( url.isValid() )
00213             conf->writePathEntry( "DocDirectory", url.directory() );
00214     }
00215     else
00216         conf->writePathEntry( "DocDirectory", d->m_docdirectory );
00217 }
00218 
00219 bool KPrinter::setup(QWidget *parent, const QString& caption, bool forceExpand)
00220 {
00221     if (!kapp->authorize("print/dialog"))
00222     {
00223         autoConfigure(QString::null, parent);
00224         return true; // Just print it
00225     }
00226 
00227     if (parent)
00228         d->m_parentId = parent->winId();
00229 
00230     KPrintDialog    *dlg = KPrintDialog::printerDialog(this, parent, caption, forceExpand);
00231     bool    state = false;
00232     if (dlg)
00233     {
00234         state = dlg->exec();
00235         delete dlg;
00236     }
00237     return state;
00238 }
00239 
00240 void KPrinter::addStandardPage(int p)
00241 {
00242     KMFactory::self()->settings()->standardDialogPages |= p;
00243 }
00244 
00245 void KPrinter::removeStandardPage(int p)
00246 {
00247     KMFactory::self()->settings()->standardDialogPages &= (~p);
00248 }
00249 
00250 void KPrinter::addDialogPage(KPrintDialogPage *page)
00251 {
00252     KMFactory::self()->uiManager()->addPrintDialogPage(page);
00253 }
00254 
00255 void KPrinter::setPageSelection(PageSelectionType t)
00256 {
00257     KMFactory::self()->settings()->pageSelection = t;
00258 }
00259 
00260 KPrinter::PageSelectionType KPrinter::pageSelection()
00261 {
00262     return (PageSelectionType)KMFactory::self()->settings()->pageSelection;
00263 }
00264 
00265 void KPrinter::setApplicationType(ApplicationType t)
00266 {
00267     KMFactory::self()->settings()->application = t;
00268 }
00269 
00270 KPrinter::ApplicationType KPrinter::applicationType()
00271 {
00272     return (ApplicationType)KMFactory::self()->settings()->application;
00273 }
00274 
00275 bool KPrinter::cmd(int c, QPainter *painter, QPDevCmdParam *p)
00276 {
00277     bool value(true);
00278     if (c == QPaintDevice::PdcBegin)
00279     {
00280         d->m_impl->statusMessage(i18n("Initialization..."), this);
00281         d->m_pagenumber = 1;
00282         preparePrinting();
00283         d->m_impl->statusMessage(i18n("Generating print data: page %1").arg(d->m_pagenumber), this);
00284     }
00285     value = d->m_wrapper->cmd(c,painter,p);
00286     if (c == QPaintDevice::PdcEnd)
00287     {
00288         // this call should take care of everything (preview, output-to-file, filtering, ...)
00289         value = value && printFiles(QStringList(d->m_wrapper->outputFileName()),true);
00290         // reset "ready" state
00291         finishPrinting();
00292     }
00293     return value;
00294 }
00295 
00296 void KPrinter::translateQtOptions()
00297 {
00298     d->m_wrapper->setCreator(creator());
00299     d->m_wrapper->setDocName(docName());
00300     d->m_wrapper->setFullPage(fullPage());
00301     d->m_wrapper->setColorMode((QPrinter::ColorMode)colorMode());
00302     d->m_wrapper->setOrientation((QPrinter::Orientation)orientation());
00303     if ( !option( "kde-printsize" ).isEmpty() )
00304         d->m_wrapper->setPageSize( ( QPrinter::PageSize )option( "kde-printsize" ).toInt() );
00305     else
00306         d->m_wrapper->setPageSize((QPrinter::PageSize)pageSize());
00307     d->m_wrapper->setOutputToFile(true);
00308     d->m_wrapper->setOutputFileName(d->m_tmpbuffer);
00309     d->m_wrapper->setNumCopies(option("kde-qtcopies").isEmpty() ? 1 : option("kde-qtcopies").toInt());
00310     if (!option("kde-margin-top").isEmpty())
00311     {
00318         int res = resolution();
00319         d->m_wrapper->setMargins(
00320                 ( int )( ( option("kde-margin-top").toFloat() * res + 71 ) / 72 ),
00321                 ( int )( ( option("kde-margin-left").toFloat() * res + 71 ) / 72 ),
00322                 ( int )( ( option("kde-margin-bottom").toFloat() * res + 71 ) / 72 ),
00323                 ( int )( ( option("kde-margin-right").toFloat() * res + 71 ) / 72 ) );
00324     }
00325     else if ( d->m_pagesize != NULL )
00326     {
00327         int res = resolution();
00328         DrPageSize *ps = d->m_pagesize;
00329         int top = ( int )( ps->topMargin() * res + 71 ) / 72;
00330         int left = ( int )( ps->leftMargin() * res + 71 ) / 72;
00331         int bottom = ( int )( ps->bottomMargin() * res + 71 ) / 72;
00332         int right = ( int )( ps->rightMargin() * res + 71 ) / 72;
00333         if ( !fullPage() )
00334         {
00335             // Printers can often print very close to the edges (PPD files say ImageArea==PaperDimension).
00336             // But that doesn't mean it looks good. Apps which use setFullPage(false) assume that
00337             // KPrinter will give them reasonable margins, so let's QMAX with defaults from Qt in that case.
00338             // Keep this in sync with KPMarginPage::initPageSize
00339             unsigned int it, il, ib, ir;
00340             d->m_wrapper->margins( &it, &il, &ib, &ir );
00341             top = QMAX( top, (int)it );
00342             left = QMAX( left, (int)il );
00343             bottom = QMAX( bottom, (int)ib );
00344             right = QMAX( right, (int)ir );
00345         }
00346         d->m_wrapper->setMargins( top, left, bottom, right );
00347     }
00348     /*else
00349     {
00350         int res = d->m_wrapper->resolution();
00351         d->m_wrapper->setMargins( res/3, res/2, res/3, res/2 );
00352     }*/
00353     // for special printers, copies are handled by Qt
00354     if (option("kde-isspecial") == "1")
00355         d->m_wrapper->setNumCopies(numCopies());
00356 }
00357 
00358 bool KPrinter::printFiles(const QStringList& l, bool flag, bool startviewer)
00359 {
00360     QStringList files(l);
00361     bool        status(true);
00362 
00363     // First apply possible filters, and update "remove" flag if filters has
00364     // been applied (result == 0, means nothing happened).
00365     int fresult = d->m_impl->filterFiles(this, files, flag);
00366     if (fresult == -1)
00367     {
00368         reportError(this);
00369         status = false;
00370     }
00371     else if (fresult == 1)
00372         flag = true;
00373 
00374     if (status)
00375     {
00376         // Automatic conversion to format supported by print system
00377         fresult = d->m_impl->autoConvertFiles(this, files, flag);
00378         if (fresult == -1)
00379         {
00380             reportError(this);
00381             status = false;
00382         }
00383         else if (fresult == 1)
00384             flag = true;
00385     }
00386 
00387     // Continue if status is OK (filtering succeeded) and no output-to-file
00388     if (status && files.count() > 0)
00389     {
00390         // Show preview if needed (only possible for a single file !), and stop
00391         // if the user requested it. Force preview if preview-only mode has been set: it
00392         // then use by default the first file in the list.
00393         if (((files.count() != 1 || option("kde-preview") != "1") && !d->m_previewonly) || doPreview(files[0]))
00394         {
00395             // check if printing has been prepared (it may be not prepared if the KPrinter object is not
00396             // use as a QPaintDevice object)
00397             preparePrinting();
00398 
00399             if (!d->m_impl->printFiles(this, files, flag))
00400             {
00401                 reportError(this);
00402                 status = false;
00403             }
00404             else
00405             {
00406                 if (/* !outputToFile() && */ startviewer)
00407                 {
00408                     QStringList args;
00409                     args << "-d";
00410                     args << printerName();
00411                     args << "--noshow";
00412                     kapp->kdeinitExec("kjobviewer", args);
00413                 }
00414             }
00415         }
00416         else if (flag)
00417         // situation: only one file, it has been previewed and printing has been canceled, then
00418         //            we should remove the file ourself
00419         {
00420             QFile::remove(files[0]);
00421         }
00422     }
00423     finishPrinting();
00424     return status;
00425 }
00426 
00427 bool KPrinter::doPreview(const QString& file)
00428 {
00429     d->m_impl->statusMessage(i18n("Previewing..."), this);
00430     d->m_impl->statusMessage(QString::null, this);
00431     return KPrintPreview::preview(file, d->m_previewonly, d->m_parentId);
00432 }
00433 
00434 void KPrinter::preparePrinting()
00435 {
00436     // check if already prepared (-> do nothing)
00437     if (d->m_ready) return;
00438 
00439     // re-initialize error
00440     setErrorMessage(QString::null);
00441 
00442     // re-initialize margins and page size (by default, use Qt mechanism)
00443     setRealPageSize(NULL);
00444 
00445     // print-system-specific setup, only if not printing to file
00446     if (option("kde-isspecial") != "1")
00447         d->m_impl->preparePrinting(this);
00448 
00449     // set the correct resolution, if needed (or reset it)
00450     int res = option( "kde-resolution" ).toInt();
00451     if ( d->m_useprinterres && res > 0 )
00452         d->m_wrapper->setResolution( res );
00453     else
00454         d->m_wrapper->setResolution( d->m_defaultres );
00455 
00456     // standard Qt settings
00457     translateQtOptions();
00458 
00459     d->m_ready = true;
00460 dumpOptions(d->m_options);
00461 }
00462 
00463 void KPrinter::finishPrinting()
00464 {
00465     d->m_ready = false;
00466     // close the status window
00467     d->m_impl->statusMessage(QString::null, this);
00468 }
00469 
00470 QValueList<int> KPrinter::pageList() const
00471 {
00472     QValueList<int> list;
00473     int mp(minPage()), MP(maxPage());
00474     if (mp > 0 && MP > 0 && MP >= mp)
00475     { // do something only if bounds specified
00476         if (option("kde-current") == "1")
00477         { // print only current page
00478             int pp = currentPage();
00479             if (pp >= mp && pp <= MP) list.append(pp);
00480         }
00481         else
00482         {
00483             // process range specification
00484             if (!option("kde-range").isEmpty())
00485             {
00486                 QStringList ranges = QStringList::split(',',option("kde-range"),false);
00487                 // use a temporary map to insure uniqueness of pages.
00488                 QMap<int,int>   pages;
00489                 for (QStringList::ConstIterator it=ranges.begin();it!=ranges.end();++it)
00490                 {
00491                     int p = (*it).find('-');
00492                     bool    ok;
00493                     if (p == -1)
00494                     {
00495                         int pp = (*it).toInt(&ok);
00496                         if (ok && pp >= mp && pp <= MP)
00497                             pages[pp] = 1;
00498                     }
00499                     else
00500                     {
00501                         int p1(0), p2(0);
00502                         p1 = (*it).left(p).toInt(&ok);
00503                         if (ok) p2 = (*it).right((*it).length()-p-1).toInt(&ok);
00504                         if (ok && p1 <= p2)
00505                         {
00506                             // clip to min/max
00507                             p1 = QMAX(mp,p1);
00508                             p2 = QMIN(MP,p2);
00509                             for (int i=p1;i<=p2;i++)
00510                                 pages[i] = 1;
00511                         }
00512                     }
00513                 }
00514                 // translate the map into the list
00515                 for (QMap<int,int>::ConstIterator it=pages.begin();it!=pages.end();++it)
00516                     list.append(it.key());
00517                 // sort the list
00518                 qHeapSort(list);
00519             }
00520             else
00521             { // add all pages between min and max
00522                 for (int i=mp;i<=MP;i++) list.append(i);
00523             }
00524 
00525             // revert the list if needed
00526             if (pageOrder() == LastPageFirst)
00527             {
00528                 for (uint i=0;i<(list.count()/2);i++)
00529                     qSwap(list[i],list[list.count()-1-i]);
00530             }
00531 
00532             // select page set if needed
00533             if (pageSet() != AllPages)
00534             {
00535                 bool    keepEven = (pageSet() == EvenPages);
00536                 for (QValueList<int>::Iterator it=list.begin();it!=list.end();)
00537                     if ((((*it) % 2) != 0 && keepEven) ||
00538                         (((*it) % 2) == 0 && !keepEven)) it = list.remove(it);
00539                     else ++it;
00540             }
00541         }
00542     }
00543     return list;
00544 }
00545 
00546 //**************************************************************************************
00547 // QPrinter interface
00548 //**************************************************************************************
00549 
00550 int KPrinter::numCopies() const
00551 {
00552     bool    ok;
00553     int p = option("kde-copies").toInt(&ok);
00554     return (ok ? p : 1);
00555 }
00556 
00557 QSize KPrinter::margins() const
00558 {
00559     return d->m_wrapper->margins();
00560 }
00561 
00562 void KPrinter::margins( uint *top, uint *left, uint *bottom, uint *right ) const
00563 {
00564     d->m_wrapper->margins( top, left, bottom, right );
00565 }
00566 
00567 int KPrinter::metric(int m) const
00568 {
00569     if (d->m_pagesize == NULL || !option( "kde-printsize" ).isEmpty())
00570         return d->m_wrapper->qprinterMetric(m);
00571 
00572     int val(0);
00573     bool    land = (orientation() == KPrinter::Landscape);
00574     uint    res(d->m_wrapper->resolution()), top = res/2, left = res/2, bottom = res/3, right = res/2;
00575     margins( &top, &left, &bottom, &right );
00576     switch ( m )
00577     {
00578         case QPaintDeviceMetrics::PdmWidth:
00579             val = (land ? ( int )d->m_pagesize->pageHeight() : ( int )d->m_pagesize->pageWidth());
00580             if ( res != 72 )
00581                 val = (val * res + 36) / 72;
00582             if ( !fullPage() )
00583                 val -= ( left + right );
00584             break;
00585         case QPaintDeviceMetrics::PdmHeight:
00586             val = (land ? ( int )d->m_pagesize->pageWidth() : ( int )d->m_pagesize->pageHeight());
00587             if ( res != 72 )
00588                 val = (val * res + 36) / 72;
00589             if ( !fullPage() )
00590                 val -= ( top + bottom );
00591             break;
00592         case QPaintDeviceMetrics::PdmWidthMM:
00593             val = metric( QPaintDeviceMetrics::PdmWidth );
00594             val = (val * 254 + 5*res) / (10*res); // +360 to get the right rounding
00595             break;
00596         case QPaintDeviceMetrics::PdmHeightMM:
00597             val = metric( QPaintDeviceMetrics::PdmHeight );
00598             val = (val * 254 + 5*res) / (10*res);
00599             break;
00600         default:
00601             val = d->m_wrapper->qprinterMetric(m);
00602             break;
00603     }
00604     return val;
00605 }
00606 
00607 void KPrinter::setOrientation(Orientation o)
00608 {
00609     KMFactory::self()->settings()->orientation = o;
00610     setOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
00611     d->m_impl->broadcastOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
00612     d->m_impl->broadcastOption( "kde-orientation-fixed", "1" );
00613 }
00614 
00615 void KPrinter::setOption( const QString& key, const QString& value, bool broadcast )
00616 {
00617     setOption( key, value );
00618     if ( broadcast )
00619         d->m_impl->broadcastOption( key, value );
00620 }
00621 
00622 void KPrinter::setPageSize(PageSize s)
00623 {
00624     KMFactory::self()->settings()->pageSize = s;
00625     setOption("kde-pagesize",QString::number((int)s),true);
00626     d->m_impl->broadcastOption( "kde-pagesize-fixed", "1" );
00627 }
00628 
00629 void KPrinter::setOptions(const QMap<QString,QString>& opts)
00630 { // This functions remove all options except those with "kde-..."
00631   // which correspond to externally-sets options (use the value
00632   // from "opts" if specified
00633     QMap<QString,QString>   tmpset = d->m_options;
00634     d->m_options = opts;
00635     // remove some problematic options that may not be overwritten (ugly hack).
00636     // Default values will be used instead, except if the dialog has set new ones.
00637     tmpset.remove("kde-pagesize");
00638     tmpset.remove( "kde-printsize" );
00639     tmpset.remove("kde-orientation");
00640     tmpset.remove("kde-colormode");
00641     tmpset.remove("kde-margin-top");
00642     tmpset.remove("kde-margin-left");
00643     tmpset.remove("kde-margin-bottom");
00644     tmpset.remove("kde-margin-right");
00645     tmpset.remove( "kde-resolution" );
00646     tmpset.remove( "kde-fonts" );
00647     for (QMap<QString,QString>::ConstIterator it=tmpset.begin();it!=tmpset.end();++it)
00648         if (it.key().left(4) == "kde-" && !(d->m_options.contains(it.key())))
00649             d->m_options[it.key()] = it.data();
00650 }
00651 
00652 void KPrinter::initOptions(const QMap<QString,QString>& opts)
00653 { // This function can be used to initialize the KPrinter object just after
00654   // creation to set some options. Non global options will be propagated to
00655   // all listed printers (non-global => start with "kde-...")
00656     for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
00657     {
00658         setOption(it.key(), it.data());
00659         if (it.key().left(4) != "kde-")
00660             d->m_impl->broadcastOption(it.key(),it.data());
00661     }
00662 }
00663 
00664 void KPrinter::reload()
00665 {
00666     d->m_impl = KMFactory::self()->printerImplementation();
00667     int global = KMFactory::self()->settings()->orientation;
00668     if (global != -1) setOrientation((KPrinter::Orientation)global);
00669     global = KMFactory::self()->settings()->pageSize;
00670     if (global != -1) setPageSize((KPrinter::PageSize)global);
00671     //initOptions(d->m_options);
00672 }
00673 
00674 bool KPrinter::autoConfigure(const QString& prname, QWidget *parent)
00675 {
00676     KMManager   *mgr = KMManager::self();
00677     KMPrinter   *mprt(0);
00678 
00679     mgr->printerList(false);
00680     if (prname.isEmpty())
00681         mprt = mgr->defaultPrinter();
00682     else
00683         mprt = mgr->findPrinter(prname);
00684 
00685     if (mprt)
00686         return mprt->autoConfigure(this, parent);
00687     else
00688         return false;
00689 }
00690 
00691 //**************************************************************************************
00692 // Util functions
00693 //**************************************************************************************
00694 
00695 void reportError(KPrinter *p)
00696 {
00697     if (!KNotifyClient::event("printerror",i18n("<p><nobr>A print error occurred. Error message received from system:</nobr></p><br>%1").arg(p->errorMessage())))
00698         kdDebug(500) << "could not send notify event" << endl;
00699 }
00700 
00701 KPrinter::PageSize pageNameToPageSize(const QString& _name)
00702 {
00703     QString name = _name.upper();
00704     if (name == "LETTER") return KPrinter::Letter;
00705     else if (name == "LEGAL") return KPrinter::Legal;
00706     else if (name == "A4") return KPrinter::A4;
00707     else if (name == "A3") return KPrinter::A3;
00708     else if (name == "EXECUTIVE") return KPrinter::Executive;
00709     else if (name == "LEDGER") return KPrinter::Ledger;
00710     else if (name == "TABLOID") return KPrinter::Tabloid;
00711     else if (name == "FOLIO") return KPrinter::Folio;
00712     else if (name == "A5") return KPrinter::A5;
00713     else if (name == "A6") return KPrinter::A6;
00714     else if (name == "A7") return KPrinter::A7;
00715     else if (name == "A8") return KPrinter::A8;
00716     else if (name == "A9") return KPrinter::A9;
00717     else if (name == "A2") return KPrinter::A2;
00718     else if (name == "A1") return KPrinter::A1;
00719     else if (name == "A0") return KPrinter::A0;
00720     else if (name == "B0" || name == "B0ISO") return KPrinter::B0;
00721     else if (name == "B1" || name == "B1ISO") return KPrinter::B1;
00722     else if (name == "B2" || name == "B2ISO") return KPrinter::B2;
00723     else if (name == "B3" || name == "B3ISO") return KPrinter::B3;
00724     else if (name == "B4" || name == "B4ISO") return KPrinter::B4;
00725     else if (name == "B5" || name == "B5ISO") return KPrinter::B5;
00726     else if (name == "B6" || name == "B6ISO") return KPrinter::B6;
00727     else if (name == "B7" || name == "B7ISO") return KPrinter::B7;
00728     else if (name == "B8" || name == "B8ISO") return KPrinter::B8;
00729     else if (name == "B9" || name == "B9ISO") return KPrinter::B9;
00730     else if (name == "B10" || name == "B10ISO") return KPrinter::B10;
00731     else if (name == "C5" || name == "C5E" || name == "ENVC5") return KPrinter::C5E;
00732     else if (name == "DL" || name == "DLE" || name == "ENVDL") return KPrinter::DLE;
00733     else if (name == "COMM10" || name == "COM10" || name == "ENV10") return KPrinter::Comm10E;
00734     else return KPrinter::A4;
00735 }
00736 
00737 const char* pageSizeToPageName(KPrinter::PageSize s)
00738 {
00739     switch(s)
00740     {
00741         case KPrinter::Letter: return "Letter";
00742         case KPrinter::Legal: return "Legal";
00743         case KPrinter::A4: return "A4";
00744         case KPrinter::A3: return "A3";
00745         case KPrinter::Executive: return "Executive";
00746         case KPrinter::Ledger: return "Ledger";
00747         case KPrinter::Tabloid: return "Tabloid";
00748         case KPrinter::Folio: return "Folio";
00749         case KPrinter::A5: return "A5";
00750         case KPrinter::A6: return "A6";
00751         case KPrinter::A7: return "A7";
00752         case KPrinter::A8: return "A8";
00753         case KPrinter::A9: return "A9";
00754         case KPrinter::A2: return "A2";
00755         case KPrinter::A1: return "A1";
00756         case KPrinter::A0: return "A0";
00757         case KPrinter::B0: return "B0";
00758         case KPrinter::B1: return "B1";
00759         case KPrinter::B2: return "B2";
00760         case KPrinter::B3: return "B3";
00761         case KPrinter::B4: return "B4";
00762         case KPrinter::B5: return "B5";
00763         case KPrinter::B6: return "B6";
00764         case KPrinter::B7: return "B7";
00765         case KPrinter::B8: return "B8";
00766         case KPrinter::B9: return "B9";
00767         case KPrinter::B10: return "B10";
00768         case KPrinter::C5E: return "C5";
00769         case KPrinter::DLE: return "DL";
00770         case KPrinter::Comm10E: return "Comm10";
00771         default: return "A4";
00772     }
00773 }
00774 
00775 // FIXME: remove for 4.0
00776 QSize rangeToSize( const QString& )
00777 {
00778     kdWarning( 500 ) << "rangeToSize(QString) is obsolete, do not use (no effect)" << endl;
00779     return QSize();
00780 }
00781 
00782 static void dumpOptions(const QMap<QString,QString>& opts)
00783 {
00784     kdDebug(500) << "********************" << endl;
00785     for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
00786         kdDebug(500) << it.key() << " = " << it.data() << endl;
00787 }
00788 
00789 KPrinterImpl* KPrinter::implementation() const
00790 { return d->m_impl; }
00791 
00792 const QString& KPrinter::option(const QString& key) const
00793 { return ((const KPrinterPrivate*)(d))->m_options[key]; }
00794 
00795 void KPrinter::setOption(const QString& key, const QString& value)
00796 { d->m_options[key] = value; }
00797 
00798 QString KPrinter::docName() const
00799 { return option("kde-docname"); }
00800 
00801 void KPrinter::setDocName(const QString& d)
00802 { setOption("kde-docname",d); }
00803 
00804 QString KPrinter::creator() const
00805 { return option("kde-creator"); }
00806 
00807 void KPrinter::setCreator(const QString& d)
00808 { setOption("kde-creator",d); }
00809 
00810 bool KPrinter::fullPage() const
00811 { return (option("kde-fullpage") == "1"); }
00812 
00813 void KPrinter::setFullPage(bool on)
00814 { setOption("kde-fullpage",(on ? "1" : "0")); }
00815 
00816 KPrinter::ColorMode KPrinter::colorMode() const
00817 { return (KPrinter::ColorMode)(option("kde-colormode") == "GrayScale" ? GrayScale : Color); }
00818 
00819 void KPrinter::setColorMode(ColorMode m)
00820 { setOption("kde-colormode",(m == Color ? "Color" : "GrayScale")); }
00821 
00822 void KPrinter::setNumCopies(int n)
00823 { setOption("kde-copies",QString::number(n)); }
00824 
00825 KPrinter::Orientation KPrinter::orientation() const
00826 { return (option("kde-orientation") == "Landscape" ? Landscape : Portrait); }
00827 
00828 KPrinter::PageOrder KPrinter::pageOrder() const
00829 { return (option("kde-pageorder") == "Reverse" ? LastPageFirst : FirstPageFirst); }
00830 
00831 void KPrinter::setPageOrder(PageOrder o)
00832 { setOption("kde-pageorder",(o == LastPageFirst ? "Reverse" : "Forward")); }
00833 
00834 KPrinter::CollateType KPrinter::collate() const
00835 { return (option("kde-collate") == "Collate" ? Collate : Uncollate); }
00836 
00837 void KPrinter::setCollate(CollateType c)
00838 { setOption("kde-collate",(c == Collate ? "Collate" : "Uncollate")); }
00839 
00840 int KPrinter::minPage() const
00841 { return (option("kde-minpage").isEmpty() ? 0 : option("kde-minpage").toInt()); }
00842 
00843 int KPrinter::maxPage() const
00844 { return (option("kde-maxpage").isEmpty() ? 0 : option("kde-maxpage").toInt()); }
00845 
00846 void KPrinter::setMinMax(int m, int M)
00847 { setOption("kde-minpage",QString::number(m)); setOption("kde-maxpage",QString::number(M)); }
00848 
00849 int KPrinter::fromPage() const
00850 { return (option("kde-frompage").isEmpty() ? 0 : option("kde-frompage").toInt()); }
00851 
00852 int KPrinter::toPage() const
00853 { return (option("kde-topage").isEmpty() ? 0 : option("kde-topage").toInt()); }
00854 
00855 void KPrinter::setFromTo(int m, int M)
00856 { setOption("kde-frompage",QString::number(m)); setOption("kde-topage",QString::number(M)); setOption("kde-range",(m>0 && M>0 ? QString("%1-%2").arg(m).arg(M) : QString::fromLatin1(""))); }
00857 
00858 // if no page size defined, use the localized one
00859 KPrinter::PageSize KPrinter::pageSize() const
00860 { return (option("kde-pagesize").isEmpty() ? (PageSize)KGlobal::locale()->pageSize() : (PageSize)option("kde-pagesize").toInt()); }
00861 
00862 KPrinter::PageSetType KPrinter::pageSet() const
00863 { return (option("kde-pageset").isEmpty() ? AllPages : (PageSetType)(option("kde-pageset").toInt())); }
00864 
00865 int KPrinter::currentPage() const
00866 { return (option("kde-currentpage").isEmpty() ? 0 : option("kde-currentpage").toInt()); }
00867 
00868 void KPrinter::setCurrentPage(int p)
00869 { setOption("kde-currentpage",QString::number(p)); }
00870 
00871 QString KPrinter::printerName() const
00872 { return d->m_printername; }
00873 
00874 void KPrinter::setPrinterName(const QString& s)
00875 { d->m_printername = s; }
00876 
00877 QString KPrinter::printProgram() const
00878 { return (option("kde-isspecial") == "1" ? option("kde-special-command") : QString::null); }
00879 
00880 void KPrinter::setPrintProgram(const QString& prg)
00881 {
00882     if (prg.isNull())
00883     {
00884         setOption("kde-isspecial", "0");
00885         d->m_options.remove("kde-special-command");
00886     }
00887     else
00888     {
00889         QString s(prg);
00890         if (s.find("%in") == -1)
00891             s.append(" %in");
00892         setOutputToFile( s.find( "%out" ) != -1 );
00893         setOption("kde-isspecial", "1");
00894         setOption("kde-special-command", s);
00895     }
00896 }
00897 
00898 QString KPrinter::printerSelectionOption() const
00899 { return QString::fromLatin1(""); }
00900 
00901 void KPrinter::setPrinterSelectionOption(const QString&)
00902 {}
00903 
00904 const QMap<QString,QString>& KPrinter::options() const
00905 { return d->m_options; }
00906 
00907 QString KPrinter::searchName() const
00908 { return d->m_searchname; }
00909 
00910 void KPrinter::setSearchName(const QString& s)
00911 { d->m_searchname = s; }
00912 
00913 bool KPrinter::newPage()
00914 {
00915     d->m_pagenumber++;
00916     d->m_impl->statusMessage(i18n("Generating print data: page %1").arg(d->m_pagenumber), this);
00917     return d->m_wrapper->newPage();
00918 }
00919 
00920 QString KPrinter::outputFileName() const
00921 { return option("kde-outputfilename"); }
00922 
00923 void KPrinter::setOutputFileName(const QString& f)
00924 { setOption("kde-outputfilename",f); setOutputToFile(!f.isEmpty()); }
00925 
00926 bool KPrinter::outputToFile() const
00927 { return (option("kde-outputtofile") == "1" || (option("kde-isspecial") == "1" && option("kde-special-command").isEmpty())); }
00928 
00929 void KPrinter::setOutputToFile(bool on)
00930 {
00931     setOption("kde-outputtofile",(on ? "1" : "0"));
00932     if (on)
00933     {
00934         setOption("kde-special-command",QString::null);
00935         setOption("kde-isspecial","1");
00936     }
00937 }
00938 
00939 bool KPrinter::abort()
00940 { return d->m_wrapper->abort(); }
00941 
00942 bool KPrinter::aborted() const
00943 { return d->m_wrapper->aborted(); }
00944 
00945 void KPrinter::setMargins(QSize m)
00946 {
00947     setMargins( m.height(), m.width(), m.height(), m.width() );
00948 }
00949 
00950 void KPrinter::setMargins( uint top, uint left, uint bottom, uint right )
00951 {
00952     d->m_wrapper->setMargins( top, left, bottom, right );
00953     setOption( "kde-margin-top", QString::number( top ), true );
00954     setOption( "kde-margin-left", QString::number( left ), true );
00955     setOption( "kde-margin-bottom", QString::number( bottom ), true );
00956     setOption( "kde-margin-right", QString::number( right ), true );
00957 }
00958 
00959 // FIXME: remove for 4.0
00960 QSize KPrinter::realPageSize() const
00961 {
00962     kdWarning( 500 ) << "KPrinter::realPageSize() is obsolete, do not use" << endl;
00963     if ( d->m_pagesize )
00964         return d->m_pagesize->pageSize();
00965     else
00966         return QSize();
00967 }
00968 
00969 void KPrinter::setRealPageSize(DrPageSize *p)
00970 {
00971     if ( p )
00972     {
00973         kdDebug( 500 ) << "Page size:  width =" << p->pageWidth() << endl;
00974         kdDebug( 500 ) << "Page size: height =" << p->pageHeight() << endl;
00975         kdDebug( 500 ) << "Page size:   left =" << p->leftMargin() << endl;
00976         kdDebug( 500 ) << "Page size:    top =" << p->topMargin() << endl;
00977         kdDebug( 500 ) << "Page size:  right =" << p->rightMargin() << endl;
00978         kdDebug( 500 ) << "Page size: bottom =" << p->bottomMargin() << endl;
00979     }
00980     else
00981         kdDebug( 500 ) << "Resetting page size" << endl;
00982 
00983     /* we copy the page size structure internally
00984      * as the original object is owned by the driver
00985      * that control its destrution */
00986     delete d->m_pagesize;
00987     d->m_pagesize = 0;
00988     if ( p )
00989         d->m_pagesize = new DrPageSize( *p );
00990 }
00991 
00992 // FIXME: remove for 4.0
00993 void KPrinter::setRealPageSize( QSize )
00994 {
00995     kdWarning( 500 ) << "KPrinter::setRealPageSize(QSize) is obsolete, do not use (no effect)" << endl;
00996 }
00997 
00998 // FIXME: remove for 4.0
00999 void KPrinter::setRealDrawableArea( const QRect& )
01000 {
01001     kdWarning( 500 ) << "KPrinter::setRealDrawableArea(QRect) is obsolete, do not use (no effect)" << endl;
01002 }
01003 
01004 // FIXME: remove for 4.0
01005 QRect KPrinter::realDrawableArea() const
01006 {
01007     kdWarning( 500 ) << "KPrinter::realDrawableArea() is obsolete, do not use" << endl;
01008     if ( d->m_pagesize )
01009         return d->m_pagesize->pageRect();
01010     else
01011         return QRect();
01012 }
01013 
01014 QString KPrinter::errorMessage() const
01015 { return d->m_errormsg; }
01016 
01017 void KPrinter::setErrorMessage(const QString& msg)
01018 { d->m_errormsg = msg; }
01019 
01020 /* we're using a builtin member to store this state because we don't
01021  * want to keep it from object to object. So there's no need to use
01022  * the QMap structure to store this
01023  */
01024 void KPrinter::setPreviewOnly(bool on)
01025 { d->m_previewonly = on; }
01026 
01027 bool KPrinter::previewOnly() const
01028 { return d->m_previewonly; }
01029 
01030 void KPrinter::setDocFileName(const QString& s)
01031 { d->m_docfilename = s; }
01032 
01033 QString KPrinter::docFileName() const
01034 { return d->m_docfilename; }
01035 
01036 void KPrinter::setDocDirectory( const QString& s )
01037 { d->m_docdirectory = s; }
01038 
01039 QString KPrinter::docDirectory() const
01040 { return ( d->m_docdirectory.isEmpty() ? QDir::homeDirPath() : d->m_docdirectory ); }
01041 
01042 void KPrinter::setResolution(int dpi)
01043 {
01044     d->m_wrapper->setResolution(dpi);
01045     d->m_defaultres = dpi;
01046 }
01047 
01048 int KPrinter::resolution() const
01049 { return d->m_wrapper->resolution(); }
01050 
01051 void KPrinter::setUsePrinterResolution( bool on )
01052 { d->m_useprinterres = on; }
KDE Logo
This file is part of the documentation for kdeprint Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Apr 28 01:39:59 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003