/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qplatformdefs.h"

#ifndef QT_NO_PRINTDIALOG

#include "private/qabstractprintdialog_p.h"

#include <QtGui/qmessagebox.h>

#include "qprintdialog.h"

#include "qfiledialog.h"

#include <QtCore/qdir.h>

#include <QtGui/qevent.h>

#include <QtGui/qfilesystemmodel.h>

#include <QtGui/qstyleditemdelegate.h>

#include <QtGui/qprinter.h>

#include <QtGui/qdialogbuttonbox.h>

#include "qfscompleter_p.h"

#include "ui_qprintpropertieswidget.h"

#include "ui_qprintsettingsoutput.h"

#include "ui_qprintwidget.h"

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

#  include <private/qcups_p.h>

#  include <cups/cups.h>

#  include <private/qpdf_p.h>

#else

#  include <QtCore/qlibrary.h>

#endif

#include <private/qprinterinfo_unix_p.h>

QT_BEGIN_NAMESPACE

extern int qt_printerRealNumCopies(QPaintEngine *);

class QOptionTreeItem;

class QPPDOptionsModel;

class QPrintPropertiesDialog : public QDialog

{

    Q_OBJECT

public:

    QPrintPropertiesDialog(QAbstractPrintDialog *parent = 0);

    ~QPrintPropertiesDialog();

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    void setCups(QCUPSSupport *cups) { m_cups = cups; }

    void addItemToOptions(QOptionTreeItem *parent, QList<const ppd_option_t*>& options, QList<const char*>& markedOptions) const;

#endif

    void selectPrinter();

    void selectPdfPsPrinter(const QPrinter *p);

    /// copy printer properties to the widget

    void applyPrinterProperties(QPrinter *p);

    void setupPrinter() const;

protected:

    void showEvent(QShowEvent* event);

private:

    Ui::QPrintPropertiesWidget widget;

    QDialogButtonBox *m_buttons;

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    QCUPSSupport *m_cups;

    QPPDOptionsModel *m_cupsOptionsModel;

#endif

};

class QPrintDialogPrivate : public QAbstractPrintDialogPrivate

{

    Q_DECLARE_PUBLIC(QPrintDialog)

    Q_DECLARE_TR_FUNCTIONS(QPrintDialog)

public:

    QPrintDialogPrivate();

    ~QPrintDialogPrivate();

    void init();

    /// copy printer properties to the widget

    void applyPrinterProperties(QPrinter *p);

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    void selectPrinter(QCUPSSupport *cups);

#endif

    void _q_chbPrintLastFirstToggled(bool);

#ifndef QT_NO_MESSAGEBOX

    void _q_checkFields();

#endif

    void _q_collapseOrExpandDialog();

    void setupPrinter();

    void updateWidgets();

    virtual void setTabs(const QList<QWidget*> &tabs);

    Ui::QPrintSettingsOutput options;

    QUnixPrintWidget *top;

    QWidget *bottom;

    QDialogButtonBox *buttons;

    QPushButton *collapseButton;

};

#if defined (Q_OS_UNIX)

class QUnixPrintWidgetPrivate

{

public:

    QUnixPrintWidgetPrivate(QUnixPrintWidget *q);

    ~QUnixPrintWidgetPrivate();

    /// copy printer properties to the widget

    void applyPrinterProperties(QPrinter *p);

    bool checkFields();

    void setupPrinter();

    void setOptionsPane(QPrintDialogPrivate *pane);

// slots

    void _q_printerChanged(int index);

    void _q_btnPropertiesClicked();

    void _q_btnBrowseClicked();

    QUnixPrintWidget * const parent;

    QPrintPropertiesDialog *propertiesDialog;

    Ui::QPrintWidget widget;

    QAbstractPrintDialog * q;

    QPrinter *printer;

    QList<QPrinterDescription> lprPrinters;

    void updateWidget();

private:

    QPrintDialogPrivate *optionsPane;

    bool filePrintersAdded;

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    QCUPSSupport* cups;

    int cupsPrinterCount;

