Public Functions
void	_q_btnBrowseClicked ()

void	_q_btnPropertiesClicked ()

void	_q_printerChanged (int index)

void	applyPrinterProperties (QPrinter *p)
	copy printer properties to the widget More...

bool	checkFields ()

	QUnixPrintWidgetPrivate (QUnixPrintWidget *q)

void	setCupsProperties ()

void	setOptionsPane (QPrintDialogPrivate *pane)

void	setupPrinter ()

void	updateWidget ()

	~QUnixPrintWidgetPrivate ()

Public Variables
QList< QPrinterDescription >	lprPrinters

QUnixPrintWidget *const	parent

QPrinter *	printer

QPrintPropertiesDialog *	propertiesDialog

QAbstractPrintDialog *	q

Ui::QPrintWidget	widget

Properties
QCUPSSupport *	cups

const ppd_file_t *	cupsPPD

int	cupsPrinterCount

const cups_dest_t *	cupsPrinters

bool	filePrintersAdded

QPrintDialogPrivate *	optionsPane

Detailed Description

Definition at line 144 of file qprintdialog_unix.cpp.

Constructors and Destructors

◆ QUnixPrintWidgetPrivate()

QUnixPrintWidgetPrivate::QUnixPrintWidgetPrivate ( QUnixPrintWidget * p )

Warning: This function is not part of the public interface.

Definition at line 660 of file qprintdialog_unix.cpp.

Referenced by setupPrinter().

     : parent(p), propertiesDialog(0), printer(0), optionsPane(0), filePrintersAdded(false)
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     , cups(0), cupsPrinterCount(0), cupsPrinters(0), cupsPPD(0)
 #endif
 {
     q = 0;
     if (parent)
         q = qobject_cast<QAbstractPrintDialog*> (parent->parent());
 
     widget.setupUi(parent);
 
     int currentPrinterIndex = 0;
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     cups = new QCUPSSupport;
     if (QCUPSSupport::isAvailable()) {
         cupsPPD = cups->currentPPD();
         cupsPrinterCount = cups->availablePrintersCount();
         cupsPrinters = cups->availablePrinters();
 
         for (int i = 0; i < cupsPrinterCount; ++i) {
             QString printerName(QString::fromLocal8Bit(cupsPrinters[i].name));
             if (cupsPrinters[i].instance)
                 printerName += QLatin1Char('/') + QString::fromLocal8Bit(cupsPrinters[i].instance);
 
             widget.printers->addItem(printerName);
             if (cupsPrinters[i].is_default)
                 widget.printers->setCurrentIndex(i);
         }
         // the model depends on valid ppd. so before enabling the
         // properties button we make sure the ppd is in fact valid.
         if (cupsPrinterCount && cups->currentPPD()) {
             widget.properties->setEnabled(true);
         }
         currentPrinterIndex = cups->currentPrinterIndex();
     } else {
 #endif
         currentPrinterIndex = qt_getLprPrinters(lprPrinters);
         // populating printer combo
         QList<QPrinterDescription>::const_iterator i = lprPrinters.constBegin();
         for(; i != lprPrinters.constEnd(); ++i)
             widget.printers->addItem((*i).name);
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     }
 #endif
 
 #if !defined(QT_NO_FILESYSTEMMODEL) && !defined(QT_NO_COMPLETER)
     QFileSystemModel *fsm = new QFileSystemModel(widget.filename);
     fsm->setRootPath(QDir::homePath());
     widget.filename->setCompleter(new QCompleter(fsm, widget.filename));
 #endif
     _q_printerChanged(currentPrinterIndex);
 
     QObject::connect(widget.printers, SIGNAL(currentIndexChanged(int)),
                      parent, SLOT(_q_printerChanged(int)));
     QObject::connect(widget.fileBrowser, SIGNAL(clicked()), parent, SLOT(_q_btnBrowseClicked()));
     QObject::connect(widget.properties, SIGNAL(clicked()), parent, SLOT(_q_btnPropertiesClicked()));
 
     // disable features that QPrinter does not yet support.
     widget.preview->setVisible(false);
 }

◆ ~QUnixPrintWidgetPrivate()

QUnixPrintWidgetPrivate::~QUnixPrintWidgetPrivate ( )

Definition at line 757 of file qprintdialog_unix.cpp.

 {
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     delete cups;
 #endif
 }

Functions

