qpaintengine_mac.cpp File Reference

#include <qbitmap.h>
#include <qpaintdevice.h>
#include <private/qpaintengine_mac_p.h>
#include <qpainterpath.h>
#include <qpixmapcache.h>
#include <private/qpaintengine_raster_p.h>
#include <private/qprintengine_mac_p.h>
#include <qprinter.h>
#include <qstack.h>
#include <qtextcodec.h>
#include <qwidget.h>
#include <qvarlengtharray.h>
#include <qdebug.h>
#include <qcoreapplication.h>
#include <qmath.h>
#include <private/qfont_p.h>
#include <private/qfontengine_p.h>
#include <private/qfontengine_coretext_p.h>
#include <private/qfontengine_mac_p.h>
#include <private/qnumeric_p.h>
#include <private/qpainter_p.h>
#include <private/qpainterpath_p.h>
#include <private/qpixmap_mac_p.h>
#include <private/qt_mac_p.h>
#include <private/qtextengine_p.h>
#include <private/qwidget_p.h>
#include <private/qt_cocoa_helpers_mac_p.h>
#include <string.h>

Go to the source code of this file.

Classes
class	QMacPattern
struct	qt_mac_cg_transform_path

Macros
#define	QMACPATTERN_MASK_MULTIPLIER   32

Enumerations
enum	CGCompositeMode {   kCGCompositeModeClear = 0, kCGCompositeModeCopy = 1, kCGCompositeModeSourceOver = 2, kCGCompositeModeSourceIn = 3,   kCGCompositeModeSourceOut = 4, kCGCompositeModeSourceAtop = 5, kCGCompositeModeDestinationOver = 6, kCGCompositeModeDestinationIn = 7,   kCGCompositeModeDestinationOut = 8, kCGCompositeModeDestinationAtop = 9, kCGCompositeModeXOR = 10, kCGCompositeModePlusDarker = 11,   kCGCompositeModePlusLighter = 12 }

Functions
static QCFType< CGColorRef >	cgColorForQColor (const QColor &col, QPaintDevice *pdev)
void	CGContextSetCompositeOperation (CGContextRef, int)
static void	drawImageReleaseData (void *info, const void *, size_t)
CGContextRef	qt_mac_cg_context (const QPaintDevice *)
	Returns the CoreGraphics CGContextRef of the paint device. More...
static QPaintEngine::PaintEngineFeatures	qt_mac_cg_features ()
void	qt_mac_cg_transform_path_apply (void *info, const CGPathElement *element)
void	qt_mac_clip_cg (CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform)
CGColorSpaceRef	qt_mac_colorSpaceForDeviceType (const QPaintDevice *paintDevice)
static CGMutablePathRef	qt_mac_compose_path (const QPainterPath &p, float off=0)
static CGRect	qt_mac_compose_rect (const QRectF &r, float off=0)
static int	qt_mac_convert_color_from_cg (float c)
static float	qt_mac_convert_color_to_cg (int c)
CGAffineTransform	qt_mac_convert_transform_to_cg (const QTransform &t)
CGImageRef	qt_mac_create_imagemask (const QPixmap &px, const QRectF &sr)
CGImageRef	qt_mac_createCGImageFromQImage (const QImage &img, const QImage **imagePtr=0)
static void	qt_mac_dispose_pattern (void *info)
void	qt_mac_dispose_rgn (RgnHandle r)
static void	qt_mac_draw_pattern (void *info, CGContextRef c)
static const uchar *	qt_mac_patternForBrush (int brushStyle)
QPoint	qt_mac_posInWindow (const QWidget *w)
OSWindowRef	qt_mac_window_for (const QWidget *)
QPixmap	qt_pixmapForBrush (int, bool)

Variables
int	qt_antialiasing_threshold

Macro Definition Documentation

QMACPATTERN_MASK_MULTIPLIER

#define QMACPATTERN_MASK_MULTIPLIER   32

Definition at line 424 of file qpaintengine_mac.cpp.

Referenced by QMacPattern::height(), qt_mac_draw_pattern(), and QMacPattern::width().

Enumeration Type Documentation

CGCompositeMode

enum CGCompositeMode

Enumerator
kCGCompositeModeClear
kCGCompositeModeCopy
kCGCompositeModeSourceOver
kCGCompositeModeSourceIn
kCGCompositeModeSourceOut
kCGCompositeModeSourceAtop
kCGCompositeModeDestinationOver
kCGCompositeModeDestinationIn
kCGCompositeModeDestinationOut
kCGCompositeModeDestinationAtop
kCGCompositeModeXOR
kCGCompositeModePlusDarker
kCGCompositeModePlusLighter

