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 QtGui module 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 <private/qpaintengine_preview_p.h>

    43 #include <private/qpainter_p.h>

    44 #include <private/qpaintengine_p.h>

    45 #include <private/qpicture_p.h>

    46 

    47 #include <QtGui/qprintengine.h>

    48 #include <QtGui/qpainter.h>

    49 #include <QtGui/qpicture.h>

    50 

    51 #ifndef QT_NO_PRINTPREVIEWWIDGET

    52 QT_BEGIN_NAMESPACE

    53 

    54 class QPreviewPaintEnginePrivate : public QPaintEnginePrivate

    55 {

    56     Q_DECLARE_PUBLIC(QPreviewPaintEngine)

    57 public:

    58     QPreviewPaintEnginePrivate() : state(QPrinter::Idle) {}

    59     ~QPreviewPaintEnginePrivate() {}

    60 

    61     QList<const QPicture *> pages;

    62     QPaintEngine *engine;

    63     QPainter *painter;

    64     QPrinter::PrinterState state;

    65 

    66     QPaintEngine *proxy_paint_engine;

    67     QPrintEngine *proxy_print_engine;

    68 };

    69 

    70 

    71 QPreviewPaintEngine::QPreviewPaintEngine()

    72     : QPaintEngine(*(new QPreviewPaintEnginePrivate), PaintEngineFeatures(AllFeatures & ~ObjectBoundingModeGradients))

    73 {

    74     Q_D(QPreviewPaintEngine);

    75     d->proxy_print_engine = 0;

    76     d->proxy_paint_engine = 0;

    77 }

    78 

    79 QPreviewPaintEngine::~QPreviewPaintEngine()

    80 {

    81     Q_D(QPreviewPaintEngine);

    82 

    83     qDeleteAll(d->pages);

    84 }

    85 

    86 bool QPreviewPaintEngine::begin(QPaintDevice *)

    87 {

    88     Q_D(QPreviewPaintEngine);

    89 

    90     qDeleteAll(d->pages);

    91     d->pages.clear();

    92 

    93     QPicture *page = new QPicture;

    94     page->d_func()->in_memory_only = true;

    95     d->painter = new QPainter(page);

    96     d->engine = d->painter->paintEngine();

    97     d->pages.append(page);

    98     d->state = QPrinter::Active;

    99     return true;

   100 }

   101 

   102 bool QPreviewPaintEngine::end()

   103 {

   104     Q_D(QPreviewPaintEngine);

   105 

   106     delete d->painter;

   107     d->painter = 0;

   108     d->engine = 0;

   109     d->state = QPrinter::Idle;

   110     return true;

   111 }

   112 

   113 void QPreviewPaintEngine::updateState(const QPaintEngineState &state)

   114 {

   115     Q_D(QPreviewPaintEngine);

   116     d->engine->updateState(state);

   117 }

   118 

   119 void QPreviewPaintEngine::drawPath(const QPainterPath &path)

   120 {

   121     Q_D(QPreviewPaintEngine);

   122     d->engine->drawPath(path);

   123 }

   124 

   125 void QPreviewPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)

   126 {

   127     Q_D(QPreviewPaintEngine);

   128     d->engine->drawPolygon(points, pointCount, mode);

   129 }

   130 

   131 void QPreviewPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)

   132 {

   133     Q_D(QPreviewPaintEngine);

   134     d->engine->drawTextItem(p, textItem);

   135 }

   136 

   137 void QPreviewPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)

   138 {

   139     Q_D(QPreviewPaintEngine);

   140     d->engine->drawPixmap(r, pm, sr);

   141 }

   142 

   143 void QPreviewPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &p)

   144 {

   145     Q_D(QPreviewPaintEngine);

   146     d->engine->drawTiledPixmap(r, pm, p);

   147 }

   148 

   149 bool QPreviewPaintEngine::newPage()

   150 {

   151     Q_D(QPreviewPaintEngine);

   152 

   153     QPicture *page = new QPicture;

   154     page->d_func()->in_memory_only = true;

   155     QPainter *tmp_painter = new QPainter(page);

   156     QPaintEngine *tmp_engine = tmp_painter->paintEngine();

   157 

   158     // copy the painter state from the original painter

   159     Q_ASSERT(painter()->d_func()->state && tmp_painter->d_func()->state);

   160     *tmp_painter->d_func()->state = *painter()->d_func()->state;

   161 

   162     // composition modes aren't supported on a QPrinter and yields a

   163     // warning, so ignore it for now

   164     tmp_engine->setDirty(DirtyFlags(AllDirty & ~DirtyCompositionMode));

   165     tmp_engine->syncState();

   166 

   167     delete d->painter;

   168     d->painter = tmp_painter;

   169     d->pages.append(page);

   170     d->engine = tmp_engine;

   171     return true;

   172 }

   173 

   174 bool QPreviewPaintEngine::abort()

   175 {

   176     Q_D(QPreviewPaintEngine);

   177     end();

   178     qDeleteAll(d->pages);

   179     d->state = QPrinter::Aborted;

   180 

   181     return true;

   182 }

   183 

   184 QList<const QPicture *> QPreviewPaintEngine::pages()

   185 {

   186     Q_D(QPreviewPaintEngine);

   187     return d->pages;

   188 }

   189 

   190 void QPreviewPaintEngine::setProxyEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine)

   191 {

   192     Q_D(QPreviewPaintEngine);

   193     d->proxy_print_engine = printEngine;

   194     d->proxy_paint_engine = paintEngine;

   195 }

   196 

   197 void QPreviewPaintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)

   198 {

   199     Q_D(QPreviewPaintEngine);

   200     d->proxy_print_engine->setProperty(key, value);

   201 }

   202 

   203 QVariant QPreviewPaintEngine::property(PrintEnginePropertyKey key) const

   204 {

   205     Q_D(const QPreviewPaintEngine);

   206     return d->proxy_print_engine->property(key);

   207 }

   208 

   209 int QPreviewPaintEngine::metric(QPaintDevice::PaintDeviceMetric id) const

   210 {

   211     Q_D(const QPreviewPaintEngine);

   212     return d->proxy_print_engine->metric(id);

   213 }

   214 

   215 QPrinter::PrinterState QPreviewPaintEngine::printerState() const

   216 {

   217     Q_D(const QPreviewPaintEngine);

   218     return d->state;

   219 }

   220 

   221 QT_END_NAMESPACE

   222 

   223 #endif