    const cups_dest_t* cupsPrinters;

    const ppd_file_t* cupsPPD;

#endif

};

#endif

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

class QOptionTreeItem

{

public:

    enum ItemType { Root, Group, Option, Choice };

    QOptionTreeItem(ItemType t, int i, const void* p, const char* desc, QOptionTreeItem* pi)

        : type(t),

          index(i),

          ptr(p),

          description(desc),

          selected(-1),

          selDescription(0),

          parentItem(pi) {}

    ~QOptionTreeItem() {

        while (!childItems.isEmpty())

            delete childItems.takeFirst();

    }

    ItemType type;

    int index;

    const void* ptr;

    const char* description;

    int selected;

    const char* selDescription;

    QOptionTreeItem* parentItem;

    QList<QOptionTreeItem*> childItems;

};

class QPPDOptionsModel : public QAbstractItemModel

{

    friend class QPPDOptionsEditor;

public:

    QPPDOptionsModel(QCUPSSupport *cups, QObject *parent = 0);

    ~QPPDOptionsModel();

    int columnCount(const QModelIndex& parent = QModelIndex()) const;

    int rowCount(const QModelIndex& parent = QModelIndex()) const;

    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const;

    QModelIndex parent(const QModelIndex& index) const;

    Qt::ItemFlags flags(const QModelIndex& index) const;

    QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;

    QOptionTreeItem* rootItem;

    QCUPSSupport *cups;

    const ppd_file_t* ppd;

    void parseItems();

    void parseGroups(QOptionTreeItem* parent);

    void parseOptions(QOptionTreeItem* parent);

    void parseChoices(QOptionTreeItem* parent);

};

class QPPDOptionsEditor : public QStyledItemDelegate

{

    Q_OBJECT

public:

    QPPDOptionsEditor(QObject* parent = 0) : QStyledItemDelegate(parent) {}

    ~QPPDOptionsEditor() {}

    QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;

    void setEditorData(QWidget* editor, const QModelIndex& index) const;

    void setModelData( QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;

private slots:

    void cbChanged(int index);

};

#endif

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

QPrintPropertiesDialog::QPrintPropertiesDialog(QAbstractPrintDialog *parent)

    : QDialog(parent)

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    , m_cups(0), m_cupsOptionsModel(0)

#endif

{

    QVBoxLayout *lay = new QVBoxLayout(this);

    this->setLayout(lay);

    QWidget *content = new QWidget(this);

    widget.setupUi(content);

    m_buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);

    lay->addWidget(content);

    lay->addWidget(m_buttons);

    connect(m_buttons->button(QDialogButtonBox::Ok), SIGNAL(clicked()), this, SLOT(accept()));

    connect(m_buttons->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), this, SLOT(reject()));

}

QPrintPropertiesDialog::~QPrintPropertiesDialog()

{

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    delete m_cupsOptionsModel;

#else

    delete widget.cupsPropertiesPage;

#endif

}

void QPrintPropertiesDialog::applyPrinterProperties(QPrinter *p)

{

    widget.pageSetup->setPrinter(p);

}

void QPrintPropertiesDialog::setupPrinter() const

{

    widget.pageSetup->setupPrinter();

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    QPPDOptionsModel* model = static_cast<QPPDOptionsModel*>(widget.treeView->model());

    if (model) {

        QOptionTreeItem* rootItem = model->rootItem;

        QList<const ppd_option_t*> options;

        QList<const char*> markedOptions;

        addItemToOptions(rootItem, options, markedOptions);

        model->cups->saveOptions(options, markedOptions);

    }

#endif

}

void QPrintPropertiesDialog::selectPrinter()

