src/gui/painting/qpaintengine_blitter.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtGui module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "private/qpaintengine_blitter_p.h"
  43
  44 #include "private/qblittable_p.h"
  45 #include "private/qpaintengine_raster_p.h"
  46 #include "private/qpainter_p.h"
  47 #include "private/qpixmap_blitter_p.h"
  48
  49 #ifndef QT_NO_BLITTABLE
  50 QT_BEGIN_NAMESPACE
  51
  52 #define STATE_XFORM_SCALE       0x00000001
  53 #define STATE_XFORM_COMPLEX     0x00000002
  54
  55 #define STATE_BRUSH_PATTERN     0x00000010
  56 #define STATE_BRUSH_ALPHA       0x00000020
  57
  58 #define STATE_PEN_ENABLED       0x00000100
  59
  60 #define STATE_ANTIALIASING      0x00001000
  61 #define STATE_ALPHA             0x00002000
  62 #define STATE_BLENDING_COMPLEX  0x00004000
  63
  64 #define STATE_CLIPSYS_COMPLEX   0x00010000
  65 #define STATE_CLIP_COMPLEX      0x00020000
  66
  67
  68 class CapabilitiesToStateMask
  69 {
  70 public:
  71     CapabilitiesToStateMask(QBlittable::Capabilities capabilities)
  72         : m_capabilities(capabilities)
  73         , fillRectMask(0)
  74         , drawRectMask(0)
  75         , drawPixmapMask(0)
  76         , capabillitiesState(0)
  77     {
  78         if (capabilities & QBlittable::SolidRectCapability)
  79             setFillRectMask();
  80         if (capabilities & QBlittable::SourcePixmapCapability)
  81            setSourcePixmapMask();
  82         if (capabilities & QBlittable::SourceOverPixmapCapability)
  83            setSourceOverPixmapMask();
  84         if (capabilities & QBlittable::SourceOverScaledPixmapCapability)
  85             setSourceOverScaledPixmapMask();
  86     }
  87
  88     inline bool canBlitterFillRect() const
  89     {
  90         return checkStateAgainstMask(capabillitiesState, fillRectMask);
  91     }
  92
  93     inline bool canBlitterDrawRectMask() const
  94     {
  95         return checkStateAgainstMask(capabillitiesState, drawRectMask);
  96     }
  97
  98     bool canBlitterDrawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) const
  99     {
 100         if (pm.handle()->classId() != QPlatformPixmap::BlitterClass)
 101             return false;
 102         if (checkStateAgainstMask(capabillitiesState, drawPixmapMask)) {
 103             if (m_capabilities & (QBlittable::SourceOverPixmapCapability
 104                                   | QBlittable::SourceOverScaledPixmapCapability)) {
 105                 if (r.size() != sr.size())
 106                     return m_capabilities & QBlittable::SourceOverScaledPixmapCapability;
 107                 else
 108                     return m_capabilities & QBlittable::SourceOverPixmapCapability;
 109             }
 110             if ((m_capabilities & QBlittable::SourcePixmapCapability) && r.size() == sr.size() && !pm.hasAlphaChannel())
 111                 return m_capabilities & QBlittable::SourcePixmapCapability;
 112         }
 113         return false;
 114     }
 115
 116     inline void updateState(uint mask, bool on) {
 117         updateStateBits(&capabillitiesState, mask, on);
 118     }
 119
 120 private:
 121
 122     static inline void updateStateBits(uint *state, uint mask, bool on)
 123     {
 124         *state = on ? (*state | mask) : (*state & ~mask);
 125     }
 126
 127     static inline bool checkStateAgainstMask(uint state, uint mask)
 128     {
 129         return !state || (state & mask && !(state & ~mask));
 130     }
 131
 132     void setFillRectMask() {
 133         updateStateBits(&fillRectMask, STATE_XFORM_SCALE, false);
 134         updateStateBits(&fillRectMask, STATE_XFORM_COMPLEX, false);
 135
 136         updateStateBits(&fillRectMask, STATE_BRUSH_PATTERN, false);
 137         updateStateBits(&fillRectMask, STATE_BRUSH_ALPHA, false);
 138
 139         updateStateBits(&fillRectMask, STATE_PEN_ENABLED, true);
 140
 141         //Sub-pixel aliasing should not be sent to the blitter
 142         updateStateBits(&fillRectMask, STATE_ANTIALIASING, true);
 143         updateStateBits(&fillRectMask, STATE_ALPHA, false);
 144         updateStateBits(&fillRectMask, STATE_BLENDING_COMPLEX, false);
 145
 146         updateStateBits(&fillRectMask, STATE_CLIPSYS_COMPLEX, false);
 147         updateStateBits(&fillRectMask, STATE_CLIP_COMPLEX, false);
 148     }
 149
 150     void setSourcePixmapMask() {
 151         updateStateBits(&drawPixmapMask, STATE_XFORM_SCALE, true);
 152         updateStateBits(&drawPixmapMask, STATE_XFORM_COMPLEX, false);
 153
 154         updateStateBits(&drawPixmapMask, STATE_BRUSH_PATTERN, true);
 155         updateStateBits(&drawPixmapMask, STATE_BRUSH_ALPHA, false);
 156
 157         updateStateBits(&drawPixmapMask, STATE_PEN_ENABLED, true);
 158
 159         updateStateBits(&drawPixmapMask, STATE_ANTIALIASING, true);
 160         updateStateBits(&drawPixmapMask, STATE_ALPHA, false);
 161         updateStateBits(&drawPixmapMask, STATE_BLENDING_COMPLEX, false);
 162
 163         updateStateBits(&drawPixmapMask, STATE_CLIPSYS_COMPLEX, false);
 164         updateStateBits(&drawPixmapMask, STATE_CLIP_COMPLEX, false);
 165     }
 166
 167     void setSourceOverPixmapMask() {
 168         setSourcePixmapMask();
 169     }
 170
 171     void setSourceOverScaledPixmapMask() {
 172         setSourceOverPixmapMask();
 173         updateStateBits(&drawRectMask, STATE_XFORM_SCALE, true);
 174     }
 175
 176     QBlittable::Capabilities m_capabilities;
 177     uint fillRectMask;
 178     uint drawRectMask;
 179     uint drawPixmapMask;
 180     uint capabillitiesState;
 181 };
 182
 183 class QBlitterPaintEnginePrivate : public QRasterPaintEnginePrivate
 184 {
 185     Q_DECLARE_PUBLIC(QBlitterPaintEngine);
 186 public:
 187     QBlitterPaintEnginePrivate(QBlittablePlatformPixmap *p)
 188         : QRasterPaintEnginePrivate()
 189         , pmData(p)
 190         , caps(pmData->blittable()->capabilities())
 191         , hasXForm(false)
 192
 193     {}
 194
 195     void lock();
 196     void unlock();
 197     void fillRect(const QRectF &rect, const QColor &color);
 198     void clipAndDrawPixmap(const QRectF &clip, const QRectF &target, const QPixmap &pm, const QRectF &sr);
 199
 200
 201     void updateCompleteState(QPainterState *s);
 202     void updatePenState(QPainterState *s);
 203     void updateBrushState(QPainterState *s);
 204     void updateOpacityState(QPainterState *s);
 205     void updateCompositionModeState(QPainterState *s);
 206     void updateRenderHintsState(QPainterState *s);
 207     void updateTransformState(QPainterState *s);
 208     void updateClipState(QPainterState *s);
 209
 210     QBlittablePlatformPixmap *pmData;
 211     CapabilitiesToStateMask caps;
 212     uint hasXForm;
 213 };
 214
 215
 216 inline void QBlitterPaintEnginePrivate::lock()
 217 {
 218     if (!pmData->blittable()->isLocked())
 219         rasterBuffer->prepare(pmData->buffer());
 220 }
 221
 222 inline void QBlitterPaintEnginePrivate::unlock()
 223 {
 224     pmData->blittable()->unlock();
 225 }
 226
 227 // State tracking to make decisions
 228 void QBlitterPaintEnginePrivate::updateCompleteState(QPainterState *s)
 229 {
 230     updatePenState(s);
 231     updateBrushState(s);
 232     updateOpacityState(s);
 233     updateCompositionModeState(s);
 234     updateRenderHintsState(s);
 235     updateTransformState(s);
 236     updateClipState(s);
 237 }
 238
 239 void QBlitterPaintEnginePrivate::updatePenState(QPainterState *s)
 240 {
 241     caps.updateState(STATE_PEN_ENABLED, qpen_style(s->pen) != Qt::NoPen);
 242 }
 243
 244 void QBlitterPaintEnginePrivate::updateBrushState(QPainterState *s)
 245 {
 246     Qt::BrushStyle style = qbrush_style(s->brush);
 247
 248     caps.updateState(STATE_BRUSH_PATTERN, style > Qt::SolidPattern);
 249     caps.updateState(STATE_BRUSH_ALPHA,
 250                         qbrush_color(s->brush).alpha() < 255);
 251 }
 252
 253 void QBlitterPaintEnginePrivate::updateOpacityState(QPainterState *s)
 254 {
 255     bool translucent = s->opacity < 1;
 256     caps.updateState(STATE_ALPHA, translucent);
 257 }
 258
 259 void QBlitterPaintEnginePrivate::updateCompositionModeState(QPainterState *s)
 260 {
 261     bool nonTrivial = s->composition_mode != QPainter::CompositionMode_SourceOver
 262                       && s->composition_mode != QPainter::CompositionMode_Source;
 263
 264     caps.updateState(STATE_BLENDING_COMPLEX, nonTrivial);
 265 }
 266
 267 void QBlitterPaintEnginePrivate::updateRenderHintsState(QPainterState *s)
 268 {
 269     bool aa = s->renderHints & QPainter::Antialiasing;
 270     caps.updateState(STATE_ANTIALIASING, aa);
 271 }
 272
 273 void QBlitterPaintEnginePrivate::updateTransformState(QPainterState *s)
 274 {
 275     QTransform::TransformationType type = s->matrix.type();
 276
 277     caps.updateState(STATE_XFORM_COMPLEX, type > QTransform::TxScale);
 278     caps.updateState(STATE_XFORM_SCALE, type > QTransform::TxTranslate);
 279
 280     hasXForm = type >= QTransform::TxTranslate;
 281 }
 282
 283 void QBlitterPaintEnginePrivate::updateClipState(QPainterState *)
 284 {
 285     const QClipData *clipData = clip();
 286     bool complexClip = clipData && !(clipData->hasRectClip || clipData->hasRegionClip);
 287     caps.updateState(STATE_CLIP_COMPLEX, complexClip);
 288 }
 289
 290 void QBlitterPaintEnginePrivate::fillRect(const QRectF &rect, const QColor &color)
 291 {
 292     Q_Q(QBlitterPaintEngine);
 293     pmData->unmarkRasterOverlay(rect);
 294     QRectF targetRect = rect;
 295     if (hasXForm)
 296         targetRect = q->state()->matrix.mapRect(rect);
 297     const QClipData *clipData = clip();
 298     if (clipData) {
 299         if (clipData->hasRectClip) {
 300             unlock();
 301             pmData->blittable()->fillRect(targetRect & clipData->clipRect, color);
 302         } else if (clipData->hasRegionClip) {
 303             QVector<QRect> rects = clipData->clipRegion.rects();
 304             for (int i = 0; i < rects.size(); ++i) {
 305                 QRect intersectRect = rects.at(i).intersected(targetRect.toRect());
 306                 if (!intersectRect.isEmpty()) {
 307                     unlock();
 308                     pmData->blittable()->fillRect(intersectRect, color);
 309                 }
 310             }
 311         }
 312     } else {
 313         if (targetRect.x() >= 0 && targetRect.y() >= 0
 314             && targetRect.width() <= q->paintDevice()->width()
 315             && targetRect.height() <= q->paintDevice()->height()) {
 316             unlock();
 317             pmData->blittable()->fillRect(targetRect, color);
 318         } else {
 319             QRectF deviceRect(0, 0, q->paintDevice()->width(), q->paintDevice()->height());
 320             unlock();
 321             pmData->blittable()->fillRect(deviceRect & targetRect, color);
 322         }
 323     }
 324 }
 325
 326 void QBlitterPaintEnginePrivate::clipAndDrawPixmap(const QRectF &clip,
 327                                                    const QRectF &target,
 328                                                    const QPixmap &pm,
 329                                                    const QRectF &sr)
 330 {
 331     QRectF intersectedRect = clip.intersected(target);
 332     if (intersectedRect.isEmpty())
 333         return;
 334     QRectF source = sr;
 335     if (intersectedRect.size() != target.size()) {
 336         qreal deltaTop = target.top() - intersectedRect.top();
 337         qreal deltaLeft = target.left() - intersectedRect.left();
 338         qreal deltaBottom = target.bottom() - intersectedRect.bottom();
 339         qreal deltaRight = target.right() - intersectedRect.right();
 340         source.adjust(-deltaLeft, -deltaTop, -deltaRight, -deltaBottom);
 341     }
 342     pmData->unmarkRasterOverlay(intersectedRect);
 343     pmData->blittable()->drawPixmap(intersectedRect, pm, source);
 344 }
 345
 346 QBlitterPaintEngine::QBlitterPaintEngine(QBlittablePlatformPixmap *p)
 347     : QRasterPaintEngine(*(new QBlitterPaintEnginePrivate(p)), p->buffer())
 348 {}
 349
 350 // State tracking
 351 void QBlitterPaintEngine::penChanged()
 352 {
 353     Q_D(QBlitterPaintEngine);
 354
 355     QRasterPaintEngine::penChanged();
 356     d->updatePenState(state());
 357 }
 358
 359 void QBlitterPaintEngine::brushChanged()
 360 {
 361     Q_D(QBlitterPaintEngine);
 362
 363     QRasterPaintEngine::brushChanged();
 364     d->updateBrushState(state());
 365 }
 366
 367 void QBlitterPaintEngine::opacityChanged()
 368 {
 369     Q_D(QBlitterPaintEngine);
 370
 371     QRasterPaintEngine::opacityChanged();
 372     d->updateOpacityState(state());
 373 }
 374
 375 void QBlitterPaintEngine::compositionModeChanged()
 376 {
 377     Q_D(QBlitterPaintEngine);
 378
 379     QRasterPaintEngine::compositionModeChanged();
 380     d->updateCompositionModeState(state());
 381 }
 382
 383 void QBlitterPaintEngine::renderHintsChanged()
 384 {
 385     Q_D(QBlitterPaintEngine);
 386
 387     QRasterPaintEngine::renderHintsChanged();
 388     d->updateRenderHintsState(state());
 389 }
 390
 391 void QBlitterPaintEngine::transformChanged()
 392 {
 393     Q_D(QBlitterPaintEngine);
 394
 395     QRasterPaintEngine::transformChanged();
 396     d->updateTransformState(state());
 397 }
 398
 399 void QBlitterPaintEngine::clipEnabledChanged()
 400 {
 401     Q_D(QBlitterPaintEngine);
 402     QRasterPaintEngine::clipEnabledChanged();
 403     d->updateClipState(state());
 404 }
 405
 406 bool QBlitterPaintEngine::begin(QPaintDevice *pdev)
 407 {
 408     bool ok = QRasterPaintEngine::begin(pdev);
 409 #ifdef QT_BLITTER_RASTEROVERLAY
 410     Q_D(QBlitterPaintEngine);
 411     d->pmData->unmergeOverlay();
 412 #endif
 413     return ok;
 414 }
 415
 416 bool QBlitterPaintEngine::end()
 417 {
 418 #ifdef QT_BLITTER_RASTEROVERLAY
 419     Q_D(QBlitterPaintEngine);
 420     d->pmData->mergeOverlay();
 421 #endif
 422
 423     return QRasterPaintEngine::end();
 424 }
 425
 426 void QBlitterPaintEngine::setState(QPainterState *s)
 427 {
 428     Q_D(QBlitterPaintEngine);
 429
 430     QRasterPaintEngine::setState(s);
 431     d->updateCompleteState(s);
 432 }
 433
 434 // Accelerated paths
 435 void QBlitterPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 436 {
 437     Q_D(QBlitterPaintEngine);
 438     if (path.shape() == QVectorPath::RectangleHint) {
 439         QRectF rect(((QPointF *) path.points())[0], ((QPointF *) path.points())[2]);
 440         fillRect(rect, brush);
 441     } else {
 442         d->lock();
 443         d->pmData->markRasterOverlay(path);
 444         QRasterPaintEngine::fill(path, brush);
 445     }
 446 }
 447
 448 void QBlitterPaintEngine::fillRect(const QRectF &rect, const QColor &color)
 449 {
 450     Q_D(QBlitterPaintEngine);
 451     if (d->caps.canBlitterFillRect() && color.alpha() == 0xff) {
 452         d->fillRect(rect, color);
 453     } else {
 454         d->lock();
 455         d->pmData->markRasterOverlay(rect);
 456         QRasterPaintEngine::fillRect(rect, color);
 457     }
 458 }
 459
 460 void QBlitterPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
 461 {
 462     if (rect.size().isEmpty())
 463         return;
 464
 465     Q_D(QBlitterPaintEngine);
 466
 467     if (qbrush_style(brush) == Qt::SolidPattern
 468         && qbrush_color(brush).alpha() == 0xff
 469         && d->caps.canBlitterFillRect()) {
 470         d->fillRect(rect, qbrush_color(brush));
 471     } else if (brush.style() == Qt::TexturePattern
 472               && d->caps.canBlitterDrawPixmap(rect, brush.texture(), rect)) {
 473         bool rectIsFilled = false;
 474         QRectF transformedRect = state()->matrix.mapRect(rect);
 475         qreal x = transformedRect.x();
 476         qreal y = transformedRect.y();
 477         QPixmap pm = brush.texture();
 478         d->unlock();
 479         int srcX = int(rect.x() - state()->brushOrigin.x()) % pm.width();
 480         if (srcX < 0)
 481             srcX = pm.width() + srcX;
 482         const int startX = srcX;
 483         int srcY = int(rect.y() - state()->brushOrigin.y()) % pm.height();
 484         if (srcY < 0)
 485             srcY = pm.height() + srcY;
 486         while (!rectIsFilled) {
 487             qreal blitWidth = (pm.width() ) - srcX;
 488             qreal blitHeight = (pm.height() ) - srcY;
 489             if (x + blitWidth > transformedRect.right())
 490                 blitWidth = transformedRect.right() -x;
 491             if (y + blitHeight > transformedRect.bottom())
 492                 blitHeight = transformedRect.bottom() - y;
 493             const QClipData *clipData = d->clip();
 494             if (clipData->hasRectClip) {
 495                 QRect targetRect = QRect(x, y, blitWidth, blitHeight).intersected(clipData->clipRect);
 496                 if (targetRect.isValid()) {
 497                     int tmpSrcX  = srcX + (targetRect.x() - x);
 498                     int tmpSrcY = srcY + (targetRect.y() - y);
 499                     QRect srcRect(tmpSrcX, tmpSrcY, targetRect.width(), targetRect.height());
 500                     d->pmData->blittable()->drawPixmap(targetRect, pm, srcRect);
 501                 }
 502             } else if (clipData->hasRegionClip) {
 503                 QVector<QRect> clipRects = clipData->clipRegion.rects();
 504                 QRect unclippedTargetRect(x, y, blitWidth, blitHeight);
 505                 QRegion intersectedRects = clipData->clipRegion.intersected(unclippedTargetRect);
 506
 507                 for (int i = 0; i < intersectedRects.rects().size(); ++i) {
 508                     QRect targetRect = intersectedRects.rects().at(i);
 509                     if (!targetRect.isValid() || targetRect.isEmpty())
 510                         continue;
 511                     int tmpSrcX = srcX + (targetRect.x() - x);
 512                     int tmpSrcY = srcY + (targetRect.y() - y);
 513                     QRect srcRect(tmpSrcX, tmpSrcY, targetRect.width(), targetRect.height());
 514                     d->pmData->blittable()->drawPixmap(targetRect, pm, srcRect);
 515                 }
 516             }
 517             x+=blitWidth;
 518             if (x >= transformedRect.right()) {
 519                 x = transformedRect.x();
 520                 srcX = startX;
 521                 srcY = 0;
 522                 y += blitHeight;
 523                 if (y >= transformedRect.bottom())
 524                     rectIsFilled = true;
 525             } else
 526                 srcX = 0;
 527         }
 528     } else {
 529         d->lock();
 530         d->pmData->markRasterOverlay(rect);
 531         QRasterPaintEngine::fillRect(rect, brush);
 532     }
 533
 534 }
 535
 536 void QBlitterPaintEngine::drawRects(const QRect *rects, int rectCount)
 537 {
 538     Q_D(QBlitterPaintEngine);
 539     if (d->caps.canBlitterDrawRectMask()) {
 540         for (int i=0; i<rectCount; ++i)
 541             d->fillRect(rects[i], qbrush_color(state()->brush));
 542     } else {
 543         d->pmData->markRasterOverlay(rects, rectCount);
 544         QRasterPaintEngine::drawRects(rects, rectCount);
 545     }
 546 }
 547
 548 void QBlitterPaintEngine::drawRects(const QRectF *rects, int rectCount)
 549 {
 550     Q_D(QBlitterPaintEngine);
 551     if (d->caps.canBlitterDrawRectMask()) {
 552         for (int i = 0; i < rectCount; ++i)
 553             d->fillRect(rects[i], qbrush_color(state()->brush));
 554     } else {
 555         d->pmData->markRasterOverlay(rects, rectCount);
 556         QRasterPaintEngine::drawRects(rects, rectCount);
 557     }
 558 }
 559
 560 void QBlitterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pm)
 561 {
 562     drawPixmap(QRectF(pos, pm.size()), pm, pm.rect());
 563 }
 564
 565 void QBlitterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
 566 {
 567     Q_D(QBlitterPaintEngine);
 568     if (d->caps.canBlitterDrawPixmap(r, pm, sr)) {
 569
 570         d->unlock();
 571         QRectF targetRect = r;
 572         if (d->hasXForm)
 573             targetRect = state()->matrix.mapRect(r);
 574         const QClipData *clipData = d->clip();
 575         if (clipData) {
 576             if (clipData->hasRectClip) {
 577                 d->clipAndDrawPixmap(clipData->clipRect, targetRect, pm, sr);
 578             } else if (clipData->hasRegionClip) {
 579                 QVector<QRect>rects = clipData->clipRegion.rects();
 580                 for (int i = 0; i<rects.size(); ++i)
 581                     d->clipAndDrawPixmap(rects.at(i), targetRect, pm, sr);
 582             }
 583         } else {
 584             QRectF deviceRect(0, 0, paintDevice()->width(), paintDevice()->height());
 585             d->clipAndDrawPixmap(deviceRect, targetRect, pm, sr);
 586         }
 587     }else {
 588         d->lock();
 589         d->pmData->markRasterOverlay(r);
 590         QRasterPaintEngine::drawPixmap(r, pm, sr);
 591     }
 592 }
 593
 594 // Overriden methods to lock the graphics memory
 595 void QBlitterPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
 596 {
 597     Q_D(QBlitterPaintEngine);
 598     d->lock();
 599     d->pmData->markRasterOverlay(points, pointCount);
 600     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
 601 }
 602
 603 void QBlitterPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
 604 {
 605     Q_D(QBlitterPaintEngine);
 606     d->lock();
 607     d->pmData->markRasterOverlay(points, pointCount);
 608     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
 609 }
 610
 611 void QBlitterPaintEngine::fillPath(const QPainterPath &path, QSpanData *fillData)
 612 {
 613     Q_D(QBlitterPaintEngine);
 614     d->lock();
 615     d->pmData->markRasterOverlay(path);
 616     QRasterPaintEngine::fillPath(path, fillData);
 617 }
 618
 619 void QBlitterPaintEngine::fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
 620 {
 621     Q_D(QBlitterPaintEngine);
 622     d->lock();
 623     d->pmData->markRasterOverlay(points, pointCount);
 624     QRasterPaintEngine::fillPolygon(points, pointCount, mode);
 625 }
 626
 627 void QBlitterPaintEngine::drawEllipse(const QRectF &r)
 628 {
 629     Q_D(QBlitterPaintEngine);
 630     d->lock();
 631     d->pmData->markRasterOverlay(r);
 632     QRasterPaintEngine::drawEllipse(r);
 633 }
 634
 635 void QBlitterPaintEngine::drawImage(const QPointF &pos, const QImage &image)
 636 {
 637     drawImage(QRectF(pos, image.size()), image, image.rect());
 638 }
 639
 640 void QBlitterPaintEngine::drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
 641                                     Qt::ImageConversionFlags flags)
 642 {
 643     Q_D(QBlitterPaintEngine);
 644     d->lock();
 645     d->pmData->markRasterOverlay(r);
 646     QRasterPaintEngine::drawImage(r, pm, sr, flags);
 647 }
 648
 649 void QBlitterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr)
 650 {
 651     Q_D(QBlitterPaintEngine);
 652     d->lock();
 653     d->pmData->markRasterOverlay(r);
 654     QRasterPaintEngine::drawTiledPixmap(r, pm, sr);
 655 }
 656
 657 void QBlitterPaintEngine::drawTextItem(const QPointF &pos, const QTextItem &ti)
 658 {
 659     Q_D(QBlitterPaintEngine);
 660     d->lock();
 661     d->pmData->markRasterOverlay(pos, ti);
 662     QRasterPaintEngine::drawTextItem(pos, ti);
 663 }
 664
 665 void QBlitterPaintEngine::drawPoints(const QPointF *points, int pointCount)
 666 {
 667     Q_D(QBlitterPaintEngine);
 668     d->lock();
 669     d->pmData->markRasterOverlay(points, pointCount);
 670     QRasterPaintEngine::drawPoints(points, pointCount);
 671 }
 672
 673 void QBlitterPaintEngine::drawPoints(const QPoint *points, int pointCount)
 674 {
 675     Q_D(QBlitterPaintEngine);
 676     d->lock();
 677     d->pmData->markRasterOverlay(points, pointCount);
 678     QRasterPaintEngine::drawPoints(points, pointCount);
 679 }
 680
 681 void QBlitterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 682 {
 683     Q_D(QBlitterPaintEngine);
 684     d->lock();
 685     d->pmData->markRasterOverlay(path);
 686     QRasterPaintEngine::stroke(path, pen);
 687 }
 688
 689 void QBlitterPaintEngine::drawStaticTextItem(QStaticTextItem *sti)
 690 {
 691     Q_D(QBlitterPaintEngine);
 692     d->lock();
 693     QRasterPaintEngine::drawStaticTextItem(sti);
 694
 695 #ifdef QT_BLITTER_RASTEROVERLAY
 696 //#### d->pmData->markRasterOverlay(sti);
 697     qWarning("not implemented: markRasterOverlay for QStaticTextItem");
 698 #endif
 699 }
 700
 701 QT_END_NAMESPACE
 702 #endif //QT_NO_BLITTABLE
 703