qprintdialog_unix.cpp

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

    p->setPageSize(static_cast<QPrinter::PageSize>(ps));
    p->setOrientation(static_cast<QPrinter::Orientation>(ui.cbPaperLayout->itemData(ui.cbPaperLayout->currentIndex()).toInt()));

    // other
    if (ui.chbColor->isChecked())
        p->setColorMode(QPrinter::Color);
    else
        p->setColorMode(QPrinter::GrayScale);

    return true;
}

void QPrintDialogPrivate::updateWidgets()
{
    Q_Q(QPrintDialog);
    ui.gbPrintRange->setEnabled(q->isOptionEnabled(QPrintDialog::PrintPageRange) ||
                                q->isOptionEnabled(QPrintDialog::PrintSelection));

    ui.rbPrintRange->setEnabled(q->isOptionEnabled(QPrintDialog::PrintPageRange));
    ui.rbPrintSelection->setEnabled(q->isOptionEnabled(QPrintDialog::PrintSelection));
    ui.chbPrintToFile->setEnabled(q->isOptionEnabled(QPrintDialog::PrintToFile));
    ui.chbCollate->setEnabled(q->isOptionEnabled(QPrintDialog::PrintCollateCopies));

    switch (q->printRange()) {
    case QPrintDialog::AllPages:
        ui.gbPrintRange->setChecked(true);
        break;
    case QPrintDialog::Selection:
        ui.rbPrintSelection->setChecked(true);
        break;
    case QPrintDialog::PageRange:
        ui.rbPrintRange->setChecked(true);
        break;
    default:
        break;
    }

    ui.sbFrom->setMinimum(q->minPage());
    ui.sbTo->setMinimum(q->minPage());
    ui.sbFrom->setMaximum(q->maxPage());
    ui.sbTo->setMaximum(q->maxPage());

    ui.sbFrom->setValue(q->fromPage());
    ui.sbTo->setValue(q->toPage());
}

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

QPrintDialog::QPrintDialog(QPrinter *printer, QWidget *parent) : QAbstractPrintDialog(*(new QPrintDialogPrivate), printer, parent)
{
    Q_D(QPrintDialog);
    d->init();
}

QPrintDialog::~QPrintDialog()
{}

int QPrintDialog::exec()
{
    Q_D(QPrintDialog);

    d->updateWidgets();

  redo:
    int status = QDialog::exec();
    if (status == QDialog::Accepted)
        if (!d->setupPrinter())
            goto redo;
    return status;
}


#ifdef QT3_SUPPORT
QPrinter *QPrintDialog::printer() const
{
    Q_D(const QPrintDialog);
    return d->printer;
}

void QPrintDialog::setPrinter(QPrinter *printer, bool pickupSettings)
{
    if (!printer)
        return;

    Q_D(QPrintDialog);
    d->printer = printer;

    if (pickupSettings)
        d->applyPrinterProperties(printer);
}

void QPrintDialog::addButton(QPushButton *button)
{
    Q_D(QPrintDialog);
    d->ui.buttonBox->addButton(button, QDialogButtonBox::HelpRole);
}
#endif // QT3_SUPPORT

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

class OptionTreeItem
{
public:
    enum ItemType { Root, Group, Option, Choice };

    OptionTreeItem(ItemType t, int i, const void* p, const char* desc, OptionTreeItem* pi)
        : type(t),
          index(i),
          ptr(p),
          description(desc),
          selected(-1),
          selDescription(0),
          parentItem(pi) {};

    ~OptionTreeItem() {
        while (!childItems.isEmpty())
            delete childItems.takeFirst();
    };

    ItemType type;
    int index;
    const void* ptr;
    const char* description;
    int selected;
    const char* selDescription;
    OptionTreeItem* parentItem;
    QList<OptionTreeItem*> childItems;
};

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

PPDPropertiesDialog::PPDPropertiesDialog(PPDOptionsModel* model, QWidget* parent, Qt::WindowFlags f) : QDialog(parent, f)
{
    setupUi(this);
    treeView->setItemDelegate(new PPDOptionsEditor(this));
    treeView->setModel(model);

    for (int i = 0; i < model->rowCount(); ++i) {
        treeView->expand(model->index(i,0));
    }

    connect(btnSave, SIGNAL(clicked()), this, SLOT(btnSaveClicked()));
}

PPDPropertiesDialog::~PPDPropertiesDialog()
{}