◆ _q_btnBrowseClicked()

void QUnixPrintWidgetPrivate::_q_btnBrowseClicked ( )

Definition at line 844 of file qprintdialog_unix.cpp.

Referenced by QUnixPrintWidgetPrivate().

 {
     QString filename = widget.filename->text();
 #ifndef QT_NO_FILEDIALOG
     filename = QFileDialog::getSaveFileName(parent, QPrintDialog::tr("Print To File ..."), filename,
                                             QString(), 0, QFileDialog::DontConfirmOverwrite);
 #else
     filename.clear();
 #endif
     if (!filename.isEmpty()) {
         widget.filename->setText(filename);
         if (filename.endsWith(QString::fromLatin1(".ps"), Qt::CaseInsensitive))
             widget.printers->setCurrentIndex(widget.printers->count() - 1); // the postscript one
         else if (filename.endsWith(QString::fromLatin1(".pdf"), Qt::CaseInsensitive))
             widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one
         else if (widget.printers->currentIndex() != widget.printers->count() - 1) // if ps is not selected, pdf is default
             widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one
     }
 }

◆ _q_btnPropertiesClicked()

void QUnixPrintWidgetPrivate::_q_btnPropertiesClicked ( )

Definition at line 951 of file qprintdialog_unix.cpp.

Referenced by QUnixPrintWidgetPrivate().

 {
     if (!propertiesDialog) {
         propertiesDialog = new QPrintPropertiesDialog(q);
         propertiesDialog->setResult(QDialog::Rejected);
     }
 
     if (propertiesDialog->result() == QDialog::Rejected) {
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
         propertiesDialog->setCups(cups);
 #endif
         propertiesDialog->applyPrinterProperties(q->printer());
 
         if (q->isOptionEnabled(QPrintDialog::PrintToFile)
             && (widget.printers->currentIndex() > widget.printers->count() - 3)) // PDF or postscript
             propertiesDialog->selectPdfPsPrinter(q->printer());
         else
             propertiesDialog->selectPrinter();
     }
     propertiesDialog->exec();
 }

◆ _q_printerChanged()

void QUnixPrintWidgetPrivate::_q_printerChanged ( int index )

Definition at line 764 of file qprintdialog_unix.cpp.

Referenced by QUnixPrintWidgetPrivate(), and setOptionsPane().

 {
     if (index < 0)
         return;
     const int printerCount = widget.printers->count();
     widget.filename->setEnabled(false);
     widget.lOutput->setEnabled(false);
 
     if (filePrintersAdded) {
         Q_ASSERT(index != printerCount - 3); // separator
         if (index > printerCount - 3) { // PDF or postscript
             bool pdfPrinter = (index == printerCount - 2);
             widget.location->setText(QPrintDialog::tr("Local file"));
             widget.type->setText(QPrintDialog::tr("Write %1 file").arg(pdfPrinter ? QString::fromLatin1("PDF")
                                                                        : QString::fromLatin1("PostScript")));
             widget.properties->setEnabled(true);
             widget.filename->setEnabled(true);
             QString filename = widget.filename->text();
             QString suffix = QFileInfo(filename).suffix();
             if (pdfPrinter && suffix == QLatin1String("ps"))
                 filename = filename.replace(QLatin1String(".ps"), QLatin1String(".pdf"));
             if (!pdfPrinter && suffix == QLatin1String("pdf"))
                 filename = filename.replace(QLatin1String(".pdf"), QLatin1String(".ps"));
             widget.filename->setText(filename);
             widget.lOutput->setEnabled(true);
             if (propertiesDialog)
                 propertiesDialog->selectPdfPsPrinter(printer);
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
             if (optionsPane)
                 optionsPane->selectPrinter(0);
 #endif
             return;
         }
     }
 
     widget.location->setText(QString());
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     if (QCUPSSupport::isAvailable()) {
         cups->setCurrentPrinter(index);
 
         const cups_option_t *opt = cups->printerOption(QString::fromLatin1("printer-location"));
         QString location;
         if (opt)
             location = QString::fromLocal8Bit(opt->value);
         widget.location->setText(location);
 
         cupsPPD = cups->currentPPD();
         // set printer type line
         QString type;
         if (cupsPPD)
             type = QString::fromLocal8Bit(cupsPPD->manufacturer) + QLatin1String(" - ") + QString::fromLocal8Bit(cupsPPD->modelname);
         widget.type->setText(type);
         if (propertiesDialog)
             propertiesDialog->selectPrinter();
         if (optionsPane)
             optionsPane->selectPrinter(cups);
     } else {
         if (optionsPane)
             optionsPane->selectPrinter(0);
 #endif
         if (lprPrinters.count() > 0) {
             QString type = lprPrinters.at(index).name + QLatin1Char('@') + lprPrinters.at(index).host;
             if (!lprPrinters.at(index).comment.isEmpty())
             type += QLatin1String(", ") + lprPrinters.at(index).comment;
             widget.type->setText(type);
             if (propertiesDialog)
                 propertiesDialog->selectPrinter();
         }
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     }
 #endif
 }

