qprintdialog_unix.cpp

奇趣公司比较新的qt/emd版本

                QRegExp rx(QLatin1String("^(\\S+)"));
                if (rx.indexIn(QString::fromLatin1(etcLpDefault)) != -1)
                    etcLpDefault = rx.cap(1).toAscii();
            }
        }
    }

    char *def = 0;
    f.setFile(QLatin1String("/etc/nsswitch.conf"));
    if (f.isFile()) {
        def = parseNsswitchConf(&printers);
    } else {
        f.setFile(QLatin1String("/etc/printers.conf"));
        if (f.isFile())
            def = parsePrintersConf(&printers);
    }

    if (def) {
        etcLpDefault = def;
        delete [] def;
    }

    // all printers hopefully known.  try to find a good default
    QString dollarPrinter;
    {
        dollarPrinter = QString::fromLocal8Bit(qgetenv("PRINTER"));
        if (dollarPrinter.isEmpty())
            dollarPrinter = QString::fromLocal8Bit(qgetenv("LPDEST"));
        if (dollarPrinter.isEmpty())
            dollarPrinter = QString::fromLocal8Bit(qgetenv("NPRINTER"));
        if (dollarPrinter.isEmpty())
            dollarPrinter = QString::fromLocal8Bit(qgetenv("NGPRINTER"));
        if (!dollarPrinter.isEmpty())
            perhapsAddPrinter(&printers, dollarPrinter,
                              QPrintDialog::tr("unknown"),
                              QLatin1String(""));
    }

    int quality = 0;
    int best = 0;
    for (int i = 0; i < printers.size(); ++i) {
        QRegExp ps(QLatin1String("[^a-z]ps(?:[^a-z]|$)"));
        QRegExp lp(QLatin1String("[^a-z]lp(?:[^a-z]|$)"));

        QString name = printers.at(i).name;
        QString comment = printers.at(i).comment;
        if (quality < 4 && name == dollarPrinter) {
            best = i;
            quality = 4;
        } else if (quality < 3 && !etcLpDefault.isEmpty() &&
                    name == QLatin1String(etcLpDefault)) {
            best = i;
            quality = 3;
        } else if (quality < 2 &&
                    (name == QLatin1String("ps") ||
                     ps.indexIn(comment) != -1)) {
            best = i;
            quality = 2;
        } else if (quality < 1 &&
                    (name == QLatin1String("lp") ||
                     lp.indexIn(comment) > -1)) {
            best = i;
            quality = 1;
        }
    }

    return best;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

QPrintDialogPrivate::QPrintDialogPrivate()
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    : cups(0), cupsPrinterCount(0), cupsPrinters(0), cupsPPD(0)
#endif
{}

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

void QPrintDialogPrivate::init()
{
    Q_Q(QPrintDialog);
    QPrinter* p = q->printer();

    ui.setupUi(q);
    ui.stackedWidget->setCurrentIndex(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) {
            ui.cbPrinters->addItem(QString::fromLocal8Bit(cupsPrinters[i].name));
            if (cupsPrinters[i].is_default)
                ui.cbPrinters->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()) {
            ui.btnProperties->setEnabled(true);
        }
        _q_printerChanged(cups->currentPrinterIndex());
    } else {
#endif
        int defprn = getLprPrinters(lprPrinters);
        // populating printer combo
        QList<QPrinterDescription>::const_iterator i = lprPrinters.constBegin();
        for(; i != lprPrinters.constEnd(); ++i) {
            ui.cbPrinters->addItem((*i).name);
        }
        ui.cbPrinters->setCurrentIndex(defprn);
        _q_printerChanged(defprn);
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    }
#endif
    if (!ui.cbPrinters->count())
        ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);

    ui.cbPaperLayout->addItem(QPrintDialog::tr("Portrait"), QPrinter::Portrait);
    ui.cbPaperLayout->addItem(QPrintDialog::tr("Landscape"), QPrinter::Landscape);

    QPushButton *printButton = ui.buttonBox->button(QDialogButtonBox::Ok);
    printButton->setText(QPrintDialog::tr("Print"));
    printButton->setDefault(true);

    applyPrinterProperties(p);

    QObject::connect(ui.buttonBox, SIGNAL(accepted()), q, SLOT(accept()));
    QObject::connect(ui.buttonBox, SIGNAL(rejected()), q, SLOT(reject()));

    QObject::connect(ui.chbPrintToFile, SIGNAL(stateChanged(int)),
                     q, SLOT(_q_printToFileChanged(int)));

    QObject::connect(ui.rbPrintRange, SIGNAL(toggled(bool)),
                     q, SLOT(_q_rbPrintRangeToggled(bool)));
    QObject::connect(ui.cbPrinters, SIGNAL(currentIndexChanged(int)),
                     q, SLOT(_q_printerChanged(int)));
    QObject::connect(ui.chbPrintLastFirst, SIGNAL(toggled(bool)),
                     q, SLOT(_q_chbPrintLastFirstToggled(bool)));