void PPDPropertiesDialog::showEvent(QShowEvent* event)
{
    treeView->resizeColumnToContents(0);
    event->accept();
}

void PPDPropertiesDialog::btnSaveClicked()
{
    PPDOptionsModel* model = static_cast<PPDOptionsModel*>(treeView->model());
    OptionTreeItem* rootItem = model->rootItem;
    QList<const ppd_option_t*> options;
    QList<const char*> markedOptions;

    addItemToOptions(rootItem, options, markedOptions);
    model->cups->saveOptions(options, markedOptions);
}

void PPDPropertiesDialog::addItemToOptions(OptionTreeItem *parent, QList<const ppd_option_t*>& options, QList<const char*>& markedOptions)
{
    for (int i = 0; i < parent->childItems.count(); ++i) {

        OptionTreeItem *itm = parent->childItems.at(i);
        if (itm->type == OptionTreeItem::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);
        }
    }
}

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

PPDOptionsModel::PPDOptionsModel(QCUPSSupport *c, QObject *parent)
    : QAbstractItemModel(parent), cups(c), ppd(c->currentPPD())
{
    parseItems();
}

PPDOptionsModel::~PPDOptionsModel()
{}

int PPDOptionsModel::columnCount(const QModelIndex&) const
{
    return 2;
}

int PPDOptionsModel::rowCount(const QModelIndex& parent) const
{
    OptionTreeItem* itm;
    if (!parent.isValid())
        itm = rootItem;
    else
        itm = reinterpret_cast<OptionTreeItem*>(parent.internalPointer());

    if (itm->type == OptionTreeItem::Option)
        return 0;

    return itm->childItems.count();
}

QVariant PPDOptionsModel::data(const QModelIndex& index, int role) const
{
    switch(role) {
        case Qt::FontRole: {
            OptionTreeItem* itm = reinterpret_cast<OptionTreeItem*>(index.internalPointer());
            if (itm && itm->type == OptionTreeItem::Group){
                QFont font = QApplication::font();
                font.setBold(true);
                return QVariant(font);
            }
            return QVariant();
        }
        break;

        case Qt::DisplayRole: {
            OptionTreeItem* itm;
            if (!index.isValid())
                itm = rootItem;
            else
                itm = reinterpret_cast<OptionTreeItem*>(index.internalPointer());

            if (index.column() == 0)
                return cups->unicodeString(itm->description);
            else if (itm->type == OptionTreeItem::Option && itm->selected > -1)
                return cups->unicodeString(itm->selDescription);
            else
                return QVariant();
        }
        break;

        default:
            return QVariant();
    }
    if (role != Qt::DisplayRole)
        return QVariant();
}

QModelIndex PPDOptionsModel::index(int row, int column, const QModelIndex& parent) const
{
    OptionTreeItem* itm;
    if (!parent.isValid())
        itm = rootItem;
    else
        itm = reinterpret_cast<OptionTreeItem*>(parent.internalPointer());

    return createIndex(row, column, itm->childItems.at(row));
}


QModelIndex PPDOptionsModel::parent(const QModelIndex& index) const
{
    if (!index.isValid())
        return QModelIndex();

    OptionTreeItem* itm = reinterpret_cast<OptionTreeItem*>(index.internalPointer());

    if (itm->parentItem && itm->parentItem != rootItem)
        return createIndex(itm->parentItem->index, 0, itm->parentItem);
    else
        return QModelIndex();
}