Definition at line 1187 of file qpaintengine_mac.cpp.

                     {
        kCGCompositeModeClear            = 0,
        kCGCompositeModeCopy             = 1,
        kCGCompositeModeSourceOver       = 2,
        kCGCompositeModeSourceIn         = 3,
        kCGCompositeModeSourceOut        = 4,
        kCGCompositeModeSourceAtop       = 5,
        kCGCompositeModeDestinationOver  = 6,
        kCGCompositeModeDestinationIn    = 7,
        kCGCompositeModeDestinationOut   = 8,
        kCGCompositeModeDestinationAtop  = 9,
        kCGCompositeModeXOR              = 10,
        kCGCompositeModePlusDarker       = 11, // (max (0, (1-d) + (1-s)))
        kCGCompositeModePlusLighter      = 12, // (min (1, s + d))
    };

Function Documentation

cgColorForQColor()

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

inlinestatic

Definition at line 160 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawPixmap(), qt_mac_draw_pattern(), QCoreGraphicsPaintEnginePrivate::setFillBrush(), and QCoreGraphicsPaintEnginePrivate::setStrokePen().

{
    CGFloat components[] = {
        qt_mac_convert_color_to_cg(col.red()),
        qt_mac_convert_color_to_cg(col.green()),
        qt_mac_convert_color_to_cg(col.blue()),
        qt_mac_convert_color_to_cg(col.alpha())
    };
    return CGColorCreate(qt_mac_colorSpaceForDeviceType(pdev), components);
}

CGContextSetCompositeOperation()

void CGContextSetCompositeOperation	(	CGContextRef	,
		int
	)

Referenced by QCoreGraphicsPaintEngine::updateCompositionMode().

drawImageReleaseData()

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

static

Definition at line 1001 of file qpaintengine_mac.cpp.

Referenced by qt_mac_createCGImageFromQImage().

{
    delete static_cast<QImage *>(info);
}

qt_mac_cg_context()

CGContextRef qt_mac_cg_context

(

const QPaintDevice *

pdev

)

Returns the CoreGraphics CGContextRef of the paint device.

Warning

This function is not part of the public interface.

0 is returned if it can't be obtained. It is the caller's responsiblity to CGContextRelease the context when finished using it.

Warning

This function is only available on Mac OS X.

Definition at line 118 of file qpaintdevice_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::begin(), and qt_mac_draw_pattern().

{
    if (pdev->devType() == QInternal::Pixmap) {
        const QPixmap *pm = static_cast<const QPixmap*>(pdev);
        CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pdev);
        uint flags = kCGImageAlphaPremultipliedFirst;
#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
        flags |= kCGBitmapByteOrder32Host;
#endif
        CGContextRef ret = 0;

        // It would make sense to put this into a mac #ifdef'ed
        // virtual function in the QPixmapData at some point
        if (pm->data->classId() == QPixmapData::MacClass) {
            const QMacPixmapData *pmData = static_cast<const QMacPixmapData*>(pm->data.data());
            ret = CGBitmapContextCreate(pmData->pixels, pmData->w, pmData->h,
                                                     8, pmData->bytesPerRow, colorspace,
                                                     flags);
            if(!ret)
                qWarning("QPaintDevice: Unable to create context for pixmap (%d/%d/%d)",
                         pmData->w, pmData->h, (pmData->bytesPerRow * pmData->h));
        } else if (pm->data->classId() == QPixmapData::RasterClass) {
            QImage *image = pm->data->buffer();
            ret = CGBitmapContextCreate(image->bits(), image->width(), image->height(),
                                        8, image->bytesPerLine(), colorspace, flags);
        }

        CGContextTranslateCTM(ret, 0, pm->height());
        CGContextScaleCTM(ret, 1, -1);
        return ret;
    } else if (pdev->devType() == QInternal::Widget) {
        CGContextRef ret = static_cast<CGContextRef>(static_cast<const QWidget *>(pdev)->macCGHandle());
        CGContextRetain(ret);
        return ret;
    } else if (pdev->devType() == QInternal::MacQuartz) {
        return static_cast<const QMacQuartzPaintDevice *>(pdev)->cgContext();
    }
    return 0;
}

