1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the examples of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtGui>

    43 

    44 #include "imagemodel.h"

    45 #include "mainwindow.h"

    46 #include "pixeldelegate.h"

    47 

    48 //! [0]

    49 MainWindow::MainWindow()

    50 {

    51 //! [0]

    52     currentPath = QDir::homePath();

    53     model = new ImageModel(this);

    54 

    55     QWidget *centralWidget = new QWidget;

    56 

    57 //! [1]

    58     view = new QTableView;

    59     view->setShowGrid(false);

    60     view->horizontalHeader()->hide();

    61     view->verticalHeader()->hide();

    62     view->horizontalHeader()->setMinimumSectionSize(1);

    63     view->verticalHeader()->setMinimumSectionSize(1);

    64     view->setModel(model);

    65 //! [1]

    66 

    67 //! [2]

    68     PixelDelegate *delegate = new PixelDelegate(this);

    69     view->setItemDelegate(delegate);

    70 //! [2]

    71 

    72 //! [3]

    73     QLabel *pixelSizeLabel = new QLabel(tr("Pixel size:"));

    74     QSpinBox *pixelSizeSpinBox = new QSpinBox;

    75     pixelSizeSpinBox->setMinimum(4);

    76     pixelSizeSpinBox->setMaximum(32);

    77     pixelSizeSpinBox->setValue(12);

    78 //! [3]

    79 

    80     QMenu *fileMenu = new QMenu(tr("&File"), this);

    81     QAction *openAction = fileMenu->addAction(tr("&Open..."));

    82     openAction->setShortcuts(QKeySequence::Open);

    83 

    84     printAction = fileMenu->addAction(tr("&Print..."));

    85     printAction->setEnabled(false);

    86     printAction->setShortcut(QKeySequence::Print);

    87 

    88     QAction *quitAction = fileMenu->addAction(tr("E&xit"));

    89     quitAction->setShortcuts(QKeySequence::Quit);

    90 

    91     QMenu *helpMenu = new QMenu(tr("&Help"), this);

    92     QAction *aboutAction = helpMenu->addAction(tr("&About"));

    93 

    94     menuBar()->addMenu(fileMenu);

    95     menuBar()->addSeparator();

    96     menuBar()->addMenu(helpMenu);

    97 

    98     connect(openAction, SIGNAL(triggered()), this, SLOT(chooseImage()));

    99     connect(printAction, SIGNAL(triggered()), this, SLOT(printImage()));

   100     connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));

   101     connect(aboutAction, SIGNAL(triggered()), this, SLOT(showAboutBox()));

   102 //! [4]

   103     connect(pixelSizeSpinBox, SIGNAL(valueChanged(int)),

   104             delegate, SLOT(setPixelSize(int)));

   105     connect(pixelSizeSpinBox, SIGNAL(valueChanged(int)),

   106             this, SLOT(updateView()));

   107 //! [4]

   108 

   109     QHBoxLayout *controlsLayout = new QHBoxLayout;

   110     controlsLayout->addWidget(pixelSizeLabel);

   111     controlsLayout->addWidget(pixelSizeSpinBox);

   112     controlsLayout->addStretch(1);

   113 

   114     QVBoxLayout *mainLayout = new QVBoxLayout;

   115     mainLayout->addWidget(view);

   116     mainLayout->addLayout(controlsLayout);

   117     centralWidget->setLayout(mainLayout);

   118 

   119     setCentralWidget(centralWidget);

   120 

   121     setWindowTitle(tr("Pixelator"));

   122     resize(640, 480);

   123 //! [5]

   124 }

   125 //! [5]

   126 

   127 void MainWindow::chooseImage()

   128 {

   129     QString fileName = QFileDialog::getOpenFileName(this,

   130         tr("Choose an image"), currentPath, "*");

   131 

   132     if (!fileName.isEmpty())

   133         openImage(fileName);

   134 }

   135 

   136 void MainWindow::openImage(const QString &fileName)

   137 {

   138     QImage image;

   139 

   140     if (image.load(fileName)) {

   141         model->setImage(image);

   142         if (!fileName.startsWith(":/")) {

   143             currentPath = fileName;

   144             setWindowTitle(tr("%1 - Pixelator").arg(currentPath));

   145         }

   146 

   147         printAction->setEnabled(true);

   148         updateView();

   149     }

   150 }

   151 

   152 void MainWindow::printImage()

   153 {

   154 #ifndef QT_NO_PRINTER

   155     if (model->rowCount(QModelIndex())*model->columnCount(QModelIndex())

   156         > 90000) {

   157 	    QMessageBox::StandardButton answer;

   158 	    answer = QMessageBox::question(this, tr("Large Image Size"),

   159             tr("The printed image may be very large. Are you sure that "

   160                "you want to print it?"),

   161             QMessageBox::Yes | QMessageBox::No);

   162         if (answer == QMessageBox::No)

   163             return;

   164     }

   165 

   166     QPrinter printer(QPrinter::HighResolution);

   167 

   168     QPrintDialog *dlg = new QPrintDialog(&printer, this);

   169     dlg->setWindowTitle(tr("Print Image"));

   170 

   171     if (dlg->exec() != QDialog::Accepted)

   172         return;

   173 

   174     QPainter painter;

   175     painter.begin(&printer);

   176 

   177     int rows = model->rowCount(QModelIndex());

   178     int columns = model->columnCount(QModelIndex());

   179     int sourceWidth = (columns+1) * ItemSize;

   180     int sourceHeight = (rows+1) * ItemSize;

   181 

   182     painter.save();

   183 

   184     double xscale = printer.pageRect().width()/double(sourceWidth);

   185     double yscale = printer.pageRect().height()/double(sourceHeight);

   186     double scale = qMin(xscale, yscale);

   187 

   188     painter.translate(printer.paperRect().x() + printer.pageRect().width()/2,

   189                       printer.paperRect().y() + printer.pageRect().height()/2);

   190     painter.scale(scale, scale);

   191     painter.translate(-sourceWidth/2, -sourceHeight/2);

   192 

   193     QStyleOptionViewItem option;

   194     QModelIndex parent = QModelIndex();

   195 

   196     QProgressDialog progress(tr("Printing..."), tr("Cancel"), 0, rows, this);

   197     progress.setWindowModality(Qt::ApplicationModal);

   198     float y = ItemSize/2;

   199 

   200     for (int row = 0; row < rows; ++row) {

   201         progress.setValue(row);

   202         qApp->processEvents();

   203         if (progress.wasCanceled())

   204             break;

   205 

   206         float x = ItemSize/2;

   207 

   208         for (int column = 0; column < columns; ++column) {

   209             option.rect = QRect(int(x), int(y), ItemSize, ItemSize);

   210             view->itemDelegate()->paint(&painter, option,

   211                                         model->index(row, column, parent));

   212             x = x + ItemSize;

   213         }

   214         y = y + ItemSize;

   215     }

   216     progress.setValue(rows);

   217 

   218     painter.restore();

   219     painter.end();

   220 

   221     if (progress.wasCanceled()) {

   222         QMessageBox::information(this, tr("Printing canceled"),

   223             tr("The printing process was canceled."), QMessageBox::Cancel);

   224     }

   225 #else

   226     QMessageBox::information(this, tr("Printing canceled"), 

   227         tr("Printing is not supported on this Qt build"), QMessageBox::Cancel);

   228 #endif

   229 }

   230 

   231 void MainWindow::showAboutBox()

   232 {

   233     QMessageBox::about(this, tr("About the Pixelator example"),

   234         tr("This example demonstrates how a standard view and a custom\n"

   235            "delegate can be used to produce a specialized representation\n"

   236            "of data in a simple custom model."));

   237 }

   238 

   239 //! [6]

   240 void MainWindow::updateView()

   241 {

   242     view->resizeColumnsToContents();

   243     view->resizeRowsToContents();

   244 }

   245 //! [6]