Qt::ItemFlags PPDOptionsModel::flags(const QModelIndex& index) const
{
    if (!index.isValid() || reinterpret_cast<OptionTreeItem*>(index.internalPointer())->type == OptionTreeItem::Group)
        return Qt::ItemIsEnabled;

    if (index.column() == 1)
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

void PPDOptionsModel::parseItems()
{
    rootItem = new OptionTreeItem(OptionTreeItem::Root, 0, ppd, "Root Item", 0);
    parseGroups(rootItem);
}

void PPDOptionsModel::parseGroups(OptionTreeItem* parent)
{
    if (parent->type == OptionTreeItem::Root) {

        const ppd_file_t* ppdFile = reinterpret_cast<const ppd_file_t*>(parent->ptr);

        if (ppdFile) {
            for (int i = 0; i < ppdFile->num_groups; ++i) {
                OptionTreeItem* group = new OptionTreeItem(OptionTreeItem::Group, i, &ppdFile->groups[i], ppdFile->groups[i].text, parent);
                parent->childItems.append(group);
                parseGroups(group); // parse possible subgroups
                parseOptions(group); // parse options
            }
        }
    } else if (parent->type == OptionTreeItem::Group) {

        const ppd_group_t* group = reinterpret_cast<const ppd_group_t*>(parent->ptr);

        if (group) {
            for (int i = 0; i < group->num_subgroups; ++i) {
                OptionTreeItem* subgroup = new OptionTreeItem(OptionTreeItem::Group, i, &group->subgroups[i], group->subgroups[i].text, parent);
                parent->childItems.append(subgroup);
                parseGroups(subgroup); // parse possible subgroups
                parseOptions(subgroup); // parse options
            }
        }
    }
}

void PPDOptionsModel::parseOptions(OptionTreeItem* parent)
{
    const ppd_group_t* group = reinterpret_cast<const ppd_group_t*>(parent->ptr);
    for (int i = 0; i < group->num_options; ++i) {
        OptionTreeItem* opt = new OptionTreeItem(OptionTreeItem::Option, i, &group->options[i], group->options[i].text, parent);
        parent->childItems.append(opt);
        parseChoices(opt);
    }
}

void PPDOptionsModel::parseChoices(OptionTreeItem* parent)
{
    const ppd_option_t* option = reinterpret_cast<const ppd_option_t*>(parent->ptr);
    bool marked = false;
    for (int i = 0; i < option->num_choices; ++i) {
        OptionTreeItem* choice = new OptionTreeItem(OptionTreeItem::Choice, i, &option->choices[i], option->choices[i].text, parent);
        if (static_cast<int>(option->choices[i].marked) == 1) {
            parent->selected = i;
            parent->selDescription = option->choices[i].text;
            marked = true;
        } else if (!marked && qstrcmp(option->choices[i].choice, option->defchoice) == 0) {
            parent->selected = i;
            parent->selDescription = option->choices[i].text;
        }
        parent->childItems.append(choice);
    }
}

QVariant PPDOptionsModel::headerData(int section, Qt::Orientation, int role) const
{
    if (role != Qt::DisplayRole)
        return QVariant();

    switch(section){
        case 0:
            return QVariant(QApplication::translate("PPDOptionsModel","Name"));
        case 1:
            return QVariant(QApplication::translate("PPDOptionsModel","Value"));
        default:
            return QVariant();
    }
}

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

QWidget* PPDOptionsEditor::createEditor(QWidget* parent, const QStyleOptionViewItem&, const QModelIndex& index) const
{
    if (index.column() == 1 && reinterpret_cast<OptionTreeItem*>(index.internalPointer())->type == OptionTreeItem::Option)
        return new QComboBox(parent);
    else
        return 0;
}

void PPDOptionsEditor::setEditorData(QWidget* editor, const QModelIndex& index) const
{
    if (index.column() != 1)
        return;

    QComboBox* cb = static_cast<QComboBox*>(editor);
    OptionTreeItem* itm = reinterpret_cast<OptionTreeItem*>(index.internalPointer());

    if (itm->selected == -1)
        cb->addItem(QString());

    for (int i = 0; i < itm->childItems.count(); ++i)
        cb->addItem(QString::fromLocal8Bit(itm->childItems.at(i)->description));

    if (itm->selected > -1)
        cb->setCurrentIndex(itm->selected);

    connect(cb, SIGNAL(currentIndexChanged(int)), this, SLOT(cbChanged(int)));
}

void PPDOptionsEditor::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
    QComboBox* cb = static_cast<QComboBox*>(editor);
    OptionTreeItem* itm = reinterpret_cast<OptionTreeItem*>(index.internalPointer());

    if (itm->selected == cb->currentIndex())
        return;

    const ppd_option_t* opt = reinterpret_cast<const ppd_option_t*>(itm->ptr);
    PPDOptionsModel* m = static_cast<PPDOptionsModel*>(model);

    if (m->cups->markOption(opt->keyword, opt->choices[cb->currentIndex()].choice) == 0) {
        itm->selected = cb->currentIndex();
        itm->selDescription = reinterpret_cast<const ppd_option_t*>(itm->ptr)->choices[itm->selected].text;
    }
}

void PPDOptionsEditor::cbChanged(int)
{
    emit commitData(static_cast<QWidget*>(sender()));
}

#endif

#include "moc_qprintdialog.cpp"
#include "qprintdialog_unix.moc"

#endif // QT_NO_PRINTDIALOG