qt_mac_cg_features()

static QPaintEngine::PaintEngineFeatures qt_mac_cg_features ( )

inlinestatic

Definition at line 534 of file qpaintengine_mac.cpp.

{
    return QPaintEngine::PaintEngineFeatures(QPaintEngine::AllFeatures & ~QPaintEngine::PaintOutsidePaintEvent
                                              & ~QPaintEngine::PerspectiveTransform
                                              & ~QPaintEngine::ConicalGradientFill
                                              & ~QPaintEngine::LinearGradientFill
                                              & ~QPaintEngine::RadialGradientFill
                                              & ~QPaintEngine::BrushStroke);
}

qt_mac_cg_transform_path_apply()

void qt_mac_cg_transform_path_apply	(	void *	info,
		const CGPathElement *	element
	)

Definition at line 1640 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEnginePrivate::drawPath().

{
    Q_ASSERT(info && element);
    qt_mac_cg_transform_path *t = (qt_mac_cg_transform_path*)info;
    switch(element->type) {
    case kCGPathElementMoveToPoint:
        CGPathMoveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y);
        break;
    case kCGPathElementAddLineToPoint:
        CGPathAddLineToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y);
        break;
    case kCGPathElementAddQuadCurveToPoint:
        CGPathAddQuadCurveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y,
                                  element->points[1].x, element->points[1].y);
        break;
    case kCGPathElementAddCurveToPoint:
        CGPathAddCurveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y,
                              element->points[1].x, element->points[1].y,
                              element->points[2].x, element->points[2].y);
        break;
    case kCGPathElementCloseSubpath:
        CGPathCloseSubpath(t->path);
        break;
    default:
        qDebug() << "Unhandled path transform type: " << element->type;
    }
}

qt_mac_clip_cg()

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

Definition at line 381 of file qpaintengine_mac.cpp.

Referenced by QMacCGContext::QMacCGContext(), and QCoreGraphicsPaintEnginePrivate::setClip().

{
    CGAffineTransform old_xform = CGAffineTransformIdentity;
    if(orig_xform) { //setup xforms
        old_xform = CGContextGetCTM(hd);
        CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));
        CGContextConcatCTM(hd, *orig_xform);
    }

    //do the clipping
    CGContextBeginPath(hd);
    if(rgn.isEmpty()) {
        CGContextAddRect(hd, CGRectMake(0, 0, 0, 0));
    } else {
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
            QCFType<HIMutableShapeRef> shape = rgn.toHIMutableShape();
            Q_ASSERT(!HIShapeIsEmpty(shape));
            HIShapeReplacePathInCGContext(shape, hd);
        } else
#endif
        {
            QVector<QRect> rects = rgn.rects();
            const int count = rects.size();
            for(int i = 0; i < count; i++) {
                const QRect &r = rects[i];
                CGRect mac_r = CGRectMake(r.x(), r.y(), r.width(), r.height());
                CGContextAddRect(hd, mac_r);
            }
        }

    }
    CGContextClip(hd);

    if(orig_xform) {//reset xforms
        CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
        CGContextConcatCTM(hd, old_xform);
    }
}

qt_mac_colorSpaceForDeviceType()

CGColorSpaceRef qt_mac_colorSpaceForDeviceType

(

const QPaintDevice *

paintDevice

)

Definition at line 153 of file qpaintengine_mac.cpp.

Referenced by cgColorForQColor(), QMacCGContext::QMacCGContext(), qt_mac_cg_context(), qt_mac_qd_context(), and QCoreGraphicsPaintEnginePrivate::setFillBrush().

{
    bool isWidget = (paintDevice->devType() == QInternal::Widget);
    return QCoreGraphicsPaintEngine::macDisplayColorSpace(isWidget ? static_cast<const QWidget *>(paintDevice)
                                                                   : 0);
}

qt_mac_compose_path()

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

static

Definition at line 252 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawPath(), and QCoreGraphicsPaintEngine::updateClipPath().