#ifndef QT_NO_FILEDIALOG
    QObject::connect(ui.btnBrowse, SIGNAL(clicked()), q, SLOT(_q_btnBrowseClicked()));
#endif
    QObject::connect(ui.btnProperties, SIGNAL(clicked()), q, SLOT(_q_btnPropertiesClicked()));
}


void QPrintDialogPrivate::applyPrinterProperties(QPrinter *p)
{
    if (p->orientation() == QPrinter::Portrait)
        ui.cbPaperLayout->setCurrentIndex(0);
    else
        ui.cbPaperLayout->setCurrentIndex(1);

    ui.sbNumCopies->setValue(p->numCopies());

    if (p->collateCopies())
        ui.chbCollate->setChecked(true);
    else
        ui.chbCollate->setChecked(false);

    if (p->pageOrder() == QPrinter::LastPageFirst)
        ui.chbPrintLastFirst->setChecked(true);
    else
        ui.chbPrintLastFirst->setChecked(false);

    if (p->colorMode() == QPrinter::Color)
        ui.chbColor->setChecked(true);
    else
        ui.chbColor->setChecked(false);

    ui.chbDuplex->setChecked(p->doubleSidedPrinting());

    QString file = p->outputFileName();
    if (!file.isEmpty()) {
        ui.chbPrintToFile->setChecked(true);
        ui.stackedWidget->setCurrentIndex(1);
        ui.gbDestination->setTitle(QApplication::translate("QPrintDialog","File"));
        ui.leFile->setText(file);
    }
    QString printer = p->printerName();
    if (!printer.isEmpty()) {
        for (int i = 0; i < ui.cbPrinters->count(); ++i) {
            if (ui.cbPrinters->itemText(i) == printer) {
                ui.cbPrinters->setCurrentIndex(i);
                break;
            }
        }
    }
}

void QPrintDialogPrivate::_q_printToFileChanged(int state)
{
    Q_Q(QPrintDialog);
    if (state == Qt::Checked) {
        ui.stackedWidget->setCurrentIndex(1);
        ui.gbDestination->setTitle(QPrintDialog::tr("File"));
        QString fileName = q->printer()->outputFileName();
        if (fileName.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
            cur += QLatin1String("print.pdf");
#endif
            ui.leFile->setText(cur);
        } else {
            ui.leFile->setText(fileName);
        }

        ui.leFile->setCursorPosition(ui.leFile->text().length());
        ui.leFile->selectAll();
        ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);

    } else {
        ui.stackedWidget->setCurrentIndex(0);
        ui.gbDestination->setTitle(QPrintDialog::tr("Printer"));
        if (!ui.cbPrinters->count())
            ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
    }
    refreshPageSizes();
}

void QPrintDialogPrivate::_q_rbPrintRangeToggled(bool checked)
{
    if (checked) {
        ui.sbFrom->setEnabled(true);
        ui.sbTo->setEnabled(true);
    } else {
        ui.sbFrom->setEnabled(false);
        ui.sbTo->setEnabled(false);
    }
}

void QPrintDialogPrivate::_q_printerChanged(int index)
{
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    if (QCUPSSupport::isAvailable()) {
        cups->setCurrentPrinter(index);
        cupsPPD = cups->currentPPD();
        //only enable properties if ppd is valid
        ui.btnProperties->setEnabled(cupsPPD != 0);
        // set printer info line
        QString info;
        if (cupsPPD)
            info = QString::fromLocal8Bit(cupsPPD->manufacturer) + QLatin1String(" - ") + QString::fromLocal8Bit(cupsPPD->modelname);
        ui.lbPrinterInfo->setText(info);
    } else {
#endif
        if (lprPrinters.count() > 0) {
            QString info = lprPrinters.at(index).name + QLatin1String("@") + lprPrinters.at(index).host;
            if (!lprPrinters.at(index).comment.isEmpty())
            info += QLatin1String(", ") + lprPrinters.at(index).comment;
            ui.lbPrinterInfo->setText(info);
        }
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    }
#endif

    refreshPageSizes();
}