{

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

    widget.pageSetup->selectPrinter(m_cups);

    widget.treeView->setModel(0);

    if (m_cups && QCUPSSupport::isAvailable()) {

        if (m_cupsOptionsModel == 0) {

            m_cupsOptionsModel = new QPPDOptionsModel(m_cups);

            widget.treeView->setItemDelegate(new QPPDOptionsEditor(this));

        } else {

            // update the model

            m_cupsOptionsModel->parseItems();

        }

        if (m_cupsOptionsModel->rowCount() > 0) {

            widget.treeView->setModel(m_cupsOptionsModel);

            for (int i = 0; i < m_cupsOptionsModel->rowCount(); ++i)

                widget.treeView->expand(m_cupsOptionsModel->index(i,0));

            widget.tabs->setTabEnabled(1, true); // enable the advanced tab

        } else {

            widget.tabs->setTabEnabled(1, false);

        }

    } else

#endif

    {

        widget.cupsPropertiesPage->setEnabled(false);

        widget.pageSetup->selectPrinter(0);

    }

}

void QPrintPropertiesDialog::selectPdfPsPrinter(const QPrinter *p)

{

    widget.treeView->setModel(0);

    widget.pageSetup->selectPdfPsPrinter(p);

    widget.tabs->setTabEnabled(1, false); // disable the advanced tab

}

void QPrintPropertiesDialog::showEvent(QShowEvent* event)

{

    widget.treeView->resizeColumnToContents(0);

    event->accept();

}

#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)

void QPrintPropertiesDialog::addItemToOptions(QOptionTreeItem *parent, QList<const ppd_option_t*>& options, QList<const char*>& markedOptions) const

{

    for (int i = 0; i < parent->childItems.count(); ++i) {

        QOptionTreeItem *itm = parent->childItems.at(i);

        if (itm->type == QOptionTreeItem::Option) {

            const ppd_option_t* opt = reinterpret_cast<const ppd_option_t*>(itm->ptr);

            options << opt;

            if (qstrcmp(opt->defchoice, opt->choices[itm->selected].choice) != 0) {

                markedOptions << opt->keyword << opt->choices[itm->selected].choice;

            }

        } else {

            addItemToOptions(itm, options, markedOptions);

        }

    }

}

#endif

QPrintDialogPrivate::QPrintDialogPrivate()

    : top(0), bottom(0), buttons(0), collapseButton(0)

{

}

QPrintDialogPrivate::~QPrintDialogPrivate()

{

}

void QPrintDialogPrivate::init()

{

    Q_Q(QPrintDialog);

    top = new QUnixPrintWidget(0, q);

    bottom = new QWidget(q);

    options.setupUi(bottom);

    options.color->setIconSize(QSize(32, 32));

    options.color->setIcon(QIcon(QLatin1String(":/trolltech/dialogs/qprintdialog/images/status-color.png")));

    options.grayscale->setIconSize(QSize(32, 32));

    options.grayscale->setIcon(QIcon(QLatin1String(":/trolltech/dialogs/qprintdialog/images/status-gray-scale.png")));

    top->d->setOptionsPane(this);

    buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, q);

    collapseButton = new QPushButton(QPrintDialog::tr("&Options >>"), buttons);

    buttons->addButton(collapseButton, QDialogButtonBox::ResetRole);

    bottom->setVisible(false);

    QPushButton *printButton = buttons->button(QDialogButtonBox::Ok);

    printButton->setText(QPrintDialog::tr("&Print"));

    printButton->setDefault(true);

    QVBoxLayout *lay = new QVBoxLayout(q);

    q->setLayout(lay);

    lay->addWidget(top);

    lay->addWidget(bottom);

    lay->addWidget(buttons);

    QPrinter* p = q->printer();

    applyPrinterProperties(p);

#ifdef QT_NO_MESSAGEBOX

    QObject::connect(buttons, SIGNAL(accepted()), q, SLOT(accept()));

#else

    QObject::connect(buttons, SIGNAL(accepted()), q, SLOT(_q_checkFields()));

#endif

    QObject::connect(buttons, SIGNAL(rejected()), q, SLOT(reject()));

    QObject::connect(options.reverse, SIGNAL(toggled(bool)),

                     q, SLOT(_q_chbPrintLastFirstToggled(bool)));

    QObject::connect(collapseButton, SIGNAL(released()), q, SLOT(_q_collapseOrExpandDialog()));

}

