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 <qbitmap.h>

    43 #include <qpaintdevice.h>

    44 #include <private/qpaintengine_mac_p.h>

    45 #include <qpainterpath.h>

    46 #include <qpixmapcache.h>

    47 #include <private/qpaintengine_raster_p.h>

    48 #include <private/qprintengine_mac_p.h>

    49 #include <qprinter.h>

    50 #include <qstack.h>

    51 #include <qtextcodec.h>

    52 #include <qwidget.h>

    53 #include <qvarlengtharray.h>

    54 #include <qdebug.h>

    55 #include <qcoreapplication.h>

    56 #include <qmath.h>

    57 

    58 #include <private/qfont_p.h>

    59 #include <private/qfontengine_p.h>

    60 #include <private/qnumeric_p.h>

    61 #include <private/qpainter_p.h>

    62 #include <private/qpainterpath_p.h>

    63 #include <private/qpixmap_mac_p.h>

    64 #include <private/qt_mac_p.h>

    65 #include <private/qtextengine_p.h>

    66 #include <private/qwidget_p.h>

    67 #include <private/qt_cocoa_helpers_mac_p.h>

    68 

    69 #include <string.h>

    70 

    71 QT_BEGIN_NAMESPACE

    72 

    73 extern int qt_antialiasing_threshold; // QApplication.cpp

    74 

    75 /*****************************************************************************

    76   External functions

    77  *****************************************************************************/

    78 extern CGImageRef qt_mac_create_imagemask(const QPixmap &px, const QRectF &sr); //qpixmap_mac.cpp

    79 extern QPoint qt_mac_posInWindow(const QWidget *w); //qwidget_mac.cpp

    80 extern OSWindowRef qt_mac_window_for(const QWidget *); //qwidget_mac.cpp

    81 extern CGContextRef qt_mac_cg_context(const QPaintDevice *); //qpaintdevice_mac.cpp

    82 extern void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp

    83 extern QPixmap qt_pixmapForBrush(int, bool); //qbrush.cpp

    84 

    85 void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform);

    86 

    87 

    88 //Implemented for qt_mac_p.h

    89 QMacCGContext::QMacCGContext(QPainter *p)

    90 {

    91     QPaintEngine *pe = p->paintEngine();

    92     if (pe->type() == QPaintEngine::MacPrinter)

    93         pe = static_cast<QMacPrintEngine*>(pe)->paintEngine();

    94     pe->syncState();

    95     context = 0;

    96     if(pe->type() == QPaintEngine::CoreGraphics)

    97         context = static_cast<QCoreGraphicsPaintEngine*>(pe)->handle();

    98 

    99     int devType = p->device()->devType();

   100     if (pe->type() == QPaintEngine::Raster

   101             && (devType == QInternal::Widget || devType == QInternal::Pixmap)) {

   102 

   103         extern CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice);

   104         CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pe->paintDevice());

   105         uint flags = kCGImageAlphaPremultipliedFirst;

   106 #ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version

   107         flags |= kCGBitmapByteOrder32Host;

   108 #endif

   109         const QImage *image = (const QImage *) pe->paintDevice();

   110 

   111         context = CGBitmapContextCreate((void *) image->bits(), image->width(), image->height(),

   112                                         8, image->bytesPerLine(), colorspace, flags);

   113 

   114         CGContextTranslateCTM(context, 0, image->height());

   115         CGContextScaleCTM(context, 1, -1);

   116 

   117         if (devType == QInternal::Widget) {

   118             QRegion clip = p->paintEngine()->systemClip();

   119             QTransform native = p->deviceTransform();

   120             QTransform logical = p->combinedTransform();

   121             if (p->hasClipping()) {

   122                 QRegion r = p->clipRegion();

   123                 r.translate(native.dx() - logical.dx(), native.dy() - logical.dy());

   124                 if (clip.isEmpty())

   125                     clip = r;

   126                 else

   127                     clip &= r;

   128             }

   129             qt_mac_clip_cg(context, clip, 0);

   130 

   131             QPainterState *state = static_cast<QPainterState *>(pe->state);

   132             Q_ASSERT(state);

   133             if (!state->redirectionMatrix.isIdentity())

   134                 CGContextTranslateCTM(context, state->redirectionMatrix.dx(), state->redirectionMatrix.dy());

   135         }

   136     }

   137     CGContextRetain(context);

   138 }

   139 

   140 

   141 /*****************************************************************************

   142   QCoreGraphicsPaintEngine utility functions

   143  *****************************************************************************/

   144 

   145 //conversion

   146 inline static float qt_mac_convert_color_to_cg(int c) { return ((float)c * 1000 / 255) / 1000; }

   147 inline static int qt_mac_convert_color_from_cg(float c) { return qRound(c * 255); }

   148 CGAffineTransform qt_mac_convert_transform_to_cg(const QTransform &t) {

   149     return CGAffineTransformMake(t.m11(), t.m12(), t.m21(), t.m22(), t.dx(),  t.dy());

   150 }

   151 

   152 CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice)

   153 {

   154     bool isWidget = (paintDevice->devType() == QInternal::Widget);

   155     return QCoreGraphicsPaintEngine::macDisplayColorSpace(isWidget ? static_cast<const QWidget *>(paintDevice)

   156                                                                    : 0);

   157 }

   158 

   159 inline static QCFType<CGColorRef> cgColorForQColor(const QColor &col, QPaintDevice *pdev)

   160 {

   161     CGFloat components[] = {

   162         qt_mac_convert_color_to_cg(col.red()),

   163         qt_mac_convert_color_to_cg(col.green()),

   164         qt_mac_convert_color_to_cg(col.blue()),

   165         qt_mac_convert_color_to_cg(col.alpha())

   166     };

   167     return CGColorCreate(qt_mac_colorSpaceForDeviceType(pdev), components);

   168 }

   169 

   170 // There's architectural problems with using native gradients

   171 // on the Mac at the moment, so disable them.

   172 // #define QT_MAC_USE_NATIVE_GRADIENTS

   173 

   174 #ifdef QT_MAC_USE_NATIVE_GRADIENTS

   175 static bool drawGradientNatively(const QGradient *gradient)

   176 {

   177     return gradient->spread() == QGradient::PadSpread;

   178 }

   179 

   180 // gradiant callback

   181 static void qt_mac_color_gradient_function(void *info, const CGFloat *in, CGFloat *out)

   182 {

   183     QBrush *brush = static_cast<QBrush *>(info);

   184     Q_ASSERT(brush && brush->gradient());

   185 

   186     const QGradientStops stops = brush->gradient()->stops();

   187     const int n = stops.count();

   188     Q_ASSERT(n >= 1);

   189     const QGradientStop *begin = stops.constBegin();

   190     const QGradientStop *end = begin + n;

   191 

   192     qreal p = in[0];

   193     const QGradientStop *i = begin;

   194     while (i != end && i->first < p)

   195         ++i;

   196 

   197     QRgb c;

   198     if (i == begin) {

   199         c = begin->second.rgba();

   200     } else if (i == end) {

   201         c = (end - 1)->second.rgba();

   202     } else {

   203         const QGradientStop &s1 = *(i - 1);

   204         const QGradientStop &s2 = *i;

   205         qreal p1 = s1.first;

   206         qreal p2 = s2.first;

   207         QRgb c1 = s1.second.rgba();

   208         QRgb c2 = s2.second.rgba();

   209         int idist = 256 * (p - p1) / (p2 - p1);

   210         int dist = 256 - idist;

   211         c = qRgba(INTERPOLATE_PIXEL_256(qRed(c1), dist, qRed(c2), idist),

   212                   INTERPOLATE_PIXEL_256(qGreen(c1), dist, qGreen(c2), idist),

   213                   INTERPOLATE_PIXEL_256(qBlue(c1), dist, qBlue(c2), idist),

   214                   INTERPOLATE_PIXEL_256(qAlpha(c1), dist, qAlpha(c2), idist));

   215     }

   216 

   217     out[0] = qt_mac_convert_color_to_cg(qRed(c));

   218     out[1] = qt_mac_convert_color_to_cg(qGreen(c));

   219     out[2] = qt_mac_convert_color_to_cg(qBlue(c));

   220     out[3] = qt_mac_convert_color_to_cg(qAlpha(c));

   221 }

   222 #endif

   223 

   224 //clipping handling

   225 void QCoreGraphicsPaintEnginePrivate::resetClip()

   226 {

   227     static bool inReset = false;

   228     if (inReset)

   229         return;

   230     inReset = true;

   231 

   232     CGAffineTransform old_xform = CGContextGetCTM(hd);

   233 

   234     //setup xforms

   235     CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));

   236     while (stackCount > 0) {

   237         restoreGraphicsState();

   238     }

   239     saveGraphicsState();

   240     inReset = false;

   241     //reset xforms

   242     CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));

   243     CGContextConcatCTM(hd, old_xform);

   244 }

   245 

   246 static CGRect qt_mac_compose_rect(const QRectF &r, float off=0)

   247 {

   248     return CGRectMake(r.x()+off, r.y()+off, r.width(), r.height());

   249 }

   250 

   251 static CGMutablePathRef qt_mac_compose_path(const QPainterPath &p, float off=0)

   252 {

   253     CGMutablePathRef ret = CGPathCreateMutable();

   254     QPointF startPt;

   255     for (int i=0; i<p.elementCount(); ++i) {

   256         const QPainterPath::Element &elm = p.elementAt(i);

   257         switch (elm.type) {

   258             case QPainterPath::MoveToElement:

   259                 if(i > 0

   260                         && p.elementAt(i - 1).x == startPt.x()

   261                         && p.elementAt(i - 1).y == startPt.y())

   262                     CGPathCloseSubpath(ret);

   263                 startPt = QPointF(elm.x, elm.y);

   264                 CGPathMoveToPoint(ret, 0, elm.x+off, elm.y+off);

   265                 break;

   266             case QPainterPath::LineToElement:

   267                 CGPathAddLineToPoint(ret, 0, elm.x+off, elm.y+off);

   268                 break;

   269             case QPainterPath::CurveToElement:

   270                 Q_ASSERT(p.elementAt(i+1).type == QPainterPath::CurveToDataElement);

   271                 Q_ASSERT(p.elementAt(i+2).type == QPainterPath::CurveToDataElement);

   272                 CGPathAddCurveToPoint(ret, 0,

   273                         elm.x+off, elm.y+off,

   274                         p.elementAt(i+1).x+off, p.elementAt(i+1).y+off,

   275                         p.elementAt(i+2).x+off, p.elementAt(i+2).y+off);

   276                 i+=2;

   277                 break;

   278             default:

   279                 qFatal("QCoreGraphicsPaintEngine::drawPath(), unhandled type: %d", elm.type);

   280                 break;

   281         }

   282     }

   283     if(!p.isEmpty()

   284             && p.elementAt(p.elementCount() - 1).x == startPt.x()

   285             && p.elementAt(p.elementCount() - 1).y == startPt.y())

   286         CGPathCloseSubpath(ret);

   287     return ret;

   288 }

   289 

   290 CGColorSpaceRef QCoreGraphicsPaintEngine::m_genericColorSpace = 0;

   291 QHash<CGDirectDisplayID, CGColorSpaceRef> QCoreGraphicsPaintEngine::m_displayColorSpaceHash;

   292 bool QCoreGraphicsPaintEngine::m_postRoutineRegistered = false;

   293 

   294 CGColorSpaceRef QCoreGraphicsPaintEngine::macGenericColorSpace()

   295 {

   296 #if 0

   297     if (!m_genericColorSpace) {

   298 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4

   299         if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {

   300             m_genericColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);

   301         } else

   302 #endif

   303         {

   304             m_genericColorSpace = CGColorSpaceCreateDeviceRGB();

   305         }

   306         if (!m_postRoutineRegistered) {

   307             m_postRoutineRegistered = true;

   308             qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);

   309         }

   310     }

   311     return m_genericColorSpace;

   312 #else

   313     // Just return the main display colorspace for the moment.

   314     return macDisplayColorSpace();

   315 #endif

   316 }

   317 

   318 /*

   319     Ideally, we should pass the widget in here, and use CGGetDisplaysWithRect() etc.

   320     to support multiple displays correctly.

   321 */

   322 CGColorSpaceRef QCoreGraphicsPaintEngine::macDisplayColorSpace(const QWidget *widget)

   323 {

   324     CGColorSpaceRef colorSpace;

   325 

   326     CGDirectDisplayID displayID;

   327     CMProfileRef displayProfile = 0;

   328     if (widget == 0) {

   329         displayID = CGMainDisplayID();

   330     } else {

   331         const QRect &qrect = widget->window()->geometry();

   332         CGRect rect = CGRectMake(qrect.x(), qrect.y(), qrect.width(), qrect.height());

   333         CGDisplayCount throwAway;

   334         CGDisplayErr dErr = CGGetDisplaysWithRect(rect, 1, &displayID, &throwAway);

   335         if (dErr != kCGErrorSuccess)

   336             return macDisplayColorSpace(0); // fall back on main display

   337     }

   338     if ((colorSpace = m_displayColorSpaceHash.value(displayID)))

   339         return colorSpace;

   340 

   341     CMError err = CMGetProfileByAVID((CMDisplayIDType)displayID, &displayProfile);

   342     if (err == noErr) {

   343         colorSpace = CGColorSpaceCreateWithPlatformColorSpace(displayProfile);

   344     } else if (widget) {

   345         return macDisplayColorSpace(0); // fall back on main display

   346     }

   347 

   348     if (colorSpace == 0)

   349         colorSpace = CGColorSpaceCreateDeviceRGB();

   350 

   351     m_displayColorSpaceHash.insert(displayID, colorSpace);

   352     CMCloseProfile(displayProfile);

   353     if (!m_postRoutineRegistered) {

   354         m_postRoutineRegistered = true;

   355         qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);

   356     }

   357     return colorSpace;

   358 }

   359 

   360 void QCoreGraphicsPaintEngine::cleanUpMacColorSpaces()

   361 {

   362     if (m_genericColorSpace) {

   363         CFRelease(m_genericColorSpace);

   364         m_genericColorSpace = 0;

   365     }

   366     QHash<CGDirectDisplayID, CGColorSpaceRef>::const_iterator it = m_displayColorSpaceHash.constBegin();

   367     while (it != m_displayColorSpaceHash.constEnd()) {

   368         if (it.value())

   369             CFRelease(it.value());

   370         ++it;

   371     }

   372     m_displayColorSpaceHash.clear();

   373 }

   374 

   375 void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform)

   376 {

   377     CGAffineTransform old_xform = CGAffineTransformIdentity;

   378     if(orig_xform) { //setup xforms

   379         old_xform = CGContextGetCTM(hd);

   380         CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));

   381         CGContextConcatCTM(hd, *orig_xform);

   382     }

   383 

   384     //do the clipping

   385     CGContextBeginPath(hd);

   386     if(rgn.isEmpty()) {

   387         CGContextAddRect(hd, CGRectMake(0, 0, 0, 0));

   388     } else {

   389 #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)

   390         if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {

   391             QCFType<HIMutableShapeRef> shape = rgn.toHIMutableShape();

   392             Q_ASSERT(!HIShapeIsEmpty(shape));

   393             HIShapeReplacePathInCGContext(shape, hd);

   394         } else

   395 #endif

   396         {

   397             QVector<QRect> rects = rgn.rects();

   398             const int count = rects.size();

   399             for(int i = 0; i < count; i++) {

   400                 const QRect &r = rects[i];

   401                 CGRect mac_r = CGRectMake(r.x(), r.y(), r.width(), r.height());

   402                 CGContextAddRect(hd, mac_r);

   403             }

   404         }

   405 

   406     }

   407     CGContextClip(hd);

   408 

   409     if(orig_xform) {//reset xforms

   410         CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));

   411         CGContextConcatCTM(hd, old_xform);

   412     }

   413 }

   414 

   415 

   416 //pattern handling (tiling)

   417 #if 1

   418 #  define QMACPATTERN_MASK_MULTIPLIER 32

   419 #else

   420 #  define QMACPATTERN_MASK_MULTIPLIER 1

   421 #endif

   422 class QMacPattern

   423 {

   424 public:

   425     QMacPattern() : as_mask(false), pdev(0), image(0) { data.bytes = 0; }

   426     ~QMacPattern() { CGImageRelease(image); }

   427     int width() {

   428         if(image)

   429             return CGImageGetWidth(image);

   430         if(data.bytes)

   431             return 8*QMACPATTERN_MASK_MULTIPLIER;

   432         return data.pixmap.width();

   433     }

   434     int height() {

   435         if(image)

   436             return CGImageGetHeight(image);

   437         if(data.bytes)

   438             return 8*QMACPATTERN_MASK_MULTIPLIER;

   439         return data.pixmap.height();

   440     }

   441 

   442     //input

   443     QColor foreground;

   444     bool as_mask;

   445     struct {

   446         QPixmap pixmap;

   447         const uchar *bytes;

   448     } data;

   449     QPaintDevice *pdev;

   450     //output

   451     CGImageRef image;

   452 };

   453 static void qt_mac_draw_pattern(void *info, CGContextRef c)

   454 {

   455     QMacPattern *pat = (QMacPattern*)info;

   456     int w = 0, h = 0;

   457     bool isBitmap = (pat->data.pixmap.depth() == 1);

   458     if(!pat->image) { //lazy cache

   459         if(pat->as_mask) {

   460             Q_ASSERT(pat->data.bytes);

   461             w = h = 8;

   462 #if (QMACPATTERN_MASK_MULTIPLIER == 1)

   463             CGDataProviderRef provider = CGDataProviderCreateWithData(0, pat->data.bytes, w*h, 0);

   464             pat->image = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);

   465             CGDataProviderRelease(provider);

   466 #else

   467             const int numBytes = (w*h)/sizeof(uchar);

   468             uchar xor_bytes[numBytes];

   469             for(int i = 0; i < numBytes; ++i)

   470                 xor_bytes[i] = pat->data.bytes[i] ^ 0xFF;

   471             CGDataProviderRef provider = CGDataProviderCreateWithData(0, xor_bytes, w*h, 0);

   472             CGImageRef swatch = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);

   473             CGDataProviderRelease(provider);

   474 

   475             const QColor c0(0, 0, 0, 0), c1(255, 255, 255, 255);

   476             QPixmap pm(w*QMACPATTERN_MASK_MULTIPLIER, h*QMACPATTERN_MASK_MULTIPLIER);

   477             pm.fill(c0);

   478             CGContextRef pm_ctx = qt_mac_cg_context(&pm);

   479             CGContextSetFillColorWithColor(c, cgColorForQColor(c1, pat->pdev));

   480             CGRect rect = CGRectMake(0, 0, w, h);

   481             for(int x = 0; x < QMACPATTERN_MASK_MULTIPLIER; ++x) {

   482                 rect.origin.x = x * w;

   483                 for(int y = 0; y < QMACPATTERN_MASK_MULTIPLIER; ++y) {

   484                     rect.origin.y = y * h;

   485                     qt_mac_drawCGImage(pm_ctx, &rect, swatch);

   486                 }

   487             }

   488             pat->image = qt_mac_create_imagemask(pm, pm.rect());

   489             CGImageRelease(swatch);

   490             CGContextRelease(pm_ctx);

   491             w *= QMACPATTERN_MASK_MULTIPLIER;

   492             h *= QMACPATTERN_MASK_MULTIPLIER;

   493 #endif

   494         } else {

   495             w = pat->data.pixmap.width();

   496             h = pat->data.pixmap.height();

   497             if (isBitmap)

   498                 pat->image = qt_mac_create_imagemask(pat->data.pixmap, pat->data.pixmap.rect());

   499             else

   500                 pat->image = (CGImageRef)pat->data.pixmap.macCGHandle();

   501         }

   502     } else {

   503         w = CGImageGetWidth(pat->image);

   504         h = CGImageGetHeight(pat->image);

   505     }

   506 

   507     //draw

   508     bool needRestore = false;

   509     if (CGImageIsMask(pat->image)) {

   510         CGContextSaveGState(c);

   511         CGContextSetFillColorWithColor(c, cgColorForQColor(pat->foreground, pat->pdev));

   512     }

   513     CGRect rect = CGRectMake(0, 0, w, h);

   514     qt_mac_drawCGImage(c, &rect, pat->image);

   515     if(needRestore)

   516         CGContextRestoreGState(c);

   517 }

   518 static void qt_mac_dispose_pattern(void *info)

   519 {

   520     QMacPattern *pat = (QMacPattern*)info;

   521     delete pat;

   522 }

   523 

   524 /*****************************************************************************

   525   QCoreGraphicsPaintEngine member functions

   526  *****************************************************************************/

   527 

   528 inline static QPaintEngine::PaintEngineFeatures qt_mac_cg_features()

   529 {

   530     return QPaintEngine::PaintEngineFeatures(QPaintEngine::AllFeatures & ~QPaintEngine::PaintOutsidePaintEvent

   531                                               & ~QPaintEngine::PerspectiveTransform

   532                                               & ~QPaintEngine::ConicalGradientFill

   533                                               & ~QPaintEngine::LinearGradientFill

   534                                               & ~QPaintEngine::RadialGradientFill

   535                                               & ~QPaintEngine::BrushStroke);

   536 }

   537 

   538 QCoreGraphicsPaintEngine::QCoreGraphicsPaintEngine()

   539 : QPaintEngine(*(new QCoreGraphicsPaintEnginePrivate), qt_mac_cg_features())

   540 {

   541 }

   542 

   543 QCoreGraphicsPaintEngine::QCoreGraphicsPaintEngine(QPaintEnginePrivate &dptr)

   544 : QPaintEngine(dptr, qt_mac_cg_features())

   545 {

   546 }

   547 

   548 QCoreGraphicsPaintEngine::~QCoreGraphicsPaintEngine()

   549 {

   550 }

   551 

   552 bool

   553 QCoreGraphicsPaintEngine::begin(QPaintDevice *pdev)

   554 {

   555     Q_D(QCoreGraphicsPaintEngine);

   556     if(isActive()) {                         // already active painting

   557         qWarning("QCoreGraphicsPaintEngine::begin: Painter already active");

   558         return false;

   559     }

   560 

   561     //initialization

   562     d->pdev = pdev;

   563     d->complexXForm = false;

   564     d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticSetPenWidth;

   565     d->cosmeticPenSize = 1;

   566     d->current.clipEnabled = false;

   567     d->pixelSize = QPoint(1,1);

   568     d->hd = qt_mac_cg_context(pdev);

   569     if(d->hd) {

   570         d->saveGraphicsState();

   571         d->orig_xform = CGContextGetCTM(d->hd);

   572         if (d->shading) {

   573             CGShadingRelease(d->shading);

   574             d->shading = 0;

   575         }

   576         d->setClip(0);  //clear the context's clipping

   577     }

   578 

   579     setActive(true);

   580 

   581     if(d->pdev->devType() == QInternal::Widget) {                    // device is a widget

   582         QWidget *w = (QWidget*)d->pdev;

   583         bool unclipped = w->testAttribute(Qt::WA_PaintUnclipped);

   584 

   585         if((w->windowType() == Qt::Desktop)) {

   586             if(!unclipped)

   587                 qWarning("QCoreGraphicsPaintEngine::begin: Does not support clipped desktop on Mac OS X");

   588             // ## need to do [qt_mac_window_for(w) makeKeyAndOrderFront]; (need to rename the file)

   589         } else if(unclipped) {

   590             qWarning("QCoreGraphicsPaintEngine::begin: Does not support unclipped painting");

   591         }

   592     } else if(d->pdev->devType() == QInternal::Pixmap) {             // device is a pixmap

   593         QPixmap *pm = (QPixmap*)d->pdev;

   594         if(pm->isNull()) {

   595             qWarning("QCoreGraphicsPaintEngine::begin: Cannot paint null pixmap");

   596             end();

   597             return false;

   598         }

   599     }

   600 

   601     setDirty(QPaintEngine::DirtyPen);

   602     setDirty(QPaintEngine::DirtyBrush);

   603     setDirty(QPaintEngine::DirtyBackground);

   604     setDirty(QPaintEngine::DirtyHints);

   605     return true;

   606 }

   607 

   608 bool

   609 QCoreGraphicsPaintEngine::end()

   610 {

   611     Q_D(QCoreGraphicsPaintEngine);

   612     setActive(false);

   613     if(d->pdev->devType() == QInternal::Widget && static_cast<QWidget*>(d->pdev)->windowType() == Qt::Desktop) {

   614 #ifndef QT_MAC_USE_COCOA

   615         HideWindow(qt_mac_window_for(static_cast<QWidget*>(d->pdev)));

   616 #else

   617 //        // ### need to do [qt_mac_window_for(static_cast<QWidget *>(d->pdev)) orderOut]; (need to rename)

   618 #endif

   619 

   620 	}

   621     if(d->shading) {

   622         CGShadingRelease(d->shading);

   623         d->shading = 0;

   624     }

   625     d->pdev = 0;

   626     if(d->hd) {

   627         d->restoreGraphicsState();

   628         CGContextSynchronize(d->hd);

   629         CGContextRelease(d->hd);

   630         d->hd = 0;

   631     }

   632     return true;

   633 }

   634 

   635 void

   636 QCoreGraphicsPaintEngine::updateState(const QPaintEngineState &state)

   637 {

   638     Q_D(QCoreGraphicsPaintEngine);

   639     QPaintEngine::DirtyFlags flags = state.state();

   640 

   641     if (flags & DirtyTransform)

   642         updateMatrix(state.transform());

   643 

   644     if (flags & DirtyClipEnabled) {

   645         if (state.isClipEnabled())

   646             updateClipPath(painter()->clipPath(), Qt::ReplaceClip);

   647         else

   648             updateClipPath(QPainterPath(), Qt::NoClip);

   649     }

   650 

   651     if (flags & DirtyClipPath) {

   652         updateClipPath(state.clipPath(), state.clipOperation());

   653     } else if (flags & DirtyClipRegion) {

   654         updateClipRegion(state.clipRegion(), state.clipOperation());

   655     }

   656 

   657     // If the clip has changed we need to update all other states

   658     // too, since they are included in the system context on OSX,

   659     // and changing the clip resets that context back to scratch.

   660     if (flags & (DirtyClipPath | DirtyClipRegion | DirtyClipEnabled))

   661         flags |= AllDirty;

   662 

   663     if (flags & DirtyPen)

   664         updatePen(state.pen());

   665     if (flags & (DirtyBrush|DirtyBrushOrigin))

   666         updateBrush(state.brush(), state.brushOrigin());

   667     if (flags & DirtyFont)

   668         updateFont(state.font());

   669     if (flags & DirtyOpacity)

   670         updateOpacity(state.opacity());

   671     if (flags & DirtyHints)

   672         updateRenderHints(state.renderHints());

   673     if (flags & DirtyCompositionMode)

   674         updateCompositionMode(state.compositionMode());

   675 

   676     if (flags & (DirtyPen | DirtyTransform)) {

   677         if (!d->current.pen.isCosmetic()) {

   678             d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticNone;

   679         } else if (d->current.transform.m11() < d->current.transform.m22()-1.0 ||

   680                   d->current.transform.m11() > d->current.transform.m22()+1.0) {

   681             d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticTransformPath;

   682             d->cosmeticPenSize = d->adjustPenWidth(d->current.pen.widthF());

   683             if (!d->cosmeticPenSize)

   684                 d->cosmeticPenSize = 1.0;

   685         } else {

   686             d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticSetPenWidth;

   687             static const float sqrt2 = sqrt(2);

   688             qreal width = d->current.pen.widthF();

   689             if (!width)

   690                 width = 1;

   691             d->cosmeticPenSize = sqrt(pow(d->pixelSize.y(), 2) + pow(d->pixelSize.x(), 2)) / sqrt2 * width;

   692         }

   693     }

   694 }

   695 

   696 void

   697 QCoreGraphicsPaintEngine::updatePen(const QPen &pen)

   698 {

   699     Q_D(QCoreGraphicsPaintEngine);

   700     Q_ASSERT(isActive());

   701     d->current.pen = pen;

   702     d->setStrokePen(pen);

   703 }

   704 

   705 void

   706 QCoreGraphicsPaintEngine::updateBrush(const QBrush &brush, const QPointF &brushOrigin)

   707 {

   708     Q_D(QCoreGraphicsPaintEngine);

   709     Q_ASSERT(isActive());

   710     d->current.brush = brush;

   711 

   712 #ifdef QT_MAC_USE_NATIVE_GRADIENTS

   713     // Quartz supports only pad spread

   714     if (const QGradient *gradient = brush.gradient()) {

   715         if (drawGradientNatively(gradient)) {

   716             gccaps |= QPaintEngine::LinearGradientFill | QPaintEngine::RadialGradientFill;

   717         } else {

   718             gccaps &= ~(QPaintEngine::LinearGradientFill | QPaintEngine::RadialGradientFill);

   719         }

   720     }

   721 #endif

   722 

   723     if (d->shading) {

   724         CGShadingRelease(d->shading);

   725         d->shading = 0;

   726     }

   727     d->setFillBrush(brushOrigin);

   728 }

   729 

   730 void

   731 QCoreGraphicsPaintEngine::updateOpacity(qreal opacity)

   732 {

   733     Q_D(QCoreGraphicsPaintEngine);

   734     CGContextSetAlpha(d->hd, opacity);

   735 }

   736 

   737 void

   738 QCoreGraphicsPaintEngine::updateFont(const QFont &)

   739 {

   740     Q_D(QCoreGraphicsPaintEngine);

   741     Q_ASSERT(isActive());

   742     updatePen(d->current.pen);

   743 }

   744 

   745 void

   746 QCoreGraphicsPaintEngine::updateMatrix(const QTransform &transform)

   747 {

   748     Q_D(QCoreGraphicsPaintEngine);

   749     Q_ASSERT(isActive());

   750 

   751     if (qt_is_nan(transform.m11()) || qt_is_nan(transform.m12()) || qt_is_nan(transform.m13())

   752 	|| qt_is_nan(transform.m21()) || qt_is_nan(transform.m22()) || qt_is_nan(transform.m23())

   753 	|| qt_is_nan(transform.m31()) || qt_is_nan(transform.m32()) || qt_is_nan(transform.m33()))

   754 	return;

   755 

   756     d->current.transform = transform;

   757     d->setTransform(transform.isIdentity() ? 0 : &transform);

   758     d->complexXForm = (transform.m11() != 1 || transform.m22() != 1

   759             || transform.m12() != 0 || transform.m21() != 0);

   760     d->pixelSize = d->devicePixelSize(d->hd);

   761 }

   762 

   763 void

   764 QCoreGraphicsPaintEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)

   765 {

   766     Q_D(QCoreGraphicsPaintEngine);

   767     Q_ASSERT(isActive());

   768     if(op == Qt::NoClip) {

   769         if(d->current.clipEnabled) {

   770             d->current.clipEnabled = false;

   771             d->current.clip = QRegion();

   772             d->setClip(0);

   773         }

   774     } else {

   775         if(!d->current.clipEnabled)

   776             op = Qt::ReplaceClip;

   777         d->current.clipEnabled = true;

   778         QRegion clipRegion(p.toFillPolygon().toPolygon(), p.fillRule());

   779         if(op == Qt::ReplaceClip) {

   780             d->current.clip = clipRegion;

   781             d->setClip(0);

   782             if(p.isEmpty()) {

   783                 CGRect rect = CGRectMake(0, 0, 0, 0);

   784                 CGContextClipToRect(d->hd, rect);

   785             } else {

   786                 CGMutablePathRef path = qt_mac_compose_path(p);

   787                 CGContextBeginPath(d->hd);

   788                 CGContextAddPath(d->hd, path);

   789                 if(p.fillRule() == Qt::WindingFill)

   790                     CGContextClip(d->hd);

   791                 else

   792                     CGContextEOClip(d->hd);

   793                 CGPathRelease(path);

   794             }

   795         } else if(op == Qt::IntersectClip) {

   796             d->current.clip = d->current.clip.intersected(clipRegion);

   797             d->setClip(&d->current.clip);

   798         } else if(op == Qt::UniteClip) {

   799             d->current.clip = d->current.clip.united(clipRegion);

   800             d->setClip(&d->current.clip);

   801         }

   802     }

   803 }

   804 

   805 void

   806 QCoreGraphicsPaintEngine::updateClipRegion(const QRegion &clipRegion, Qt::ClipOperation op)

   807 {

   808     Q_D(QCoreGraphicsPaintEngine);

   809     Q_ASSERT(isActive());

   810     if(op == Qt::NoClip) {

   811         d->current.clipEnabled = false;

   812         d->current.clip = QRegion();

   813         d->setClip(0);

   814     } else {

   815         if(!d->current.clipEnabled)

   816             op = Qt::ReplaceClip;

   817         d->current.clipEnabled = true;

   818         if(op == Qt::IntersectClip)

   819             d->current.clip = d->current.clip.intersected(clipRegion);

   820         else if(op == Qt::ReplaceClip)

   821             d->current.clip = clipRegion;

   822         else if(op == Qt::UniteClip)

   823             d->current.clip = d->current.clip.united(clipRegion);

   824         d->setClip(&d->current.clip);

   825     }

   826 }

   827 

   828 void

   829 QCoreGraphicsPaintEngine::drawPath(const QPainterPath &p)

   830 {

   831     Q_D(QCoreGraphicsPaintEngine);

   832     Q_ASSERT(isActive());

   833 

   834     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   835         return;

   836 

   837     CGMutablePathRef path = qt_mac_compose_path(p);

   838     uchar ops = QCoreGraphicsPaintEnginePrivate::CGStroke;

   839     if(p.fillRule() == Qt::WindingFill)

   840         ops |= QCoreGraphicsPaintEnginePrivate::CGFill;

   841     else

   842         ops |= QCoreGraphicsPaintEnginePrivate::CGEOFill;

   843     CGContextBeginPath(d->hd);

   844     d->drawPath(ops, path);

   845     CGPathRelease(path);

   846 }

   847 

   848 void

   849 QCoreGraphicsPaintEngine::drawRects(const QRectF *rects, int rectCount)

   850 {

   851     Q_D(QCoreGraphicsPaintEngine);

   852     Q_ASSERT(isActive());

   853 

   854     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   855         return;

   856 

   857     for (int i=0; i<rectCount; ++i) {

   858         QRectF r = rects[i];

   859 

   860         CGMutablePathRef path = CGPathCreateMutable();

   861         CGPathAddRect(path, 0, qt_mac_compose_rect(r));

   862         d->drawPath(QCoreGraphicsPaintEnginePrivate::CGFill|QCoreGraphicsPaintEnginePrivate::CGStroke,

   863                 path);

   864         CGPathRelease(path);

   865     }

   866 }

   867 

   868 void

   869 QCoreGraphicsPaintEngine::drawPoints(const QPointF *points, int pointCount)

   870 {

   871     Q_D(QCoreGraphicsPaintEngine);

   872     Q_ASSERT(isActive());

   873 

   874     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   875         return;

   876 

   877     if (d->current.pen.capStyle() == Qt::FlatCap)

   878         CGContextSetLineCap(d->hd, kCGLineCapSquare);

   879 

   880     CGMutablePathRef path = CGPathCreateMutable();

   881     for(int i=0; i < pointCount; i++) {

   882         float x = points[i].x(), y = points[i].y();

   883         CGPathMoveToPoint(path, 0, x, y);

   884         CGPathAddLineToPoint(path, 0, x+0.001, y);

   885     }

   886 

   887     bool doRestore = false;

   888     if(d->cosmeticPen == QCoreGraphicsPaintEnginePrivate::CosmeticNone && !(state->renderHints() & QPainter::Antialiasing)) {

   889         //we don't want adjusted pens for point rendering

   890         doRestore = true;

   891         d->saveGraphicsState();

   892         CGContextSetLineWidth(d->hd, d->current.pen.widthF());

   893     }

   894     d->drawPath(QCoreGraphicsPaintEnginePrivate::CGStroke, path);

   895     if (doRestore)

   896         d->restoreGraphicsState();

   897     CGPathRelease(path);

   898     if (d->current.pen.capStyle() == Qt::FlatCap)

   899         CGContextSetLineCap(d->hd, kCGLineCapButt);

   900 }

   901 

   902 void

   903 QCoreGraphicsPaintEngine::drawEllipse(const QRectF &r)

   904 {

   905     Q_D(QCoreGraphicsPaintEngine);

   906     Q_ASSERT(isActive());

   907 

   908     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   909         return;

   910 

   911     CGMutablePathRef path = CGPathCreateMutable();

   912     CGAffineTransform transform = CGAffineTransformMakeScale(r.width() / r.height(), 1);

   913     CGPathAddArc(path, &transform,(r.x() + (r.width() / 2)) / (r.width() / r.height()),

   914             r.y() + (r.height() / 2), r.height() / 2, 0, (2 * M_PI), false);

   915     d->drawPath(QCoreGraphicsPaintEnginePrivate::CGFill | QCoreGraphicsPaintEnginePrivate::CGStroke,

   916             path);

   917     CGPathRelease(path);

   918 }

   919 

   920 void

   921 QCoreGraphicsPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)

   922 {

   923     Q_D(QCoreGraphicsPaintEngine);

   924     Q_ASSERT(isActive());

   925 

   926     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   927         return;

   928 

   929     CGMutablePathRef path = CGPathCreateMutable();

   930     CGPathMoveToPoint(path, 0, points[0].x(), points[0].y());

   931     for(int x = 1; x < pointCount; ++x)

   932         CGPathAddLineToPoint(path, 0, points[x].x(), points[x].y());

   933     if(mode != PolylineMode && points[0] != points[pointCount-1])

   934         CGPathAddLineToPoint(path, 0, points[0].x(), points[0].y());

   935     uint op = QCoreGraphicsPaintEnginePrivate::CGStroke;

   936     if (mode != PolylineMode)

   937         op |= mode == OddEvenMode ? QCoreGraphicsPaintEnginePrivate::CGEOFill

   938             : QCoreGraphicsPaintEnginePrivate::CGFill;

   939     d->drawPath(op, path);

   940     CGPathRelease(path);

   941 }

   942 

   943 void

   944 QCoreGraphicsPaintEngine::drawLines(const QLineF *lines, int lineCount)

   945 {

   946     Q_D(QCoreGraphicsPaintEngine);

   947     Q_ASSERT(isActive());

   948 

   949     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   950         return;

   951 

   952     CGMutablePathRef path = CGPathCreateMutable();

   953     for(int i = 0; i < lineCount; i++) {

   954         const QPointF start = lines[i].p1(), end = lines[i].p2();

   955         CGPathMoveToPoint(path, 0, start.x(), start.y());

   956         CGPathAddLineToPoint(path, 0, end.x(), end.y());

   957     }

   958     d->drawPath(QCoreGraphicsPaintEnginePrivate::CGStroke, path);

   959     CGPathRelease(path);

   960 }

   961 

   962 void QCoreGraphicsPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)

   963 {

   964     Q_D(QCoreGraphicsPaintEngine);

   965     Q_ASSERT(isActive());

   966 

   967     if (state->compositionMode() == QPainter::CompositionMode_Destination)

   968         return;

   969 

   970     if(pm.isNull())

   971         return;

   972 

   973     bool differentSize = (QRectF(0, 0, pm.width(), pm.height()) != sr), doRestore = false;

   974     CGRect rect = CGRectMake(qRound(r.x()), qRound(r.y()), qRound(r.width()), qRound(r.height()));

   975     QCFType<CGImageRef> image;

   976     bool isBitmap = (pm.depth() == 1);

   977     if (isBitmap) {

   978         doRestore = true;

   979         d->saveGraphicsState();

   980 

   981         const QColor &col = d->current.pen.color();

   982         CGContextSetFillColorWithColor(d->hd, cgColorForQColor(col, d->pdev));

   983         image = qt_mac_create_imagemask(pm, sr);

   984     } else if (differentSize) {

   985         QCFType<CGImageRef> img = pm.toMacCGImageRef();

   986         image = CGImageCreateWithImageInRect(img, CGRectMake(qRound(sr.x()), qRound(sr.y()), qRound(sr.width()), qRound(sr.height())));

   987     } else {

   988         image = (CGImageRef)pm.macCGHandle();

   989     }

   990     qt_mac_drawCGImage(d->hd, &rect, image);

   991     if (doRestore)

   992         d->restoreGraphicsState();

   993 }

   994 

   995 static void drawImageReleaseData (void *info, const void *, size_t)

   996 {

   997     delete static_cast<QImage *>(info);

   998 }

   999 

  1000 CGImageRef qt_mac_createCGImageFromQImage(const QImage &img, const QImage **imagePtr = 0)

  1001 {

  1002     QImage *image;

  1003     if (img.depth() != 32)

  1004         image = new QImage(img.convertToFormat(QImage::Format_ARGB32_Premultiplied));

  1005     else

  1006         image = new QImage(img);

  1007 

  1008     uint cgflags = kCGImageAlphaNone;

  1009     switch (image->format()) {

  1010     case QImage::Format_ARGB32_Premultiplied:

  1011         cgflags = kCGImageAlphaPremultipliedFirst;

  1012         break;

  1013     case QImage::Format_ARGB32:

  1014         cgflags = kCGImageAlphaFirst;

  1015         break;

  1016     case QImage::Format_RGB32:

  1017         cgflags = kCGImageAlphaNoneSkipFirst;

  1018     default:

  1019         break;

  1020     }

  1021 #if defined(kCGBitmapByteOrder32Host) //only needed because CGImage.h added symbols in the minor version

  1022     cgflags |= kCGBitmapByteOrder32Host;

  1023 #endif

  1024     QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithData(image,

  1025                                                           static_cast<const QImage *>(image)->bits(),

  1026                                                           image->numBytes(),

  1027                                                           drawImageReleaseData);

  1028     if (imagePtr)

  1029         *imagePtr = image;

  1030     return CGImageCreate(image->width(), image->height(), 8, 32,

  1031                                         image->bytesPerLine(),

  1032                                         QCoreGraphicsPaintEngine::macGenericColorSpace(),

  1033                                         cgflags, dataProvider, 0, false, kCGRenderingIntentDefault);

  1034 

  1035 }

  1036 

  1037 void QCoreGraphicsPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,

  1038                                          Qt::ImageConversionFlags flags)

  1039 {

  1040     Q_D(QCoreGraphicsPaintEngine);

  1041     Q_UNUSED(flags);

  1042     Q_ASSERT(isActive());

  1043 

  1044     if (img.isNull() || state->compositionMode() == QPainter::CompositionMode_Destination)

  1045         return;

  1046 

  1047     const QImage *image;

  1048     QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(img, &image);

  1049     CGRect rect = CGRectMake(r.x(), r.y(), r.width(), r.height());

  1050     if (QRectF(0, 0, img.width(), img.height()) != sr)

  1051         cgimage = CGImageCreateWithImageInRect(cgimage, CGRectMake(sr.x(), sr.y(),

  1052                                                sr.width(), sr.height()));

  1053     qt_mac_drawCGImage(d->hd, &rect, cgimage);

  1054 }

  1055 

  1056 void QCoreGraphicsPaintEngine::initialize()

  1057 {

  1058 }

  1059 

  1060 void QCoreGraphicsPaintEngine::cleanup()

  1061 {

  1062 }

  1063 

  1064 CGContextRef

  1065 QCoreGraphicsPaintEngine::handle() const

  1066 {

  1067     return d_func()->hd;

  1068 }

  1069 

  1070 void

  1071 QCoreGraphicsPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap,

  1072         const QPointF &p)

  1073 {

  1074     Q_D(QCoreGraphicsPaintEngine);

  1075     Q_ASSERT(isActive());

  1076 

  1077     if (state->compositionMode() == QPainter::CompositionMode_Destination)

  1078         return;

  1079 

  1080     //save the old state

  1081     d->saveGraphicsState();

  1082 

  1083     //setup the pattern

  1084     QMacPattern *qpattern = new QMacPattern;

  1085     qpattern->data.pixmap = pixmap;

  1086     qpattern->foreground = d->current.pen.color();

  1087     qpattern->pdev = d->pdev;

  1088     CGPatternCallbacks callbks;

  1089     callbks.version = 0;

  1090     callbks.drawPattern = qt_mac_draw_pattern;

  1091     callbks.releaseInfo = qt_mac_dispose_pattern;

  1092     const int width = qpattern->width(), height = qpattern->height();

  1093     CGAffineTransform trans = CGContextGetCTM(d->hd);

  1094     CGPatternRef pat = CGPatternCreate(qpattern, CGRectMake(0, 0, width, height),

  1095             trans, width, height,

  1096             kCGPatternTilingNoDistortion, true, &callbks);

  1097     CGColorSpaceRef cs = CGColorSpaceCreatePattern(0);

  1098     CGContextSetFillColorSpace(d->hd, cs);

  1099     CGFloat component = 1.0; //just one

  1100     CGContextSetFillPattern(d->hd, pat, &component);

  1101     CGSize phase = CGSizeApplyAffineTransform(CGSizeMake(-(p.x()-r.x()), -(p.y()-r.y())), trans);

  1102     CGContextSetPatternPhase(d->hd, phase);

  1103 

  1104     //fill the rectangle

  1105     CGRect mac_rect = CGRectMake(r.x(), r.y(), r.width(), r.height());

  1106     CGContextFillRect(d->hd, mac_rect);

  1107 

  1108     //restore the state

  1109     d->restoreGraphicsState();

  1110     //cleanup

  1111     CGColorSpaceRelease(cs);

  1112     CGPatternRelease(pat);

  1113 }

  1114 

  1115 void QCoreGraphicsPaintEngine::drawTextItem(const QPointF &pos, const QTextItem &item)

  1116 {

  1117     Q_D(QCoreGraphicsPaintEngine);

  1118     if (d->current.transform.type() == QTransform::TxProject

  1119 #ifndef QMAC_NATIVE_GRADIENTS

  1120         || painter()->pen().brush().gradient()  //Just let the base engine "emulate" the gradient

  1121 #endif

  1122         ) {

  1123         QPaintEngine::drawTextItem(pos, item);

  1124         return;

  1125     }

  1126 

  1127     if (state->compositionMode() == QPainter::CompositionMode_Destination)

  1128         return;

  1129 

  1130     const QTextItemInt &ti = static_cast<const QTextItemInt &>(item);

  1131 

  1132     QPen oldPen = painter()->pen();

  1133     QBrush oldBrush = painter()->brush();

  1134     QPointF oldBrushOrigin = painter()->brushOrigin();