kprinter.cpp
/*
* This file is part of the KDE libraries
* Copyright (c) 2001 Michael Goffioul <kdeprint@swing.be>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License version 2 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
**/
#include <config.h>
#include "kprinter.h"
#include "kprinterimpl.h"
#include "kprintdialog.h"
#include "kprintpreview.h"
#include "kmfactory.h"
#include "kmuimanager.h"
#include "kmmanager.h"
#include "driver.h"
#include <qpaintdevicemetrics.h>
#include <qfile.h>
#include <qtl.h>
#include <qdir.h>
#include <qguardedptr.h>
#include <kapplication.h>
#include <kstandarddirs.h>
#include <kglobal.h>
#include <kconfig.h>
#include <krun.h>
#include <knotifyclient.h>
#include <kdebug.h>
#include <klocale.h>
#include <kprocess.h>
#include <klibloader.h>
#include <kmessagebox.h>
static void dumpOptions(const QMap<QString,QString>& opts);
static void reportError(KPrinter*);
//**************************************************************************************
// KPrinterWrapper class
//**************************************************************************************
class KPrinterWrapper : public QPrinter
{
friend class KPrinter;
public:
KPrinterWrapper(KPrinter*, PrinterMode m = ScreenResolution);
~KPrinterWrapper();
protected:
virtual bool cmd(int, QPainter*, QPDevCmdParam*);
virtual int metric(int) const;
int qprinterMetric(int) const;
private:
KPrinter *m_printer;
};
KPrinterWrapper::KPrinterWrapper(KPrinter *prt, QPrinter::PrinterMode m)
: QPrinter(m), m_printer(prt)
{
}
KPrinterWrapper::~KPrinterWrapper()
{
}
bool KPrinterWrapper::cmd(int c, QPainter *painter, QPDevCmdParam *p)
{
return QPrinter::cmd(c,painter,p);
}
int KPrinterWrapper::metric(int m) const
{
return m_printer->metric(m);
}
int KPrinterWrapper::qprinterMetric(int m) const
{
return QPrinter::metric(m);
}
//**************************************************************************************
// KPrinterPrivate class
//**************************************************************************************
class KPrinterPrivate
{
public:
QGuardedPtr<KPrinterImpl> m_impl;
bool m_restore;
bool m_previewonly;
WId m_parentId;
QString m_docfilename;
QString m_docdirectory;
KPrinterWrapper *m_wrapper;
QMap<QString,QString> m_options;
QString m_tmpbuffer;
QString m_printername;
QString m_searchname;
QString m_errormsg;
bool m_ready;
int m_pagenumber;
DrPageSize *m_pagesize;
bool m_useprinterres;
int m_defaultres;
};
//**************************************************************************************
// KPrinter class
//**************************************************************************************
KPrinter::KPrinter(bool restore, QPrinter::PrinterMode m)
: QPaintDevice(QInternal::Printer|QInternal::ExternalDevice)
{
init(restore, m);
}
KPrinter::~KPrinter()
{
// delete Wrapper object
delete d->m_wrapper;
// save current options
if (d->m_restore)
saveSettings();
// delete private data (along any data allocated internally)
delete d->m_pagesize;
delete d;
}
void KPrinter::init(bool restore, QPrinter::PrinterMode m)
{
// Private data initialization
d = new KPrinterPrivate;
d->m_impl = KMFactory::self()->printerImplementation();
d->m_restore = restore;
d->m_previewonly = false;
d->m_parentId = 0;
d->m_pagesize = 0;
// initialize QPrinter wrapper
d->m_wrapper = new KPrinterWrapper(this, m);
// other initialization
d->m_tmpbuffer = d->m_impl->tempFile();
d->m_ready = false;
d->m_defaultres = d->m_wrapper->resolution();
d->m_useprinterres = false;
// reload options from implementation (static object)
if (d->m_restore)
loadSettings();
}
void KPrinter::loadSettings()
{
d->m_options = d->m_impl->loadOptions();
// load the last printer used in the current process (if any)
// and remove the corresponding entry in the option map, as it
// is not needed anymore
setSearchName(option("kde-searchname"));
d->m_options.remove("kde-searchname");
KConfig *conf = KGlobal::config(), *pconf = KMFactory::self()->printConfig();
conf->setGroup("KPrinter Settings");
pconf->setGroup("General");
// load latest used printer from config file, if required in the options
if (searchName().isEmpty() && pconf->readBoolEntry("UseLast", true))
setSearchName(conf->readEntry("Printer"));
// latest used print command
setOption("kde-printcommand",conf->readPathEntry("PrintCommand"));
// latest used document directory
setDocDirectory( conf->readPathEntry( "DocDirectory" ) );
setDocFileName( "print" );
}
void KPrinter::saveSettings()
{
if (d->m_impl)
{
setOption("kde-searchname", searchName());
d->m_impl->saveOptions(d->m_options);
}
// save latest used printer to config file
KConfig *conf = KGlobal::config();
conf->setGroup("KPrinter Settings");
conf->writeEntry("Printer",searchName());
// latest used print command
conf->writePathEntry("PrintCommand",option("kde-printcommand"));
// latest used document directory
if ( d->m_docdirectory.isEmpty() )
{
KURL url( outputFileName() );
if ( url.isValid() )
conf->writePathEntry( "DocDirectory", url.directory() );
}
else
conf->writePathEntry( "DocDirectory", d->m_docdirectory );
}
bool KPrinter::setup(QWidget *parent, const QString& caption, bool forceExpand)
{
if (!kapp->authorize("print/dialog"))
{
autoConfigure(QString::null, parent);
return true; // Just print it
}
if (parent)
d->m_parentId = parent->winId();
KPrintDialog *dlg = KPrintDialog::printerDialog(this, parent, caption, forceExpand);
bool state = false;
if (dlg)
{
state = dlg->exec();
delete dlg;
}
return state;
}
void KPrinter::addStandardPage(int p)
{
KMFactory::self()->settings()->standardDialogPages |= p;
}
void KPrinter::removeStandardPage(int p)
{
KMFactory::self()->settings()->standardDialogPages &= (~p);
}
void KPrinter::addDialogPage(KPrintDialogPage *page)
{
KMFactory::self()->uiManager()->addPrintDialogPage(page);
}
void KPrinter::setPageSelection(PageSelectionType t)
{
KMFactory::self()->settings()->pageSelection = t;
}
KPrinter::PageSelectionType KPrinter::pageSelection()
{
return (PageSelectionType)KMFactory::self()->settings()->pageSelection;
}
void KPrinter::setApplicationType(ApplicationType t)
{
KMFactory::self()->settings()->application = t;
}
KPrinter::ApplicationType KPrinter::applicationType()
{
return (ApplicationType)KMFactory::self()->settings()->application;
}
bool KPrinter::cmd(int c, QPainter *painter, QPDevCmdParam *p)
{
bool value(true);
if (c == QPaintDevice::PdcBegin)
{
d->m_impl->statusMessage(i18n("Initialization..."), this);
d->m_pagenumber = 1;
preparePrinting();
d->m_impl->statusMessage(i18n("Generating print data: page %1").arg(d->m_pagenumber), this);
}
value = d->m_wrapper->cmd(c,painter,p);
if (c == QPaintDevice::PdcEnd)
{
// this call should take care of everything (preview, output-to-file, filtering, ...)
value = value && printFiles(QStringList(d->m_wrapper->outputFileName()),true);
// reset "ready" state
finishPrinting();
}
return value;
}
void KPrinter::translateQtOptions()
{
d->m_wrapper->setCreator(creator());
d->m_wrapper->setDocName(docName());
d->m_wrapper->setFullPage(fullPage());
d->m_wrapper->setColorMode((QPrinter::ColorMode)colorMode());
d->m_wrapper->setOrientation((QPrinter::Orientation)orientation());
if ( !option( "kde-printsize" ).isEmpty() )
d->m_wrapper->setPageSize( ( QPrinter::PageSize )option( "kde-printsize" ).toInt() );
else
d->m_wrapper->setPageSize((QPrinter::PageSize)pageSize());
d->m_wrapper->setOutputToFile(true);
d->m_wrapper->setOutputFileName(d->m_tmpbuffer);
d->m_wrapper->setNumCopies(option("kde-qtcopies").isEmpty() ? 1 : option("kde-qtcopies").toInt());
if (!option("kde-margin-top").isEmpty())
{
int res = resolution();
d->m_wrapper->setMargins(
( int )( ( option("kde-margin-top").toFloat() * res + 71 ) / 72 ),
( int )( ( option("kde-margin-left").toFloat() * res + 71 ) / 72 ),
( int )( ( option("kde-margin-bottom").toFloat() * res + 71 ) / 72 ),
( int )( ( option("kde-margin-right").toFloat() * res + 71 ) / 72 ) );
}
else if ( d->m_pagesize != NULL )
{
int res = resolution();
DrPageSize *ps = d->m_pagesize;
int top = ( int )( ps->topMargin() * res + 71 ) / 72;
int left = ( int )( ps->leftMargin() * res + 71 ) / 72;
int bottom = ( int )( ps->bottomMargin() * res + 71 ) / 72;
int right = ( int )( ps->rightMargin() * res + 71 ) / 72;
if ( !fullPage() )
{
// Printers can often print very close to the edges (PPD files say ImageArea==PaperDimension).
// But that doesn't mean it looks good. Apps which use setFullPage(false) assume that
// KPrinter will give them reasonable margins, so let's QMAX with defaults from Qt in that case.
// Keep this in sync with KPMarginPage::initPageSize
unsigned int it, il, ib, ir;
d->m_wrapper->margins( &it, &il, &ib, &ir );
top = QMAX( top, (int)it );
left = QMAX( left, (int)il );
bottom = QMAX( bottom, (int)ib );
right = QMAX( right, (int)ir );
}
d->m_wrapper->setMargins( top, left, bottom, right );
}
/*else
{
int res = d->m_wrapper->resolution();
d->m_wrapper->setMargins( res/3, res/2, res/3, res/2 );
}*/
// for special printers, copies are handled by Qt
if (option("kde-isspecial") == "1")
d->m_wrapper->setNumCopies(numCopies());
}
bool KPrinter::printFiles(const QStringList& l, bool flag, bool startviewer)
{
QStringList files(l);
bool status(true);
// First apply possible filters, and update "remove" flag if filters has
// been applied (result == 0, means nothing happened).
int fresult = d->m_impl->filterFiles(this, files, flag);
if (fresult == -1)
{
reportError(this);
status = false;
}
else if (fresult == 1)
flag = true;
if (status)
{
// Automatic conversion to format supported by print system
fresult = d->m_impl->autoConvertFiles(this, files, flag);
if (fresult == -1)
{
reportError(this);
status = false;
}
else if (fresult == 1)
flag = true;
}
// Continue if status is OK (filtering succeeded) and no output-to-file
if (status && files.count() > 0)
{
// Show preview if needed (only possible for a single file !), and stop
// if the user requested it. Force preview if preview-only mode has been set: it
// then use by default the first file in the list.
if (((files.count() != 1 || option("kde-preview") != "1") && !d->m_previewonly) || doPreview(files[0]))
{
// check if printing has been prepared (it may be not prepared if the KPrinter object is not
// use as a QPaintDevice object)
preparePrinting();
if (!d->m_impl->printFiles(this, files, flag))
{
reportError(this);
status = false;
}
else
{
if (/* !outputToFile() && */ startviewer)
{
QStringList args;
args << "-d";
args << printerName();
args << "--noshow";
kapp->kdeinitExec("kjobviewer", args);
}
}
}
else if (flag)
// situation: only one file, it has been previewed and printing has been canceled, then
// we should remove the file ourself
{
QFile::remove(files[0]);
}
}
finishPrinting();
return status;
}
bool KPrinter::doPreview(const QString& file)
{
d->m_impl->statusMessage(i18n("Previewing..."), this);
d->m_impl->statusMessage(QString::null, this);
return KPrintPreview::preview(file, d->m_previewonly, d->m_parentId);
}
void KPrinter::preparePrinting()
{
// check if already prepared (-> do nothing)
if (d->m_ready) return;
// re-initialize error
setErrorMessage(QString::null);
// re-initialize margins and page size (by default, use Qt mechanism)
setRealPageSize(NULL);
// print-system-specific setup, only if not printing to file
if (option("kde-isspecial") != "1")
d->m_impl->preparePrinting(this);
// set the correct resolution, if needed (or reset it)
int res = option( "kde-resolution" ).toInt();
if ( d->m_useprinterres && res > 0 )
d->m_wrapper->setResolution( res );
else
d->m_wrapper->setResolution( d->m_defaultres );
// standard Qt settings
translateQtOptions();
d->m_ready = true;
dumpOptions(d->m_options);
}
void KPrinter::finishPrinting()
{
d->m_ready = false;
// close the status window
d->m_impl->statusMessage(QString::null, this);
}
QValueList<int> KPrinter::pageList() const
{
QValueList<int> list;
int mp(minPage()), MP(maxPage());
if (mp > 0 && MP > 0 && MP >= mp)
{ // do something only if bounds specified
if (option("kde-current") == "1")
{ // print only current page
int pp = currentPage();
if (pp >= mp && pp <= MP) list.append(pp);
}
else
{
// process range specification
if (!option("kde-range").isEmpty())
{
QStringList ranges = QStringList::split(',',option("kde-range"),false);
for (QStringList::ConstIterator it=ranges.begin();it!=ranges.end();++it)
{
int p = (*it).find('-');
bool ok;
if (p == -1)
{
int pp = (*it).toInt(&ok);
if (ok && pp >= mp && pp <= MP)
list.append(pp);
}
else
{
int p1(0), p2(0);
p1 = (*it).left(p).toInt(&ok);
if (ok) p2 = (*it).right((*it).length()-p-1).toInt(&ok);
if (ok && p1 <= p2)
{
// clip to min/max
p1 = QMAX(mp,p1);
p2 = QMIN(MP,p2);
for (int i=p1;i<=p2;i++)
list.append(i);
}
}
}
}
else
{ // add all pages between min and max
for (int i=mp;i<=MP;i++) list.append(i);
}
// revert the list if needed
if (pageOrder() == LastPageFirst)
{
for (uint i=0;i<(list.count()/2);i++)
qSwap(list[i],list[list.count()-1-i]);
}
// select page set if needed
if (pageSet() != AllPages)
{
bool keepEven = (pageSet() == EvenPages);
for (QValueList<int>::Iterator it=list.begin();it!=list.end();)
if ((((*it) % 2) != 0 && keepEven) ||
(((*it) % 2) == 0 && !keepEven)) it = list.remove(it);
else ++it;
}
}
}
return list;
}
//**************************************************************************************
// QPrinter interface
//**************************************************************************************
int KPrinter::numCopies() const
{
bool ok;
int p = option("kde-copies").toInt(&ok);
return (ok ? p : 1);
}
QSize KPrinter::margins() const
{
return d->m_wrapper->margins();
}
void KPrinter::margins( uint *top, uint *left, uint *bottom, uint *right ) const
{
d->m_wrapper->margins( top, left, bottom, right );
}
int KPrinter::metric(int m) const
{
if (d->m_pagesize == NULL || !option( "kde-printsize" ).isEmpty())
return d->m_wrapper->qprinterMetric(m);
int val(0);
bool land = (orientation() == KPrinter::Landscape);
uint res(d->m_wrapper->resolution()), top = res/2, left = res/2, bottom = res/3, right = res/2;
margins( &top, &left, &bottom, &right );
switch ( m )
{
case QPaintDeviceMetrics::PdmWidth:
val = (land ? ( int )d->m_pagesize->pageHeight() : ( int )d->m_pagesize->pageWidth());
if ( res != 72 )
val = (val * res + 36) / 72;
if ( !fullPage() )
val -= ( left + right );
break;
case QPaintDeviceMetrics::PdmHeight:
val = (land ? ( int )d->m_pagesize->pageWidth() : ( int )d->m_pagesize->pageHeight());
if ( res != 72 )
val = (val * res + 36) / 72;
if ( !fullPage() )
val -= ( top + bottom );
break;
case QPaintDeviceMetrics::PdmWidthMM:
val = metric( QPaintDeviceMetrics::PdmWidth );
val = (val * 254 + 5*res) / (10*res); // +360 to get the right rounding
break;
case QPaintDeviceMetrics::PdmHeightMM:
val = metric( QPaintDeviceMetrics::PdmHeight );
val = (val * 254 + 5*res) / (10*res);
break;
default:
val = d->m_wrapper->qprinterMetric(m);
break;
}
return val;
}
void KPrinter::setOrientation(Orientation o)
{
KMFactory::self()->settings()->orientation = o;
setOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
d->m_impl->broadcastOption("kde-orientation",(o == Landscape ? "Landscape" : "Portrait"));
d->m_impl->broadcastOption( "kde-orientation-fixed", "1" );
}
void KPrinter::setOption( const QString& key, const QString& value, bool broadcast )
{
setOption( key, value );
if ( broadcast )
d->m_impl->broadcastOption( key, value );
}
void KPrinter::setPageSize(PageSize s)
{
KMFactory::self()->settings()->pageSize = s;
setOption("kde-pagesize",QString::number((int)s),true);
d->m_impl->broadcastOption( "kde-pagesize-fixed", "1" );
}
void KPrinter::setOptions(const QMap<QString,QString>& opts)
{ // This functions remove all options except those with "kde-..."
// which correspond to externally-sets options (use the value
// from "opts" if specified
QMap<QString,QString> tmpset = d->m_options;
d->m_options = opts;
// remove some problematic options that may not be overwritten (ugly hack).
// Default values will be used instead, except if the dialog has set new ones.
tmpset.remove("kde-pagesize");
tmpset.remove( "kde-printsize" );
tmpset.remove("kde-orientation");
tmpset.remove("kde-colormode");
tmpset.remove("kde-margin-top");
tmpset.remove("kde-margin-left");
tmpset.remove("kde-margin-bottom");
tmpset.remove("kde-margin-right");
tmpset.remove( "kde-resolution" );
tmpset.remove( "kde-fonts" );
for (QMap<QString,QString>::ConstIterator it=tmpset.begin();it!=tmpset.end();++it)
if (it.key().left(4) == "kde-" && !(d->m_options.contains(it.key())))
d->m_options[it.key()] = it.data();
}
void KPrinter::initOptions(const QMap<QString,QString>& opts)
{ // This function can be used to initialize the KPrinter object just after
// creation to set some options. Non global options will be propagated to
// all listed printers (non-global => start with "kde-...")
for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
{
setOption(it.key(), it.data());
if (it.key().left(4) != "kde-")
d->m_impl->broadcastOption(it.key(),it.data());
}
}
void KPrinter::reload()
{
d->m_impl = KMFactory::self()->printerImplementation();
int global = KMFactory::self()->settings()->orientation;
if (global != -1) setOrientation((KPrinter::Orientation)global);
global = KMFactory::self()->settings()->pageSize;
if (global != -1) setPageSize((KPrinter::PageSize)global);
//initOptions(d->m_options);
}
bool KPrinter::autoConfigure(const QString& prname, QWidget *parent)
{
KMManager *mgr = KMManager::self();
KMPrinter *mprt(0);
mgr->printerList(false);
if (prname.isEmpty())
mprt = mgr->defaultPrinter();
else
mprt = mgr->findPrinter(prname);
if (mprt)
return mprt->autoConfigure(this, parent);
else
return false;
}
//**************************************************************************************
// Util functions
//**************************************************************************************
void reportError(KPrinter *p)
{
if (!KNotifyClient::event(0,"printerror",i18n("<p><nobr>A print error occurred. Error message received from system:</nobr></p><br>%1").arg(p->errorMessage())))
kdDebug(500) << "could not send notify event" << endl;
}
KPrinter::PageSize pageNameToPageSize(const QString& _name)
{
QString name = _name.upper();
if (name == "LETTER") return KPrinter::Letter;
else if (name == "LEGAL") return KPrinter::Legal;
else if (name == "A4") return KPrinter::A4;
else if (name == "A3") return KPrinter::A3;
else if (name == "EXECUTIVE") return KPrinter::Executive;
else if (name == "LEDGER") return KPrinter::Ledger;
else if (name == "TABLOID") return KPrinter::Tabloid;
else if (name == "FOLIO") return KPrinter::Folio;
else if (name == "A5") return KPrinter::A5;
else if (name == "A6") return KPrinter::A6;
else if (name == "A7") return KPrinter::A7;
else if (name == "A8") return KPrinter::A8;
else if (name == "A9") return KPrinter::A9;
else if (name == "A2") return KPrinter::A2;
else if (name == "A1") return KPrinter::A1;
else if (name == "A0") return KPrinter::A0;
else if (name == "B0" || name == "B0ISO") return KPrinter::B0;
else if (name == "B1" || name == "B1ISO") return KPrinter::B1;
else if (name == "B2" || name == "B2ISO") return KPrinter::B2;
else if (name == "B3" || name == "B3ISO") return KPrinter::B3;
else if (name == "B4" || name == "B4ISO") return KPrinter::B4;
else if (name == "B5" || name == "B5ISO") return KPrinter::B5;
else if (name == "B6" || name == "B6ISO") return KPrinter::B6;
else if (name == "B7" || name == "B7ISO") return KPrinter::B7;
else if (name == "B8" || name == "B8ISO") return KPrinter::B8;
else if (name == "B9" || name == "B9ISO") return KPrinter::B9;
else if (name == "B10" || name == "B10ISO") return KPrinter::B10;
else if (name == "C5" || name == "C5E" || name == "ENVC5") return KPrinter::C5E;
else if (name == "DL" || name == "DLE" || name == "ENVDL") return KPrinter::DLE;
else if (name == "COMM10" || name == "COM10" || name == "ENV10") return KPrinter::Comm10E;
else return KPrinter::A4;
}
const char* pageSizeToPageName(KPrinter::PageSize s)
{
switch(s)
{
case KPrinter::Letter: return "Letter";
case KPrinter::Legal: return "Legal";
case KPrinter::A4: return "A4";
case KPrinter::A3: return "A3";
case KPrinter::Executive: return "Executive";
case KPrinter::Ledger: return "Ledger";
case KPrinter::Tabloid: return "Tabloid";
case KPrinter::Folio: return "Folio";
case KPrinter::A5: return "A5";
case KPrinter::A6: return "A6";
case KPrinter::A7: return "A7";
case KPrinter::A8: return "A8";
case KPrinter::A9: return "A9";
case KPrinter::A2: return "A2";
case KPrinter::A1: return "A1";
case KPrinter::A0: return "A0";
case KPrinter::B0: return "B0";
case KPrinter::B1: return "B1";
case KPrinter::B2: return "B2";
case KPrinter::B3: return "B3";
case KPrinter::B4: return "B4";
case KPrinter::B5: return "B5";
case KPrinter::B6: return "B6";
case KPrinter::B7: return "B7";
case KPrinter::B8: return "B8";
case KPrinter::B9: return "B9";
case KPrinter::B10: return "B10";
case KPrinter::C5E: return "C5";
case KPrinter::DLE: return "DL";
case KPrinter::Comm10E: return "Comm10";
default: return "A4";
}
}
// FIXME: remove for 4.0
QSize rangeToSize( const QString& )
{
kdWarning( 500 ) << "rangeToSize(QString) is obsolete, do not use (no effect)" << endl;
return QSize();
}
static void dumpOptions(const QMap<QString,QString>& opts)
{
kdDebug(500) << "********************" << endl;
for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
kdDebug(500) << it.key() << " = " << it.data() << endl;
}
KPrinterImpl* KPrinter::implementation() const
{ return d->m_impl; }
const QString& KPrinter::option(const QString& key) const
{ return ((const KPrinterPrivate*)(d))->m_options[key]; }
void KPrinter::setOption(const QString& key, const QString& value)
{ d->m_options[key] = value; }
QString KPrinter::docName() const
{ return option("kde-docname"); }
void KPrinter::setDocName(const QString& d)
{ setOption("kde-docname",d); }
QString KPrinter::creator() const
{ return option("kde-creator"); }
void KPrinter::setCreator(const QString& d)
{ setOption("kde-creator",d); }
bool KPrinter::fullPage() const
{ return (option("kde-fullpage") == "1"); }
void KPrinter::setFullPage(bool on)
{ setOption("kde-fullpage",(on ? "1" : "0")); }
KPrinter::ColorMode KPrinter::colorMode() const
{ return (KPrinter::ColorMode)(option("kde-colormode") == "GrayScale" ? GrayScale : Color); }
void KPrinter::setColorMode(ColorMode m)
{ setOption("kde-colormode",(m == Color ? "Color" : "GrayScale")); }
void KPrinter::setNumCopies(int n)
{ setOption("kde-copies",QString::number(n)); }
KPrinter::Orientation KPrinter::orientation() const
{ return (option("kde-orientation") == "Landscape" ? Landscape : Portrait); }
KPrinter::PageOrder KPrinter::pageOrder() const
{ return (option("kde-pageorder") == "Reverse" ? LastPageFirst : FirstPageFirst); }
void KPrinter::setPageOrder(PageOrder o)
{ setOption("kde-pageorder",(o == LastPageFirst ? "Reverse" : "Forward")); }
KPrinter::CollateType KPrinter::collate() const
{ return (option("kde-collate") == "Collate" ? Collate : Uncollate); }
void KPrinter::setCollate(CollateType c)
{ setOption("kde-collate",(c == Collate ? "Collate" : "Uncollate")); }
int KPrinter::minPage() const
{ return (option("kde-minpage").isEmpty() ? 0 : option("kde-minpage").toInt()); }
int KPrinter::maxPage() const
{ return (option("kde-maxpage").isEmpty() ? 0 : option("kde-maxpage").toInt()); }
void KPrinter::setMinMax(int m, int M)
{ setOption("kde-minpage",QString::number(m)); setOption("kde-maxpage",QString::number(M)); }
int KPrinter::fromPage() const
{ return (option("kde-frompage").isEmpty() ? 0 : option("kde-frompage").toInt()); }
int KPrinter::toPage() const
{ return (option("kde-topage").isEmpty() ? 0 : option("kde-topage").toInt()); }
void KPrinter::setFromTo(int m, int M)
{ 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(""))); }
// if no page size defined, use the localized one
KPrinter::PageSize KPrinter::pageSize() const
{ return (option("kde-pagesize").isEmpty() ? (PageSize)KGlobal::locale()->pageSize() : (PageSize)option("kde-pagesize").toInt()); }
KPrinter::PageSetType KPrinter::pageSet() const
{ return (option("kde-pageset").isEmpty() ? AllPages : (PageSetType)(option("kde-pageset").toInt())); }
int KPrinter::currentPage() const
{ return (option("kde-currentpage").isEmpty() ? 0 : option("kde-currentpage").toInt()); }
void KPrinter::setCurrentPage(int p)
{ setOption("kde-currentpage",QString::number(p)); }
QString KPrinter::printerName() const
{ return d->m_printername; }
void KPrinter::setPrinterName(const QString& s)
{ d->m_printername = s; }
QString KPrinter::printProgram() const
{ return (option("kde-isspecial") == "1" ? option("kde-special-command") : QString::null); }
void KPrinter::setPrintProgram(const QString& prg)
{
if (prg.isNull())
{
setOption("kde-isspecial", "0");
d->m_options.remove("kde-special-command");
}
else
{
QString s(prg);
if (s.find("%in") == -1)
s.append(" %in");
setOutputToFile( s.find( "%out" ) != -1 );
setOption("kde-isspecial", "1");
setOption("kde-special-command", s);
}
}
QString KPrinter::printerSelectionOption() const
{ return QString::fromLatin1(""); }
void KPrinter::setPrinterSelectionOption(const QString&)
{}
const QMap<QString,QString>& KPrinter::options() const
{ return d->m_options; }
QString KPrinter::searchName() const
{ return d->m_searchname; }
void KPrinter::setSearchName(const QString& s)
{ d->m_searchname = s; }
bool KPrinter::newPage()
{
d->m_pagenumber++;
d->m_impl->statusMessage(i18n("Generating print data: page %1").arg(d->m_pagenumber), this);
return d->m_wrapper->newPage();
}
QString KPrinter::outputFileName() const
{ return option("kde-outputfilename"); }
void KPrinter::setOutputFileName(const QString& f)
{ setOption("kde-outputfilename",f); setOutputToFile(!f.isEmpty()); }
bool KPrinter::outputToFile() const
{ return (option("kde-outputtofile") == "1" || (option("kde-isspecial") == "1" && option("kde-special-command").isEmpty())); }
void KPrinter::setOutputToFile(bool on)
{
setOption("kde-outputtofile",(on ? "1" : "0"));
if (on)
{
setOption("kde-special-command",QString::null);
setOption("kde-isspecial","1");
}
}
bool KPrinter::abort()
{ return d->m_wrapper->abort(); }
bool KPrinter::aborted() const
{ return d->m_wrapper->aborted(); }
void KPrinter::setMargins(QSize m)
{
setMargins( m.height(), m.width(), m.height(), m.width() );
}
void KPrinter::setMargins( uint top, uint left, uint bottom, uint right )
{
d->m_wrapper->setMargins( top, left, bottom, right );
setOption( "kde-margin-top", QString::number( top ), true );
setOption( "kde-margin-left", QString::number( left ), true );
setOption( "kde-margin-bottom", QString::number( bottom ), true );
setOption( "kde-margin-right", QString::number( right ), true );
}
// FIXME: remove for 4.0
QSize KPrinter::realPageSize() const
{
kdWarning( 500 ) << "KPrinter::realPageSize() is obsolete, do not use" << endl;
if ( d->m_pagesize )
return d->m_pagesize->pageSize();
else
return QSize();
}
void KPrinter::setRealPageSize(DrPageSize *p)
{
if ( p )
{
kdDebug( 500 ) << "Page size: width =" << p->pageWidth() << endl;
kdDebug( 500 ) << "Page size: height =" << p->pageHeight() << endl;
kdDebug( 500 ) << "Page size: left =" << p->leftMargin() << endl;
kdDebug( 500 ) << "Page size: top =" << p->topMargin() << endl;
kdDebug( 500 ) << "Page size: right =" << p->rightMargin() << endl;
kdDebug( 500 ) << "Page size: bottom =" << p->bottomMargin() << endl;
}
else
kdDebug( 500 ) << "Resetting page size" << endl;
/* we copy the page size structure internally
* as the original object is owned by the driver
* that control its destrution */
delete d->m_pagesize;
d->m_pagesize = 0;
if ( p )
d->m_pagesize = new DrPageSize( *p );
}
// FIXME: remove for 4.0
void KPrinter::setRealPageSize( QSize )
{
kdWarning( 500 ) << "KPrinter::setRealPageSize(QSize) is obsolete, do not use (no effect)" << endl;
}
// FIXME: remove for 4.0
void KPrinter::setRealDrawableArea( const QRect& )
{
kdWarning( 500 ) << "KPrinter::setRealDrawableArea(QRect) is obsolete, do not use (no effect)" << endl;
}
// FIXME: remove for 4.0
QRect KPrinter::realDrawableArea() const
{
kdWarning( 500 ) << "KPrinter::realDrawableArea() is obsolete, do not use" << endl;
if ( d->m_pagesize )
return d->m_pagesize->pageRect();
else
return QRect();
}
QString KPrinter::errorMessage() const
{ return d->m_errormsg; }
void KPrinter::setErrorMessage(const QString& msg)
{ d->m_errormsg = msg; }
/* we're using a builtin member to store this state because we don't
* want to keep it from object to object. So there's no need to use
* the QMap structure to store this
*/
void KPrinter::setPreviewOnly(bool on)
{ d->m_previewonly = on; }
bool KPrinter::previewOnly() const
{ return d->m_previewonly; }
void KPrinter::setDocFileName(const QString& s)
{ d->m_docfilename = s; }
QString KPrinter::docFileName() const
{ return d->m_docfilename; }
void KPrinter::setDocDirectory( const QString& s )
{ d->m_docdirectory = s; }
QString KPrinter::docDirectory() const
{ return ( d->m_docdirectory.isEmpty() ? QDir::homeDirPath() : d->m_docdirectory ); }
void KPrinter::setResolution(int dpi)
{
d->m_wrapper->setResolution(dpi);
d->m_defaultres = dpi;
}
int KPrinter::resolution() const
{ return d->m_wrapper->resolution(); }
void KPrinter::setUsePrinterResolution( bool on )
{ d->m_useprinterres = on; }
KPrinter::collate
CollateType collate() const
Returns the collate status of the current KPrinter.
Definition: kprinter.cpp:827
KPrinter::setResolution
void setResolution(int dpi)
Set the resolution of the current KPrinter object.
Definition: kprinter.cpp:1035
KPrinter::setSearchName
void setSearchName(const QString &n)
Sets the search name of the KPrinter object.
Definition: kprinter.cpp:903
KPrinter::ColorMode
ColorMode
Defines the color mode of the printer.
Definition: kprinter.h:152
KPrinter::searchName
QString searchName() const
Returns the search name of the printer selected by the user.
Definition: kprinter.cpp:900
KPrinter::ApplicationType
ApplicationType
Defines the type of the application, this affects the GUI of the print dialog:
Definition: kprinter.h:126
KPrinter::addDialogPage
static void addDialogPage(KPrintDialogPage *_page)
Adds a customized page to the print dialog.
Definition: kprinter.cpp:250
KPrinter::abort
bool abort()
See QPrinter::abort().
Definition: kprinter.cpp:932
KPrinter::setDocName
void setDocName(const QString &)
See QPrinter::setDocName().
Definition: kprinter.cpp:794
KPrinter::printerName
QString printerName() const
See QPrinter::printerName().
Definition: kprinter.cpp:864
KPrinter::setRealPageSize
void setRealPageSize(QSize p)
DO NOT USE, WILL BE REMOVED.
Definition: kprinter.cpp:986
KPrinter::setPreviewOnly
void setPreviewOnly(bool on)
Sets the KPrinter object to preview mode if on is true.
Definition: kprinter.cpp:1017
KPrinter::fullPage
bool fullPage() const
See QPrinter::fullPage().
Definition: kprinter.cpp:803
KPrinter::currentPage
int currentPage() const
Returns the current page number.
Definition: kprinter.cpp:858
KPrinter::margins
QSize margins() const
See QPrinter::margins().
Definition: kprinter.cpp:550
KPrinter::setColorMode
void setColorMode(ColorMode)
See QPrinter::setColorMode().
Definition: kprinter.cpp:812
KPrinter::minPage
int minPage() const
See QPrinter::minPage().
Definition: kprinter.cpp:833
KPrinter::setMargins
void setMargins(QSize m)
Not used yet.
Definition: kprinter.cpp:938
KPrinter::setCollate
void setCollate(CollateType type)
Sets the collate status for the current KPrinter to type.
Definition: kprinter.cpp:830
KPrinter::setPageSelection
static void setPageSelection(PageSelectionType _mode)
Sets the page selection mode of the application.
Definition: kprinter.cpp:255
KPrinter::initOptions
void initOptions(const QMap< QString, QString > &opts)
For internal use only.
Definition: kprinter.cpp:645
KPrinter::autoConfigure
bool autoConfigure(const QString &prname=QString::null, QWidget *parent=0)
Configure the KPrinter object to be used with the printer named prname.
Definition: kprinter.cpp:667
KPrinter::setPrintProgram
void setPrintProgram(const QString &cmd)
Sets the command line to use when printing.
Definition: kprinter.cpp:873
KPrinter::docDirectory
QString docDirectory() const
Get the default document directory, that is the directory used for any output file.
Definition: kprinter.cpp:1032
KPrinter::setMinMax
void setMinMax(int, int)
See QPrinter::setMinMax().
Definition: kprinter.cpp:839
KPrinter::realPageSize
QSize realPageSize() const
Returns the page size in dot unit ( 1 dot = 1/72th in ).
Definition: kprinter.cpp:953
KPrinter::outputFileName
QString outputFileName() const
See QPrinter::outputFileName().
Definition: kprinter.cpp:913
KPrinter
This class is the main interface to access the KDE print framework.
Definition: kprinter.h:88
KPrinter::orientation
Orientation orientation() const
See QPrinter::orientation().
Definition: kprinter.cpp:818
KPrinter::previewOnly
bool previewOnly() const
Returns the preview-only state for this KPrinter object.
Definition: kprinter.cpp:1020
KPrinter::removeStandardPage
static void removeStandardPage(int p)
Removes a standard page from the print dialog.
Definition: kprinter.cpp:245
KPrinter::pageList
QValueList< int > pageList() const
Returns the page list to be printed, correpsonding to the options selected by the user...
Definition: kprinter.cpp:470
KPrinter::setUsePrinterResolution
void setUsePrinterResolution(bool on)
Define the KPrinter object to use the actual printer resolution.
Definition: kprinter.cpp:1044
KPrinter::printerSelectionOption
QString printerSelectionOption() const
See QPrinter::printerSelectionOption().
Definition: kprinter.cpp:891
KPrinter::pageSelection
static PageSelectionType pageSelection()
Returns the page selection mode of the current application.
Definition: kprinter.cpp:260
KPrinter::PageSetType
PageSetType
Defines the page set to print:
Definition: kprinter.h:137
KPrinter::PageOrder
PageOrder
Defines the page order of the print job.
Definition: kprinter.h:162
KPrinter::translateQtOptions
void translateQtOptions()
Definition: kprinter.cpp:296
KPrinter::setFromTo
void setFromTo(int, int)
Sets the first and last page to be printed.
Definition: kprinter.cpp:848
KPrinter::pageOrder
PageOrder pageOrder() const
See QPrinter::pageOrder().
Definition: kprinter.cpp:821
KPrinter::PageSelectionType
PageSelectionType
Defines whether the application can perform page selection itself or not.
Definition: kprinter.h:116
KPrinter::aborted
bool aborted() const
See QPrinter::aborted(.)
Definition: kprinter.cpp:935
KPrinter::setApplicationType
static void setApplicationType(ApplicationType type)
Sets the application type concerning the print dialog.
Definition: kprinter.cpp:265
KPrinter::setPageOrder
void setPageOrder(PageOrder)
See QPrinter::setPageOrder().
Definition: kprinter.cpp:824
KPrinter::KPrinter
KPrinter(bool restore=true, QPrinter::PrinterMode m=QPrinter::ScreenResolution)
Constructor.
Definition: kprinter.cpp:123
KPrinter::option
const QString & option(const QString &key) const
Starts the add printer wizard.
Definition: kprinter.cpp:785
KPrinter::realDrawableArea
QRect realDrawableArea() const
DO NOT USE, WILL BE REMOVED.
Definition: kprinter.cpp:998
KPrinter::errorMessage
QString errorMessage() const
Returns the last error message issued by the print system.
Definition: kprinter.cpp:1007
KPrinter::setOutputFileName
void setOutputFileName(const QString &)
See QPrinter::setOutputFileName().
Definition: kprinter.cpp:916
KPrinter::printProgram
QString printProgram() const
Returns the print program as set by setPrintProgram() or by the print dialog if a special printer has...
Definition: kprinter.cpp:870
KPrinter::creator
QString creator() const
See QPrinter::creator().
Definition: kprinter.cpp:797
KPrinter::newPage
bool newPage()
See QPrinter::newPage().
Definition: kprinter.cpp:906
KPrinter::setOrientation
void setOrientation(Orientation)
See QPrinter::setOrientation().
Definition: kprinter.cpp:600
KPrinter::setErrorMessage
void setErrorMessage(const QString &msg)
Sets the last error message.
Definition: kprinter.cpp:1010
KPrinter::setPageSize
void setPageSize(PageSize)
See QPrinter::setPageSize().
Definition: kprinter.cpp:615
KPrinter::resolution
int resolution() const
Resturns the resolution of the current KPrinter object.
Definition: kprinter.cpp:1041
KPrinter::setOption
void setOption(const QString &key, const QString &value)
Adds or modifies an option in the KPrinter object.
Definition: kprinter.cpp:788
KPrinter::pageSize
PageSize pageSize() const
See QPrinter::pageSize().
Definition: kprinter.cpp:852
KPrinter::printFiles
bool printFiles(const QStringList &files, bool removeafter=false, bool startviewer=true)
Prints the files given in argument.
Definition: kprinter.cpp:358
KPrinter::~KPrinter
~KPrinter()
Destructor.
Definition: kprinter.cpp:129
KPrinter::setNumCopies
void setNumCopies(int n)
See QPrinter::setNumCopies().
Definition: kprinter.cpp:815
KPrintDialogPage
This class is intended to be used as base class for customized print dialog page. ...
Definition: kprintdialogpage.h:90
KPrinter::maxPage
int maxPage() const
See QPrinter::maxPage().
Definition: kprinter.cpp:836
KPrinter::setCreator
void setCreator(const QString &)
See QPrinter::setCreator().
Definition: kprinter.cpp:800
KPrinter::outputToFile
bool outputToFile() const
See QPrinter::outputToFile().
Definition: kprinter.cpp:919
KPrinter::docName
QString docName() const
See QPrinter::docName().
Definition: kprinter.cpp:791
KPrinter::CollateType
CollateType
Defines the collate property of the printer (if supported by the print system):
Definition: kprinter.h:145
KPrinter::docFileName
QString docFileName() const
Get the default document filename, that is the default basename used for the output file...
Definition: kprinter.cpp:1026
KPrinter::numCopies
int numCopies() const
See QPrinter::numCopies().
Definition: kprinter.cpp:543
KPrinter::setPrinterSelectionOption
void setPrinterSelectionOption(const QString &)
See QPrinter::setPrinterSelectionOption().
Definition: kprinter.cpp:894
KPrinter::toPage
int toPage() const
Returns the last page to be printed.
Definition: kprinter.cpp:845
KPrinter::setPrinterName
void setPrinterName(const QString &)
See QPrinter::setPrinterName().
Definition: kprinter.cpp:867
KPrinter::fromPage
int fromPage() const KDE_DEPRECATED
Returns the first page to be printed.
Definition: kprinter.cpp:842
KPrinter::applicationType
static ApplicationType applicationType()
Returns the application type concerning the print dialog.
Definition: kprinter.cpp:270
KPrinter::PageSize
PageSize
Defines the paper size to use.
Definition: kprinter.h:167
KPrinter::setDocFileName
void setDocFileName(const QString &filename)
Set the default document filename.
Definition: kprinter.cpp:1023
KPrinter::setRealDrawableArea
void setRealDrawableArea(const QRect &r)
DO NOT USE, WILL BE REMOVED.
Definition: kprinter.cpp:992
KPrinter::setCurrentPage
void setCurrentPage(int p=0)
Sets the current page number.
Definition: kprinter.cpp:861
KPrinter::setDocDirectory
void setDocDirectory(const QString &dir)
Set the default document directory.
Definition: kprinter.cpp:1029
KPrinter::pageSet
PageSetType pageSet() const
Returns the page set of the current KPrinter object.
Definition: kprinter.cpp:855
KPrinter::implementation
KPrinterImpl * implementation() const
For internal use only.
Definition: kprinter.cpp:782
KPrinter::setup
bool setup(QWidget *parent=0, const QString &caption=QString::null, bool forceExpand=false)
Sets up the KPrinter object using the print dialog, returns true if the user clicked OK...
Definition: kprinter.cpp:219
KPrinter::addStandardPage
static void addStandardPage(int p)
Adds a standard page to the print dialog.
Definition: kprinter.cpp:240
KPrinter::colorMode
ColorMode colorMode() const
See QPrinter::colorMode().
Definition: kprinter.cpp:809
KPrinter::setFullPage
void setFullPage(bool)
See QPrinter::setFullPage().
Definition: kprinter.cpp:806
KPrinter::Orientation
Orientation
Defines the orientation of the paper.
Definition: kprinter.h:157
KPrinter::setOptions
void setOptions(const QMap< QString, QString > &opts)
Sets the option set in one operation.
Definition: kprinter.cpp:622
KPrinter::options
const QMap< QString, QString > & options() const
Returns the complete set of print options from the KPrinter object.
Definition: kprinter.cpp:897
KPrinter::setOutputToFile
void setOutputToFile(bool)
See QPrinter::setOutputToFile().
Definition: kprinter.cpp:922

KDE Home | KDE Accessibility Home | Description of Access Keys