◆ applyPrinterProperties()

void QUnixPrintWidgetPrivate::applyPrinterProperties ( QPrinter * p )

copy printer properties to the widget

Definition at line 864 of file qprintdialog_unix.cpp.

 {
     if (p == 0)
         return;
     printer = p;
     if (p->outputFileName().isEmpty()) {
         QString home = QString::fromLocal8Bit(qgetenv("HOME").constData());
         QString cur = QDir::currentPath();
         if (home.at(home.length()-1) != QLatin1Char('/'))
             home += QLatin1Char('/');
         if (cur.at(cur.length()-1) != QLatin1Char('/'))
             cur += QLatin1Char('/');
         if (cur.left(home.length()) != home)
             cur = home;
 #ifdef Q_WS_X11
         if (p->docName().isEmpty()) {
             if (p->outputFormat() == QPrinter::PostScriptFormat)
                 cur += QLatin1String("print.ps");
             else
                 cur += QLatin1String("print.pdf");
         } else {
             QRegExp re(QString::fromLatin1("(.*)\\.\\S+"));
             if (re.exactMatch(p->docName()))
                 cur += re.cap(1);
             else
                 cur += p->docName();
             if (p->outputFormat() == QPrinter::PostScriptFormat)
                 cur += QLatin1String(".ps");
             else
                 cur += QLatin1String(".pdf");
         }
 #endif
         widget.filename->setText(cur);
     }
     else
         widget.filename->setText( p->outputFileName() );
     QString printer = p->printerName();
     if (!printer.isEmpty()) {
         for (int i = 0; i < widget.printers->count(); ++i) {
             if (widget.printers->itemText(i) == printer) {
                 widget.printers->setCurrentIndex(i);
                 break;
             }
         }
     }
     // PDF and PS printers are not added to the dialog yet, we'll handle those cases in QUnixPrintWidgetPrivate::updateWidget
 
     if (propertiesDialog)
         propertiesDialog->applyPrinterProperties(p);
 }

◆ checkFields()

bool QUnixPrintWidgetPrivate::checkFields ( )

Definition at line 916 of file qprintdialog_unix.cpp.

 {
     if (widget.filename->isEnabled()) {
         QString file = widget.filename->text();
         QFile f(file);
         QFileInfo fi(f);
         bool exists = fi.exists();
         bool opened = false;
         if (exists && fi.isDir()) {
             QMessageBox::warning(q, q->windowTitle(),
                             QPrintDialog::tr("%1 is a directory.\nPlease choose a different file name.").arg(file));
             return false;
         } else if ((exists && !fi.isWritable()) || !(opened = f.open(QFile::Append))) {
             QMessageBox::warning(q, q->windowTitle(),
                             QPrintDialog::tr("File %1 is not writable.\nPlease choose a different file name.").arg(file));
             return false;
         } else if (exists) {
             int ret = QMessageBox::question(q, q->windowTitle(),
                                             QPrintDialog::tr("%1 already exists.\nDo you want to overwrite it?").arg(file),
                                             QMessageBox::Yes|QMessageBox::No, QMessageBox::No);
             if (ret == QMessageBox::No)
                 return false;
         }
         if (opened) {
             f.close();
             if (!exists)
                 f.remove();
         }
     }
 
     // Every test passed. Accept the dialog.
     return true;
 }

◆ setCupsProperties()

void QUnixPrintWidgetPrivate::setCupsProperties ( )

Definition at line 974 of file qprintdialog_unix.cpp.