{
    CGMutablePathRef ret = CGPathCreateMutable();
    QPointF startPt;
    for (int i=0; i<p.elementCount(); ++i) {
        const QPainterPath::Element &elm = p.elementAt(i);
        switch (elm.type) {
            case QPainterPath::MoveToElement:
                if(i > 0
                        && p.elementAt(i - 1).x == startPt.x()
                        && p.elementAt(i - 1).y == startPt.y())
                    CGPathCloseSubpath(ret);
                startPt = QPointF(elm.x, elm.y);
                CGPathMoveToPoint(ret, 0, elm.x+off, elm.y+off);
                break;
            case QPainterPath::LineToElement:
                CGPathAddLineToPoint(ret, 0, elm.x+off, elm.y+off);
                break;
            case QPainterPath::CurveToElement:
                Q_ASSERT(p.elementAt(i+1).type == QPainterPath::CurveToDataElement);
                Q_ASSERT(p.elementAt(i+2).type == QPainterPath::CurveToDataElement);
                CGPathAddCurveToPoint(ret, 0,
                        elm.x+off, elm.y+off,
                        p.elementAt(i+1).x+off, p.elementAt(i+1).y+off,
                        p.elementAt(i+2).x+off, p.elementAt(i+2).y+off);
                i+=2;
                break;
            default:
                qFatal("QCoreGraphicsPaintEngine::drawPath(), unhandled type: %d", elm.type);
                break;
        }
    }
    if(!p.isEmpty()
            && p.elementAt(p.elementCount() - 1).x == startPt.x()
            && p.elementAt(p.elementCount() - 1).y == startPt.y())
        CGPathCloseSubpath(ret);
    return ret;
}

qt_mac_compose_rect()

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

static

Definition at line 247 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawRects().

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

qt_mac_convert_color_from_cg()

static int qt_mac_convert_color_from_cg ( float  c )

inlinestatic

Definition at line 148 of file qpaintengine_mac.cpp.

{ return qRound(c * 255); }

qt_mac_convert_color_to_cg()

static float qt_mac_convert_color_to_cg ( int  c )

inlinestatic

Definition at line 147 of file qpaintengine_mac.cpp.

Referenced by cgColorForQColor(), and QCoreGraphicsPaintEnginePrivate::setFillBrush().

{ return ((float)c * 1000 / 255) / 1000; }

qt_mac_convert_transform_to_cg()

CGAffineTransform qt_mac_convert_transform_to_cg

(

const QTransform &

t

)

Definition at line 149 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEnginePrivate::drawPath(), QCoreGraphicsPaintEnginePrivate::setFillBrush(), and QCoreGraphicsPaintEnginePrivate::setTransform().

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

qt_mac_create_imagemask()

CGImageRef qt_mac_create_imagemask	(	const QPixmap &	px,
		const QRectF &	sr
	)

Definition at line 1077 of file qpixmap_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawPixmap(), and qt_mac_draw_pattern().

{
    QMacPixmapData *px = static_cast<QMacPixmapData*>(pixmap.data.data());
    if (px->cg_mask) {
        if (px->cg_mask_rect == sr) {
            CGImageRetain(px->cg_mask); //reference for the caller
            return px->cg_mask;
        }
        CGImageRelease(px->cg_mask);
        px->cg_mask = 0;
    }

    const int sx = qRound(sr.x()), sy = qRound(sr.y()), sw = qRound(sr.width()), sh = qRound(sr.height());
    const int sbpr = px->bytesPerRow;
    const uint nbytes = sw * sh;
    //  alpha is always 255 for bitmaps, ignore it in this case.
    const quint32 mask = px->depth() == 1 ? 0x00ffffff : 0xffffffff;
    quint8 *dptr = static_cast<quint8 *>(malloc(nbytes));
    quint32 *sptr = px->pixels, *srow;
    for(int y = sy, offset=0; y < sh; ++y) {
        srow = sptr + (y * (sbpr / 4));
        for(int x = sx; x < sw; ++x)
            *(dptr+(offset++)) = (*(srow+x) & mask) ? 255 : 0;
    }
    QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(0, dptr, nbytes, qt_mac_cgimage_data_free);
    px->cg_mask = CGImageMaskCreate(sw, sh, 8, 8, nbytes / sh, provider, 0, 0);
    px->cg_mask_rect = sr;
    CGImageRetain(px->cg_mask); //reference for the caller
    return px->cg_mask;
}

qt_mac_createCGImageFromQImage()

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

Definition at line 1006 of file qpaintengine_mac.cpp.

Referenced by QMacPasteboardMimeHTMLText::convertFromMime(), QMacPasteboardMimeTiff::convertFromMime(), and QCoreGraphicsPaintEngine::drawImage().

