00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
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
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
00132 delete d->m_wrapper;
00133
00134
00135 if (d->m_restore)
00136 saveSettings();
00137
00138
00139 delete d->m_pagesize;
00140 delete d;
00141 }
00142
00143 void KPrinter::init(bool restore, QPrinter::PrinterMode m)
00144 {
00145
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
00154 d->m_wrapper = new KPrinterWrapper(this, m);
00155
00156
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
00163 if (d->m_restore)
00164 loadSettings();
00165 }
00166
00167 void KPrinter::loadSettings()
00168 {
00169 d->m_options = d->m_impl->loadOptions();
00170
00171
00172
00173
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
00182 if (searchName().isEmpty() && pconf->readBoolEntry("UseLast", true))
00183 setSearchName(conf->readEntry("Printer"));
00184
00185
00186 setOption("kde-printcommand",conf->readPathEntry("PrintCommand"));
00187
00188
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
00202 KConfig *conf = KGlobal::config();
00203 conf->setGroup("KPrinter Settings");
00204 conf->writeEntry("Printer",searchName());
00205
00206 conf->writePathEntry("PrintCommand",option("kde-printcommand"));
00207
00208
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;
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
00289 value = value && printFiles(QStringList(d->m_wrapper->outputFileName()),true);
00290
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 d->m_wrapper->setMargins(
00330 ( int )( ( ps->topMargin() * res + 71 ) / 72 ),
00331 ( int )( ( ps->leftMargin() * res + 71 ) / 72 ),
00332 ( int )( ( ps->bottomMargin() * res + 71 ) / 72 ),
00333 ( int )( ( ps->rightMargin() * res + 71 ) / 72 ) );
00334 }
00335
00336
00337
00338
00339
00340
00341 if (option("kde-isspecial") == "1")
00342 d->m_wrapper->setNumCopies(numCopies());
00343 }
00344
00345 bool KPrinter::printFiles(const QStringList& l, bool flag, bool startviewer)
00346 {
00347 QStringList files(l);
00348 bool status(true);
00349
00350
00351
00352 int fresult = d->m_impl->filterFiles(this, files, flag);
00353 if (fresult == -1)
00354 {
00355 reportError(this);
00356 status = false;
00357 }
00358 else if (fresult == 1)
00359 flag = true;
00360
00361 if (status)
00362 {
00363
00364 fresult = d->m_impl->autoConvertFiles(this, files, flag);
00365 if (fresult == -1)
00366 {
00367 reportError(this);
00368 status = false;
00369 }
00370 else if (fresult == 1)
00371 flag = true;
00372 }
00373
00374
00375 if (status && files.count() > 0)
00376 {
00377
00378
00379
00380 if (((files.count() != 1 || option("kde-preview") != "1") && !d->m_previewonly) || doPreview(files[0]))
00381 {
00382
00383
00384 preparePrinting();
00385
00386 if (!d->m_impl->printFiles(this, files, flag))
00387 {
00388 reportError(this);
00389 status = false;
00390 }
00391 else
00392 {
00393 if ( startviewer)
00394 {
00395 QStringList args;
00396 args << "-d";
00397 args << printerName();
00398 args << "--noshow";
00399 kapp->kdeinitExec("kjobviewer", args);
00400 }
00401 }
00402 }
00403 else if (flag)
00404
00405
00406 {
00407 QFile::remove(files[0]);
00408 }
00409 }
00410 finishPrinting();
00411 return status;
00412 }
00413
00414 bool KPrinter::doPreview(const QString& file)
00415 {
00416 d->m_impl->statusMessage(i18n("Previewing..."), this);
00417 d->m_impl->statusMessage(QString::null, this);
00418 return KPrintPreview::preview(file, d->m_previewonly, d->m_parentId);
00419 }
00420
00421 void KPrinter::preparePrinting()
00422 {
00423
00424 if (d->m_ready) return;
00425
00426
00427 setErrorMessage(QString::null);
00428
00429
00430 setRealPageSize(NULL);
00431
00432
00433 if (option("kde-isspecial") != "1")
00434 d->m_impl->preparePrinting(this);
00435
00436
00437 int res = option( "kde-resolution" ).toInt();
00438 if ( d->m_useprinterres && res > 0 )
00439 d->m_wrapper->setResolution( res );
00440 else
00441 d->m_wrapper->setResolution( d->m_defaultres );
00442
00443
00444 translateQtOptions();
00445
00446 d->m_ready = true;
00447 dumpOptions(d->m_options);
00448 }
00449
00450 void KPrinter::finishPrinting()
00451 {
00452 d->m_ready = false;
00453
00454 d->m_impl->statusMessage(QString::null, this);
00455 }
00456
00457 QValueList<int> KPrinter::pageList() const
00458 {
00459 QValueList<int> list;
00460 int mp(minPage()), MP(maxPage());
00461 if (mp > 0 && MP > 0 && MP >= mp)
00462 {
00463 if (option("kde-current") == "1")
00464 {
00465 int pp = currentPage();
00466 if (pp >= mp && pp <= MP) list.append(pp);
00467 }
00468 else
00469 {
00470
00471 if (!option("kde-range").isEmpty())
00472 {
00473 QStringList ranges = QStringList::split(',',option("kde-range"),false);
00474
00475 QMap<int,int> pages;
00476 for (QStringList::ConstIterator it=ranges.begin();it!=ranges.end();++it)
00477 {
00478 int p = (*it).find('-');
00479 bool ok;
00480 if (p == -1)
00481 {
00482 int pp = (*it).toInt(&ok);
00483 if (ok && pp >= mp && pp <= MP)
00484 pages[pp] = 1;
00485 }
00486 else
00487 {
00488 int p1(0), p2(0);
00489 p1 = (*it).left(p).toInt(&ok);
00490 if (ok) p2 = (*it).right((*it).length()-p-1).toInt(&ok);
00491 if (ok && p1 <= p2)
00492 {
00493
00494 p1 = QMAX(mp,p1);
00495 p2 = QMIN(MP,p2);
00496 for (int i=p1;i<=p2;i++)
00497 pages[i] = 1;
00498 }
00499 }
00500 }
00501
00502 for (QMap<int,int>::ConstIterator it=pages.begin();it!=pages.end();++it)
00503 list.append(it.key());
00504
00505 qHeapSort(list);
00506 }
00507 else
00508 {
00509 for (int i=mp;i<=MP;i++) list.append(i);
00510 }
00511
00512
00513 if (pageOrder() == LastPageFirst)
00514 {
00515 for (uint i=0;i<(list.count()/2);i++)
00516 qSwap(list[i],list[list.count()-1-i]);
00517 }
00518
00519
00520 if (pageSet() != AllPages)
00521 {
00522 bool keepEven = (pageSet() == EvenPages);
00523 for (QValueList<int>::Iterator it=list.begin();it!=list.end();)
00524 if ((((*it) % 2) != 0 && keepEven) ||
00525 (((*it) % 2) == 0 && !keepEven)) it = list.remove(it);
00526 else ++it;
00527 }
00528 }
00529 }
00530 return list;
00531 }
00532
00533
00534
00535
00536
00537 int KPrinter::numCopies() const
00538 {
00539 bool ok;
00540 int p = option("kde-copies").toInt(&ok);
00541 return (ok ? p : 1);
00542 }
00543
00544 QSize KPrinter::margins() const
00545 {
00546 return d->m_wrapper->margins();
00547 }
00548
00549 void KPrinter::margins( uint *top, uint *left, uint *bottom, uint *right ) const
00550 {
00551 d->m_wrapper->margins( top, left, bottom, right );
00552 }
00553
00554 int KPrinter::metric(int m) const
00555 {
00556 if (d->m_pagesize == NULL || !option( "kde-printsize" ).isEmpty())
00557 return d->m_wrapper->qprinterMetric(m);
00558
00559 int val(0);
00560 bool land = (orientation() == KPrinter::Landscape);
00561 uint res(d->m_wrapper->resolution()), top = res/2, left = res/2, bottom = res/3, right = res/2;
00562 margins( &top, &left, &bottom, &right );
00563 switch ( m )
00564 {
00565 case QPaintDeviceMetrics::PdmWidth:
00566 val = (land ? ( int )d->m_pagesize->pageHeight() : ( int )d->m_pagesize->pageWidth());
00567 if ( res != 72 )
00568 val = (val * res + 36) / 72;
00569 if ( !fullPage() )
00570 val -= ( left + right );
00571 break;
00572 case QPaintDeviceMetrics::PdmHeight:
00573 val = (land ? ( int )d->m_pagesize->pageWidth() : ( int )d->m_pagesize->pageHeight());
00574 if ( res != 72 )
00575 val = (val * res + 36) / 72;
00576 if ( !fullPage() )
00577 val -= ( top + bottom );
00578 break;
00579 case QPaintDeviceMetrics::PdmWidthMM:
00580 val = metric( QPaintDeviceMetrics::PdmWidth );
00581 val = (val * 254 + 5*res) / (10*res);
00582 break;
00583 case QPaintDeviceMetrics::PdmHeightMM:
00584 val = metric( QPaintDeviceMetrics::PdmHeight );
00585 val = (val * 254 + 5*res) / (10*res);
00586 break;
00587 default:
00588 val = d->m_wrapper->qprinterMetric(m);
00589 break;
00590 }
00591 return val;
00592 }
00593
00594 void KPrinter::setOrientation(Orientation o)
00595 {
00596 KMFactory::self()->settings()->orientation = o;
00597 setOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
00598 d->m_impl->broadcastOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
00599 d->m_impl->broadcastOption( "kde-orientation-fixed", "1" );
00600 }
00601
00602 void KPrinter::setOption( const QString& key, const QString& value, bool broadcast )
00603 {
00604 setOption( key, value );
00605 if ( broadcast )
00606 d->m_impl->broadcastOption( key, value );
00607 }
00608
00609 void KPrinter::setPageSize(PageSize s)
00610 {
00611 KMFactory::self()->settings()->pageSize = s;
00612 setOption("kde-pagesize",QString::number((int)s),true);
00613 d->m_impl->broadcastOption( "kde-pagesize-fixed", "1" );
00614 }
00615
00616 void KPrinter::setOptions(const QMap<QString,QString>& opts)
00617 {
00618
00619
00620 QMap<QString,QString> tmpset = d->m_options;
00621 d->m_options = opts;
00622
00623
00624 tmpset.remove("kde-pagesize");
00625 tmpset.remove( "kde-printsize" );
00626 tmpset.remove("kde-orientation");
00627 tmpset.remove("kde-colormode");
00628 tmpset.remove("kde-margin-top");
00629 tmpset.remove("kde-margin-left");
00630 tmpset.remove("kde-margin-bottom");
00631 tmpset.remove("kde-margin-right");
00632 tmpset.remove( "kde-resolution" );
00633 tmpset.remove( "kde-fonts" );
00634 for (QMap<QString,QString>::ConstIterator it=tmpset.begin();it!=tmpset.end();++it)
00635 if (it.key().left(4) == "kde-" && !(d->m_options.contains(it.key())))
00636 d->m_options[it.key()] = it.data();
00637 }
00638
00639 void KPrinter::initOptions(const QMap<QString,QString>& opts)
00640 {
00641
00642
00643 for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
00644 {
00645 setOption(it.key(), it.data());
00646 if (it.key().left(4) != "kde-")
00647 d->m_impl->broadcastOption(it.key(),it.data());
00648 }
00649 }
00650
00651 void KPrinter::reload()
00652 {
00653 d->m_impl = KMFactory::self()->printerImplementation();
00654 int global = KMFactory::self()->settings()->orientation;
00655 if (global != -1) setOrientation((KPrinter::Orientation)global);
00656 global = KMFactory::self()->settings()->pageSize;
00657 if (global != -1) setPageSize((KPrinter::PageSize)global);
00658
00659 }
00660
00661 bool KPrinter::autoConfigure(const QString& prname, QWidget *parent)
00662 {
00663 KMManager *mgr = KMManager::self();
00664 KMPrinter *mprt(0);
00665
00666 mgr->printerList(false);
00667 if (prname.isEmpty())
00668 mprt = mgr->defaultPrinter();
00669 else
00670 mprt = mgr->findPrinter(prname);
00671
00672 if (mprt)
00673 return mprt->autoConfigure(this, parent);
00674 else
00675 return false;
00676 }
00677
00678
00679
00680
00681
00682 void reportError(KPrinter *p)
00683 {
00684 if (!KNotifyClient::event("printerror",i18n("<p><nobr>A print error occurred. Error message received from system:</nobr></p><br>%1").arg(p->errorMessage())))
00685 kdDebug(500) << "could not send notify event" << endl;
00686 }
00687
00688 KPrinter::PageSize pageNameToPageSize(const QString& _name)
00689 {
00690 QString name = _name.upper();
00691 if (name == "LETTER") return KPrinter::Letter;
00692 else if (name == "LEGAL") return KPrinter::Legal;
00693 else if (name == "A4") return KPrinter::A4;
00694 else if (name == "A3") return KPrinter::A3;
00695 else if (name == "EXECUTIVE") return KPrinter::Executive;
00696 else if (name == "LEDGER") return KPrinter::Ledger;
00697 else if (name == "TABLOID") return KPrinter::Tabloid;
00698 else if (name == "FOLIO") return KPrinter::Folio;
00699 else if (name == "A5") return KPrinter::A5;
00700 else if (name == "A6") return KPrinter::A6;
00701 else if (name == "A7") return KPrinter::A7;
00702 else if (name == "A8") return KPrinter::A8;
00703 else if (name == "A9") return KPrinter::A9;
00704 else if (name == "A2") return KPrinter::A2;
00705 else if (name == "A1") return KPrinter::A1;
00706 else if (name == "A0") return KPrinter::A0;
00707 else if (name == "B0" || name == "B0ISO") return KPrinter::B0;
00708 else if (name == "B1" || name == "B1ISO") return KPrinter::B1;
00709 else if (name == "B2" || name == "B2ISO") return KPrinter::B2;
00710 else if (name == "B3" || name == "B3ISO") return KPrinter::B3;
00711 else if (name == "B4" || name == "B4ISO") return KPrinter::B4;
00712 else if (name == "B5" || name == "B5ISO") return KPrinter::B5;
00713 else if (name == "B6" || name == "B6ISO") return KPrinter::B6;
00714 else if (name == "B7" || name == "B7ISO") return KPrinter::B7;
00715 else if (name == "B8" || name == "B8ISO") return KPrinter::B8;
00716 else if (name == "B9" || name == "B9ISO") return KPrinter::B9;
00717 else if (name == "B10" || name == "B10ISO") return KPrinter::B10;
00718 else if (name == "C5" || name == "C5E" || name == "ENVC5") return KPrinter::C5E;
00719 else if (name == "DL" || name == "DLE" || name == "ENVDL") return KPrinter::DLE;
00720 else if (name == "COMM10" || name == "COM10" || name == "ENV10") return KPrinter::Comm10E;
00721 else return KPrinter::A4;
00722 }
00723
00724 const char* pageSizeToPageName(KPrinter::PageSize s)
00725 {
00726 switch(s)
00727 {
00728 case KPrinter::Letter: return "Letter";
00729 case KPrinter::Legal: return "Legal";
00730 case KPrinter::A4: return "A4";
00731 case KPrinter::A3: return "A3";
00732 case KPrinter::Executive: return "Executive";
00733 case KPrinter::Ledger: return "Ledger";
00734 case KPrinter::Tabloid: return "Tabloid";
00735 case KPrinter::Folio: return "Folio";
00736 case KPrinter::A5: return "A5";
00737 case KPrinter::A6: return "A6";
00738 case KPrinter::A7: return "A7";
00739 case KPrinter::A8: return "A8";
00740 case KPrinter::A9: return "A9";
00741 case KPrinter::A2: return "A2";
00742 case KPrinter::A1: return "A1";
00743 case KPrinter::A0: return "A0";
00744 case KPrinter::B0: return "B0";
00745 case KPrinter::B1: return "B1";
00746 case KPrinter::B2: return "B2";
00747 case KPrinter::B3: return "B3";
00748 case KPrinter::B4: return "B4";
00749 case KPrinter::B5: return "B5";
00750 case KPrinter::B6: return "B6";
00751 case KPrinter::B7: return "B7";
00752 case KPrinter::B8: return "B8";
00753 case KPrinter::B9: return "B9";
00754 case KPrinter::B10: return "B10";
00755 case KPrinter::C5E: return "C5";
00756 case KPrinter::DLE: return "DL";
00757 case KPrinter::Comm10E: return "Comm10";
00758 default: return "A4";
00759 }
00760 }
00761
00762
00763 QSize rangeToSize( const QString& )
00764 {
00765 kdWarning( 500 ) << "rangeToSize(QString) is obsolete, do not use (no effect)" << endl;
00766 return QSize();
00767 }
00768
00769 static void dumpOptions(const QMap<QString,QString>& opts)
00770 {
00771 kdDebug(500) << "********************" << endl;
00772 for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
00773 kdDebug(500) << it.key() << " = " << it.data() << endl;
00774 }
00775
00776 KPrinterImpl* KPrinter::implementation() const
00777 { return d->m_impl; }
00778
00779 const QString& KPrinter::option(const QString& key) const
00780 { return ((const KPrinterPrivate*)(d))->m_options[key]; }
00781
00782 void KPrinter::setOption(const QString& key, const QString& value)
00783 { d->m_options[key] = value; }
00784
00785 QString KPrinter::docName() const
00786 { return option("kde-docname"); }
00787
00788 void KPrinter::setDocName(const QString& d)
00789 { setOption("kde-docname",d); }
00790
00791 QString KPrinter::creator() const
00792 { return option("kde-creator"); }
00793
00794 void KPrinter::setCreator(const QString& d)
00795 { setOption("kde-creator",d); }
00796
00797 bool KPrinter::fullPage() const
00798 { return (option("kde-fullpage") == "1"); }
00799
00800 void KPrinter::setFullPage(bool on)
00801 { setOption("kde-fullpage",(on ? "1" : "0")); }
00802
00803 KPrinter::ColorMode KPrinter::colorMode() const
00804 { return (KPrinter::ColorMode)(option("kde-colormode") == "GrayScale" ? GrayScale : Color); }
00805
00806 void KPrinter::setColorMode(ColorMode m)
00807 { setOption("kde-colormode",(m == Color ? "Color" : "GrayScale")); }
00808
00809 void KPrinter::setNumCopies(int n)
00810 { setOption("kde-copies",QString::number(n)); }
00811
00812 KPrinter::Orientation KPrinter::orientation() const
00813 { return (option("kde-orientation") == "Landscape" ? Landscape : Portrait); }
00814
00815 KPrinter::PageOrder KPrinter::pageOrder() const
00816 { return (option("kde-pageorder") == "Reverse" ? LastPageFirst : FirstPageFirst); }
00817
00818 void KPrinter::setPageOrder(PageOrder o)
00819 { setOption("kde-pageorder",(o == LastPageFirst ? "Reverse" : "Forward")); }
00820
00821 KPrinter::CollateType KPrinter::collate() const
00822 { return (option("kde-collate") == "Collate" ? Collate : Uncollate); }
00823
00824 void KPrinter::setCollate(CollateType c)
00825 { setOption("kde-collate",(c == Collate ? "Collate" : "Uncollate")); }
00826
00827 int KPrinter::minPage() const
00828 { return (option("kde-minpage").isEmpty() ? 0 : option("kde-minpage").toInt()); }
00829
00830 int KPrinter::maxPage() const
00831 { return (option("kde-maxpage").isEmpty() ? 0 : option("kde-maxpage").toInt()); }
00832
00833 void KPrinter::setMinMax(int m, int M)
00834 { setOption("kde-minpage",QString::number(m)); setOption("kde-maxpage",QString::number(M)); }
00835
00836 int KPrinter::fromPage() const
00837 { return (option("kde-frompage").isEmpty() ? 0 : option("kde-frompage").toInt()); }
00838
00839 int KPrinter::toPage() const
00840 { return (option("kde-topage").isEmpty() ? 0 : option("kde-topage").toInt()); }
00841
00842 void KPrinter::setFromTo(int m, int M)
00843 { 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(""))); }
00844
00845
00846 KPrinter::PageSize KPrinter::pageSize() const
00847 { return (option("kde-pagesize").isEmpty() ? (PageSize)KGlobal::locale()->pageSize() : (PageSize)option("kde-pagesize").toInt()); }
00848
00849 KPrinter::PageSetType KPrinter::pageSet() const
00850 { return (option("kde-pageset").isEmpty() ? AllPages : (PageSetType)(option("kde-pageset").toInt())); }
00851
00852 int KPrinter::currentPage() const
00853 { return (option("kde-currentpage").isEmpty() ? 0 : option("kde-currentpage").toInt()); }
00854
00855 void KPrinter::setCurrentPage(int p)
00856 { setOption("kde-currentpage",QString::number(p)); }
00857
00858 QString KPrinter::printerName() const
00859 { return d->m_printername; }
00860
00861 void KPrinter::setPrinterName(const QString& s)
00862 { d->m_printername = s; }
00863
00864 QString KPrinter::printProgram() const
00865 { return (option("kde-isspecial") == "1" ? option("kde-special-command") : QString::null); }
00866
00867 void KPrinter::setPrintProgram(const QString& prg)
00868 {
00869 if (prg.isNull())
00870 {
00871 setOption("kde-isspecial", "0");
00872 d->m_options.remove("kde-special-command");
00873 }
00874 else
00875 {
00876 setOption("kde-isspecial", "1");
00877 QString s(prg);
00878 if (s.find("%in") == -1)
00879 s.append(" %in");
00880 setOption("kde-special-command", s);
00881 }
00882 }
00883
00884 QString KPrinter::printerSelectionOption() const
00885 { return QString::fromLatin1(""); }
00886
00887 void KPrinter::setPrinterSelectionOption(const QString&)
00888 {}
00889
00890 const QMap<QString,QString>& KPrinter::options() const
00891 { return d->m_options; }
00892
00893 QString KPrinter::searchName() const
00894 { return d->m_searchname; }
00895
00896 void KPrinter::setSearchName(const QString& s)
00897 { d->m_searchname = s; }
00898
00899 bool KPrinter::newPage()
00900 {
00901 d->m_pagenumber++;
00902 d->m_impl->statusMessage(i18n("Generating print data: page %1").arg(d->m_pagenumber), this);
00903 return d->m_wrapper->newPage();
00904 }
00905
00906 QString KPrinter::outputFileName() const
00907 { return option("kde-outputfilename"); }
00908
00909 void KPrinter::setOutputFileName(const QString& f)
00910 { setOption("kde-outputfilename",f); setOutputToFile(!f.isEmpty()); }
00911
00912 bool KPrinter::outputToFile() const
00913 { return (option("kde-outputtofile") == "1" || (option("kde-isspecial") == "1" && option("kde-special-command").isEmpty())); }
00914
00915 void KPrinter::setOutputToFile(bool on)
00916 {
00917 setOption("kde-outputtofile",(on ? "1" : "0"));
00918 if (on)
00919 {
00920 setOption("kde-special-command",QString::null);
00921 setOption("kde-isspecial","1");
00922 }
00923 }
00924
00925 bool KPrinter::abort()
00926 { return d->m_wrapper->abort(); }
00927
00928 bool KPrinter::aborted() const
00929 { return d->m_wrapper->aborted(); }
00930
00931 void KPrinter::setMargins(QSize m)
00932 {
00933 setMargins( m.height(), m.width(), m.height(), m.width() );
00934 }
00935
00936 void KPrinter::setMargins( uint top, uint left, uint bottom, uint right )
00937 {
00938 d->m_wrapper->setMargins( top, left, bottom, right );
00939 setOption( "kde-margin-top", QString::number( top ), true );
00940 setOption( "kde-margin-left", QString::number( left ), true );
00941 setOption( "kde-margin-bottom", QString::number( bottom ), true );
00942 setOption( "kde-margin-right", QString::number( right ), true );
00943 }
00944
00945
00946 QSize KPrinter::realPageSize() const
00947 {
00948 kdWarning( 500 ) << "KPrinter::realPageSize() is obsolete, do not use" << endl;
00949 if ( d->m_pagesize )
00950 return d->m_pagesize->pageSize();
00951 else
00952 return QSize();
00953 }
00954
00955 void KPrinter::setRealPageSize(DrPageSize *p)
00956 {
00957 if ( p )
00958 {
00959 kdDebug( 500 ) << "Page size: width =" << p->pageWidth() << endl;
00960 kdDebug( 500 ) << "Page size: height =" << p->pageHeight() << endl;
00961 kdDebug( 500 ) << "Page size: left =" << p->leftMargin() << endl;
00962 kdDebug( 500 ) << "Page size: top =" << p->topMargin() << endl;
00963 kdDebug( 500 ) << "Page size: right =" << p->rightMargin() << endl;
00964 kdDebug( 500 ) << "Page size: bottom =" << p->bottomMargin() << endl;
00965 }
00966 else
00967 kdDebug( 500 ) << "Resetting page size" << endl;
00968
00969
00970
00971
00972 delete d->m_pagesize;
00973 d->m_pagesize = 0;
00974 if ( p )
00975 d->m_pagesize = new DrPageSize( *p );
00976 }
00977
00978
00979 void KPrinter::setRealPageSize( QSize )
00980 {
00981 kdWarning( 500 ) << "KPrinter::setRealPageSize(QSize) is obsolete, do not use (no effect)" << endl;
00982 }
00983
00984
00985 void KPrinter::setRealDrawableArea( const QRect& )
00986 {
00987 kdWarning( 500 ) << "KPrinter::setRealDrawableArea(QRect) is obsolete, do not use (no effect)" << endl;
00988 }
00989
00990
00991 QRect KPrinter::realDrawableArea() const
00992 {
00993 kdWarning( 500 ) << "KPrinter::realDrawableArea() is obsolete, do not use" << endl;
00994 if ( d->m_pagesize )
00995 return d->m_pagesize->pageRect();
00996 else
00997 return QRect();
00998 }
00999
01000 QString KPrinter::errorMessage() const
01001 { return d->m_errormsg; }
01002
01003 void KPrinter::setErrorMessage(const QString& msg)
01004 { d->m_errormsg = msg; }
01005
01006
01007
01008
01009
01010 void KPrinter::setPreviewOnly(bool on)
01011 { d->m_previewonly = on; }
01012
01013 bool KPrinter::previewOnly() const
01014 { return d->m_previewonly; }
01015
01016 void KPrinter::setDocFileName(const QString& s)
01017 { d->m_docfilename = s; }
01018
01019 QString KPrinter::docFileName() const
01020 { return d->m_docfilename; }
01021
01022 void KPrinter::setDocDirectory( const QString& s )
01023 { d->m_docdirectory = s; }
01024
01025 QString KPrinter::docDirectory() const
01026 { return ( d->m_docdirectory.isEmpty() ? QDir::homeDirPath() : d->m_docdirectory ); }
01027
01028 void KPrinter::setResolution(int dpi)
01029 {
01030 d->m_wrapper->setResolution(dpi);
01031 d->m_defaultres = dpi;
01032 }
01033
01034 int KPrinter::resolution() const
01035 { return d->m_wrapper->resolution(); }
01036
01037 void KPrinter::setUsePrinterResolution( bool on )
01038 { d->m_useprinterres = on; }