void QPrintDialogPrivate::_q_chbPrintLastFirstToggled(bool checked)
{
    Q_Q(QPrintDialog);
    if (checked)
        q->printer()->setPageOrder(QPrinter::LastPageFirst);
    else
        q->printer()->setPageOrder(QPrinter::FirstPageFirst);
}

void QPrintDialogPrivate::refreshPageSizes()
{
    ui.cbPaperSize->blockSignals(true);
    ui.cbPaperSize->clear();

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    if (QCUPSSupport::isAvailable() && ui.chbPrintToFile->checkState() !=  Qt::Checked) {
        const ppd_option_t* pageSizes = cups->pageSizes();
        int numChoices = pageSizes ? pageSizes->num_choices : 0;

        for (int i = 0; i < numChoices; ++i) {
            ui.cbPaperSize->addItem(QString::fromLocal8Bit(pageSizes->choices[i].text), QByteArray(pageSizes->choices[i].choice));
            if (static_cast<int>(pageSizes->choices[i].marked) == 1)
                ui.cbPaperSize->setCurrentIndex(i);
        }
    } else {
#endif
        Q_Q(QPrintDialog);
        populatePaperSizes(ui.cbPaperSize);
        ui.cbPaperSize->setCurrentIndex(ui.cbPaperSize->findData(q->printer()->pageSize()));
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    }
#endif

    ui.cbPaperSize->blockSignals(false);
}

#ifndef QT_NO_FILEDIALOG
void QPrintDialogPrivate::_q_btnBrowseClicked()
{
    Q_Q(QPrintDialog);
    QString fileName = QFileDialog::getSaveFileName(q, QPrintDialog::tr("Print To File ..."),
                                                    ui.leFile->text());
    if (!fileName.isNull())
        ui.leFile->setText(fileName);
}
#endif

void QPrintDialogPrivate::_q_btnPropertiesClicked()
{
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    PPDOptionsModel model(cups);
    PPDPropertiesDialog dialog(&model);
    dialog.exec();

    const ppd_option_t* pageSizes = cups->pageSizes();
    int numChoices = pageSizes ? pageSizes->num_choices : 0;
    for (int i = 0; i < numChoices; ++i) {
        if (static_cast<int>(pageSizes->choices[i].marked) == 1)
            ui.cbPaperSize->setCurrentIndex(i);
    }
#endif
}

bool QPrintDialogPrivate::setupPrinter()
{
    Q_Q(QPrintDialog);
    QPrinter* p = q->printer();

    // printer or file name
    if (ui.chbPrintToFile->isChecked()) {
        QString file = ui.leFile->text();
#ifndef QT_NO_MESSAGEBOX
        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();
        }
#endif
        p->setOutputFileName(file);
    } else {
        p->setPrinterName(ui.cbPrinters->currentText());
        p->setOutputFileName(QString());
    }

    // print range
    if (ui.rbPrintAll->isChecked()) {
        p->setPrintRange(QPrinter::AllPages);
        p->setFromTo(0,0);
    } else if (ui.rbPrintSelection->isChecked()) {
        p->setPrintRange(QPrinter::Selection);
        p->setFromTo(0,0);
    } else if (ui.rbPrintRange->isChecked()) {
        p->setPrintRange(QPrinter::PageRange);
        p->setFromTo(ui.sbFrom->value(), ui.sbTo->value());
    }

    // copies
    p->setNumCopies(ui.sbNumCopies->value());
    p->setCollateCopies(ui.chbCollate->isChecked());
    p->setDoubleSidedPrinting(ui.chbDuplex->isChecked());

    // paper format
    QVariant val = ui.cbPaperSize->itemData(ui.cbPaperSize->currentIndex());
    int ps = p->pageSize();
    if (val.type() == QVariant::Int) {
        ps = val.toInt();
    }
#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
    else if (QCUPSSupport::isAvailable() && ui.chbPrintToFile->checkState() !=  Qt::Checked
             && cups->currentPPD()) {
        QByteArray cupsPageSize = val.toByteArray();
        QPrintEngine *engine = p->printEngine();
        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(ps = 0; ps < QPrinter::NPageSize; ++ps) {
            QPdf::PaperSize size = QPdf::paperSize(QPrinter::PageSize(ps));
            if (size.width == paperRect.width() && size.height == paperRect.height())
                break;
        }
    }
#endif