void QPrintDialogPrivate::applyPrinterProperties(QPrinter *p)

{

    if (p->colorMode() == QPrinter::Color)

        options.color->setChecked(true);

    else

        options.grayscale->setChecked(true);

    switch(p->duplex()) {

    case QPrinter::DuplexNone:

        options.noDuplex->setChecked(true); break;

    case QPrinter::DuplexLongSide:

    case QPrinter::DuplexAuto:

        options.duplexLong->setChecked(true); break;

    case QPrinter::DuplexShortSide:

        options.duplexShort->setChecked(true); break;

    }

    options.copies->setValue(qt_printerRealNumCopies(p->paintEngine()));

    options.collate->setChecked(p->collateCopies());

    options.reverse->setChecked(p->pageOrder() == QPrinter::LastPageFirst);

    top->d->applyPrinterProperties(p);

}

void QPrintDialogPrivate::_q_chbPrintLastFirstToggled(bool checked)

{

    Q_Q(QPrintDialog);

    if (checked)

        q->printer()->setPageOrder(QPrinter::LastPageFirst);

    else

        q->printer()->setPageOrder(QPrinter::FirstPageFirst);

}

void QPrintDialogPrivate::_q_collapseOrExpandDialog()

{

    int collapseHeight = 0;

    Q_Q(QPrintDialog);

    QWidget *widgetToHide = bottom;

    if (widgetToHide->isVisible()) {

        collapseButton->setText(QPrintDialog::tr("&Options >>"));

        collapseHeight = widgetToHide->y() + widgetToHide->height() - (top->y() + top->height());

    }

    else

        collapseButton->setText(QPrintDialog::tr("&Options <<"));

    widgetToHide->setVisible(! widgetToHide->isVisible());

    if (! widgetToHide->isVisible()) { // make it shrink

        q->layout()->activate();

        q->resize( QSize(q->width(), q->height() - collapseHeight) );

    }

}

#ifndef QT_NO_MESSAGEBOX

void QPrintDialogPrivate::_q_checkFields()

{

    Q_Q(QPrintDialog);

    if (top->d->checkFields())

        q->accept();

}

#endif // QT_NO_MESSAGEBOX

void QPrintDialogPrivate::setupPrinter()

{

    Q_Q(QPrintDialog);

    QPrinter* p = q->printer();

    if (options.duplex->isEnabled()) {

        if (options.noDuplex->isChecked())

            p->setDuplex(QPrinter::DuplexNone);

        else if (options.duplexLong->isChecked())

            p->setDuplex(QPrinter::DuplexLongSide);

        else

            p->setDuplex(QPrinter::DuplexShortSide);

    }

    p->setColorMode( options.color->isChecked() ? QPrinter::Color : QPrinter::GrayScale );

    // print range

    if (options.printAll->isChecked()) {

        p->setPrintRange(QPrinter::AllPages);

        p->setFromTo(0,0);

    } else if (options.printSelection->isChecked()) {

        p->setPrintRange(QPrinter::Selection);

        p->setFromTo(0,0);

    } else if (options.printRange->isChecked()) {

        p->setPrintRange(QPrinter::PageRange);

        p->setFromTo(options.from->value(), qMax(options.from->value(), options.to->value()));

    }

    // copies

    p->setNumCopies(options.copies->value());

    p->setCollateCopies(options.collate->isChecked());

    top->d->setupPrinter();

}

void QPrintDialogPrivate::updateWidgets()

{

    Q_Q(QPrintDialog);

    options.gbPrintRange->setVisible(q->isOptionEnabled(QPrintDialog::PrintPageRange) ||

                                q->isOptionEnabled(QPrintDialog::PrintSelection));

    options.printRange->setEnabled(q->isOptionEnabled(QPrintDialog::PrintPageRange));

    options.printSelection->setVisible(q->isOptionEnabled(QPrintDialog::PrintSelection));

    options.collate->setVisible(q->isOptionEnabled(QPrintDialog::PrintCollateCopies));