Referenced by setupPrinter().

 {
     if (cups && QCUPSSupport::isAvailable() && cups->pageSizes()) {
         QPrintEngine *engine = printer->printEngine();
         const ppd_option_t* pageSizes = cups->pageSizes();
         QByteArray cupsPageSize;
         for (int i = 0; i < pageSizes->num_choices; ++i) {
             if (static_cast<int>(pageSizes->choices[i].marked) == 1)
                 cupsPageSize = pageSizes->choices[i].choice;
         }
         engine->setProperty(PPK_CupsStringPageSize, QString::fromLatin1(cupsPageSize));
         engine->setProperty(PPK_CupsOptions, cups->options());
 
         QRect pageRect = cups->pageRect(cupsPageSize);
         engine->setProperty(PPK_CupsPageRect, pageRect);
 
         QRect paperRect = cups->paperRect(cupsPageSize);
         engine->setProperty(PPK_CupsPaperRect, paperRect);
 
         for (int ps = 0; ps < QPrinter::NPaperSize; ++ps) {
             QPdf::PaperSize size = QPdf::paperSize(QPrinter::PaperSize(ps));
             if (size.width == paperRect.width() && size.height == paperRect.height())
                 printer->setPaperSize(static_cast<QPrinter::PaperSize>(ps));
         }
     }
 }

◆ setOptionsPane()

void QUnixPrintWidgetPrivate::setOptionsPane ( QPrintDialogPrivate * pane )

Definition at line 837 of file qprintdialog_unix.cpp.

 {
     optionsPane = pane;
     if (optionsPane)
         _q_printerChanged(widget.printers->currentIndex());
 }

◆ setupPrinter()

void QUnixPrintWidgetPrivate::setupPrinter ( )

Definition at line 1002 of file qprintdialog_unix.cpp.

 {
     const int printerCount = widget.printers->count();
     const int index = widget.printers->currentIndex();
 
     if (filePrintersAdded && index > printerCount - 3) { // PDF or postscript
         printer->setPrinterName(QString());
         Q_ASSERT(index != printerCount - 3); // separator
         if (index == printerCount - 2)
             printer->setOutputFormat(QPrinter::PdfFormat);
         else
             printer->setOutputFormat(QPrinter::PostScriptFormat);
         QString path = widget.filename->text();
         if (QDir::isRelativePath(path))
             path = QDir::homePath() + QDir::separator() + path;
         printer->setOutputFileName(path);
     }
     else {
         printer->setPrinterName(widget.printers->currentText());
         printer->setOutputFileName(QString());
     }
 
     if (propertiesDialog && propertiesDialog->result() == QDialog::Accepted)
         propertiesDialog->setupPrinter();
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
     if (!propertiesDialog)
         setCupsProperties();
 #endif
 }

◆ updateWidget()

void QUnixPrintWidgetPrivate::updateWidget ( )

Definition at line 722 of file qprintdialog_unix.cpp.

 {
     const bool printToFile = q == 0 || q->isOptionEnabled(QPrintDialog::PrintToFile);
     if (printToFile && !filePrintersAdded) {
         if (widget.printers->count())
             widget.printers->insertSeparator(widget.printers->count());
         widget.printers->addItem(QPrintDialog::tr("Print to File (PDF)"));
         widget.printers->addItem(QPrintDialog::tr("Print to File (Postscript)"));
         filePrintersAdded = true;
     }
     if (!printToFile && filePrintersAdded) {
         widget.printers->removeItem(widget.printers->count()-1);
         widget.printers->removeItem(widget.printers->count()-1);
         if (widget.printers->count())
             widget.printers->removeItem(widget.printers->count()-1); // remove separator
         filePrintersAdded = false;
     }
     if (printer && filePrintersAdded && (printer->outputFormat() != QPrinter::NativeFormat
                                          || printer->printerName().isEmpty()))
     {
         if (printer->outputFormat() == QPrinter::PdfFormat)
             widget.printers->setCurrentIndex(widget.printers->count() - 2);
         else if (printer->outputFormat() == QPrinter::PostScriptFormat)
             widget.printers->setCurrentIndex(widget.printers->count() - 1);
         widget.filename->setEnabled(true);
         widget.lOutput->setEnabled(true);
     }
 
     widget.filename->setVisible(printToFile);
     widget.lOutput->setVisible(printToFile);
     widget.fileBrowser->setVisible(printToFile);
 
     widget.properties->setVisible(q->isOptionEnabled(QAbstractPrintDialog::PrintShowPageSize));
 }