{
    QImage *image;
    if (img.depth() != 32)
        image = new QImage(img.convertToFormat(QImage::Format_ARGB32_Premultiplied));
    else
        image = new QImage(img);

    uint cgflags = kCGImageAlphaNone;
    switch (image->format()) {
    case QImage::Format_ARGB32_Premultiplied:
        cgflags = kCGImageAlphaPremultipliedFirst;
        break;
    case QImage::Format_ARGB32:
        cgflags = kCGImageAlphaFirst;
        break;
    case QImage::Format_RGB32:
        cgflags = kCGImageAlphaNoneSkipFirst;
    default:
        break;
    }
#if defined(kCGBitmapByteOrder32Host) //only needed because CGImage.h added symbols in the minor version
    cgflags |= kCGBitmapByteOrder32Host;
#endif
    QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithData(image,
                                                          static_cast<const QImage *>(image)->bits(),
                                                          image->byteCount(),
                                                          drawImageReleaseData);
    if (imagePtr)
        *imagePtr = image;
    return CGImageCreate(image->width(), image->height(), 8, 32,
                                        image->bytesPerLine(),
                                        QCoreGraphicsPaintEngine::macGenericColorSpace(),
                                        cgflags, dataProvider, 0, false, kCGRenderingIntentDefault);

}

qt_mac_dispose_pattern()

static void qt_mac_dispose_pattern ( void *  info )

static

Definition at line 524 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawTiledPixmap(), and QCoreGraphicsPaintEnginePrivate::setFillBrush().

{
    QMacPattern *pat = (QMacPattern*)info;
    delete pat;
}

qt_mac_dispose_rgn()

void qt_mac_dispose_rgn

(

RgnHandle

r

)

qt_mac_draw_pattern()

static void qt_mac_draw_pattern ( void *  info, CGContextRef  c  )

static

Definition at line 459 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawTiledPixmap(), and QCoreGraphicsPaintEnginePrivate::setFillBrush().

{
    QMacPattern *pat = (QMacPattern*)info;
    int w = 0, h = 0;
    bool isBitmap = (pat->data.pixmap.depth() == 1);
    if(!pat->image) { //lazy cache
        if(pat->as_mask) {
            Q_ASSERT(pat->data.bytes);
            w = h = 8;
#if (QMACPATTERN_MASK_MULTIPLIER == 1)
            CGDataProviderRef provider = CGDataProviderCreateWithData(0, pat->data.bytes, w*h, 0);
            pat->image = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);
            CGDataProviderRelease(provider);
#else
            const int numBytes = (w*h)/sizeof(uchar);
            uchar xor_bytes[numBytes];
            for(int i = 0; i < numBytes; ++i)
                xor_bytes[i] = pat->data.bytes[i] ^ 0xFF;
            CGDataProviderRef provider = CGDataProviderCreateWithData(0, xor_bytes, w*h, 0);
            CGImageRef swatch = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);
            CGDataProviderRelease(provider);

            const QColor c0(0, 0, 0, 0), c1(255, 255, 255, 255);
            QPixmap pm(w*QMACPATTERN_MASK_MULTIPLIER, h*QMACPATTERN_MASK_MULTIPLIER);
            pm.fill(c0);
            CGContextRef pm_ctx = qt_mac_cg_context(&pm);
            CGContextSetFillColorWithColor(c, cgColorForQColor(c1, pat->pdev));
            CGRect rect = CGRectMake(0, 0, w, h);
            for(int x = 0; x < QMACPATTERN_MASK_MULTIPLIER; ++x) {
                rect.origin.x = x * w;
                for(int y = 0; y < QMACPATTERN_MASK_MULTIPLIER; ++y) {
                    rect.origin.y = y * h;
                    qt_mac_drawCGImage(pm_ctx, &rect, swatch);
                }
            }
            pat->image = qt_mac_create_imagemask(pm, pm.rect());
            CGImageRelease(swatch);
            CGContextRelease(pm_ctx);
            w *= QMACPATTERN_MASK_MULTIPLIER;
            h *= QMACPATTERN_MASK_MULTIPLIER;
#endif
        } else {
            w = pat->data.pixmap.width();
            h = pat->data.pixmap.height();
            if (isBitmap)
                pat->image = qt_mac_create_imagemask(pat->data.pixmap, pat->data.pixmap.rect());
            else
                pat->image = (CGImageRef)pat->data.pixmap.macCGHandle();
        }
    } else {
        w = CGImageGetWidth(pat->image);
        h = CGImageGetHeight(pat->image);
    }

    //draw
    bool needRestore = false;
    if (CGImageIsMask(pat->image)) {
        CGContextSaveGState(c);
        CGContextSetFillColorWithColor(c, cgColorForQColor(pat->foreground, pat->pdev));
    }
    CGRect rect = CGRectMake(0, 0, w, h);
    qt_mac_drawCGImage(c, &rect, pat->image);
    if(needRestore)
        CGContextRestoreGState(c);
}

qt_mac_patternForBrush()

static const uchar* qt_mac_patternForBrush ( int  brushStyle )

static

Definition at line 1506 of file qpaintengine_mac.cpp.

Referenced by QCoreGraphicsPaintEnginePrivate::setFillBrush().

{
    Q_ASSERT(brushStyle > Qt::SolidPattern && brushStyle < Qt::LinearGradientPattern);
    static const uchar dense1_pat[] = { 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00 };
    static const uchar dense2_pat[] = { 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00, 0x88 };
    static const uchar dense3_pat[] = { 0x11, 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa };
    static const uchar dense4_pat[] = { 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55 };
    static const uchar dense5_pat[] = { 0xee, 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55 };
    static const uchar dense6_pat[] = { 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff, 0x77 };
    static const uchar dense7_pat[] = { 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff };
    static const uchar hor_pat[]    = { 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff };
    static const uchar ver_pat[]    = { 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef };
    static const uchar cross_pat[]  = { 0xef, 0xef, 0xef, 0xef, 0x00, 0xef, 0xef, 0xef };
    static const uchar fdiag_pat[]  = { 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe };
    static const uchar bdiag_pat[]  = { 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f };
    static const uchar dcross_pat[] = { 0x7e, 0xbd, 0xdb, 0xe7, 0xe7, 0xdb, 0xbd, 0x7e };
    static const uchar *const pat_tbl[] = {
        dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
        dense6_pat, dense7_pat,
        hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
    return pat_tbl[brushStyle - Qt::Dense1Pattern];
}

qt_mac_posInWindow()

QPoint qt_mac_posInWindow

(

const QWidget *

w

)

Definition at line 380 of file qwidget_mac.mm.

Referenced by make_widget_eventUPP(), and qt_mac_get_widget_rgn().

{
    QPoint ret = w->data->wrect.topLeft();
    while(w && !w->isWindow()) {
        ret += w->pos();
        w =  w->parentWidget();
    }
    return ret;
}

qt_mac_window_for()

OSWindowRef qt_mac_window_for

(

const QWidget *

)

Definition at line 484 of file qwidget_mac.mm.

Referenced by QCoreGraphicsPaintEngine::end().

{
    if (OSViewRef hiview = qt_mac_effectiveview_for(w)) {
        OSWindowRef window = qt_mac_window_for(hiview);
        if (window)
            return window;

        if (qt_isGenuineQWidget(hiview)) {
            // This is a workaround for NSToolbar. When a widget is hidden
            // by clicking the toolbar button, Cocoa reparents the widgets
            // to another window (but Qt doesn't know about it).
            // When we start showing them, it reparents back,
            // but at this point it's window is nil, but the window it's being brought
            // into (the Qt one) is for sure created.
            // This stops the hierarchy moving under our feet.
            QWidget *toplevel = w->window();
            if (toplevel != w) {
                hiview = qt_mac_nativeview_for(toplevel);
                if (OSWindowRef w = qt_mac_window_for(hiview))
                    return w;
            }

            toplevel->d_func()->createWindow_sys();
            // Reget the hiview since "create window" could potentially move the view (I guess).
            hiview = qt_mac_nativeview_for(toplevel);
            return qt_mac_window_for(hiview);
        }
    }
    return 0;
}

qt_pixmapForBrush()

QPixmap qt_pixmapForBrush	(	int	,
		bool
	)

Definition at line 99 of file qbrush.cpp.

{

    QPixmap pm;
    QString key = QLatin1Literal("$qt-brush$")
                  % HexString<uint>(brushStyle)
                  % QLatin1Char(invert ? '1' : '0');
    if (!QPixmapCache::find(key, pm)) {
        pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
                               QImage::Format_MonoLSB);
        QPixmapCache::insert(key, pm);
    }

    return pm;
}

Variable Documentation

qt_antialiasing_threshold

int qt_antialiasing_threshold

Definition at line 495 of file qapplication.cpp.

Referenced by QCoreGraphicsPaintEngine::drawTextItem().