QCoreGraphicsPaintEnginePrivate Class Reference

#include <qpaintengine_mac_p.h>

Inheritance diagram for QCoreGraphicsPaintEnginePrivate:

Public Types
enum	{ CosmeticNone, CosmeticTransformPath, CosmeticSetPenWidth }
enum	{ CGStroke =0x01, CGEOFill =0x02, CGFill =0x04 }

Public Functions
float	adjustPenWidth (float penWidth)
QPointF	devicePixelSize (CGContextRef context)
void	drawPath (uchar ops, CGMutablePathRef path=0)
float	penOffset ()
	QCoreGraphicsPaintEnginePrivate ()
void	resetClip ()
void	restoreGraphicsState ()
void	saveGraphicsState ()
void	setClip (const QRegion *rgn=0)
void	setFillBrush (const QPointF &origin=QPoint())
void	setStrokePen (const QPen &pen)
void	setTransform (const QTransform *matrix=0)
Public Functions inherited from QPaintEnginePrivate
void	drawBoxTextItem (const QPointF &p, const QTextItemInt &ti)
	QPaintEnginePrivate ()
void	setSystemTransform (const QTransform &xform)
void	setSystemViewport (const QRegion &region)
virtual void	systemStateChanged ()
void	transformSystemClip ()
virtual	~QPaintEnginePrivate ()

Public Variables
bool	complexXForm
enum QCoreGraphicsPaintEnginePrivate:: { ... }	cosmeticPen
float	cosmeticPenSize
struct {
QBrush   brush
QRegion   clip
uint   clipEnabled: 1
QPen   pen
QTransform   transform
}	current
bool	disabledSmoothFonts
CGContextRef	hd
CGAffineTransform	orig_xform
QPointF	pixelSize
CGShadingRef	shading
int	stackCount
Public Variables inherited from QPaintEnginePrivate
QWidget *	currentClipWidget
uint	hasSystemTransform: 1
uint	hasSystemViewport: 1
QPaintDevice *	pdev
QPaintEngine *	q_ptr
QRegion	systemClip
QRect	systemRect
QTransform	systemTransform
QRegion	systemViewport

Detailed Description

Definition at line 146 of file qpaintengine_mac_p.h.

Enumerations

anonymous enum

anonymous enum

Enumerator
CosmeticNone
CosmeticTransformPath
CosmeticSetPenWidth

Definition at line 172 of file qpaintengine_mac_p.h.

{ CosmeticNone, CosmeticTransformPath, CosmeticSetPenWidth } cosmeticPen;

anonymous enum

anonymous enum

Enumerator
CGStroke
CGEOFill
CGFill

Definition at line 179 of file qpaintengine_mac_p.h.

{ CGStroke=0x01, CGEOFill=0x02, CGFill=0x04 };

Constructors and Destructors

QCoreGraphicsPaintEnginePrivate()

QCoreGraphicsPaintEnginePrivate::QCoreGraphicsPaintEnginePrivate ( )

inline

Definition at line 150 of file qpaintengine_mac_p.h.

        : hd(0), shading(0), stackCount(0), complexXForm(false), disabledSmoothFonts(false)
    {
    }

Functions

adjustPenWidth()

float QCoreGraphicsPaintEnginePrivate::adjustPenWidth

(

float

penWidth

)

Definition at line 1427 of file qpaintengine_mac.cpp.

{
    Q_Q(QCoreGraphicsPaintEngine);
    float ret = penWidth;
    if (!complexXForm && !(q->state->renderHints() & QPainter::Antialiasing)) {
        if (penWidth < 2)
            ret = 1;
        else if (penWidth < 3)
            ret = 1.5;
        else
            ret = penWidth -1;
    }
    return ret;
}

devicePixelSize()

QPointF QCoreGraphicsPaintEnginePrivate::devicePixelSize

(

CGContextRef

context

)

Definition at line 1416 of file qpaintengine_mac.cpp.

{
    QPointF p1 = current.transform.inverted().map(QPointF(0, 0));
    QPointF p2 = current.transform.inverted().map(QPointF(1, 1));
    return QPointF(qAbs(p2.x() - p1.x()), qAbs(p2.y() - p1.y()));
}

drawPath()

void QCoreGraphicsPaintEnginePrivate::drawPath	(	uchar	ops,
		CGMutablePathRef	path = 0
	)

Definition at line 1668 of file qpaintengine_mac.cpp.

{
    Q_Q(QCoreGraphicsPaintEngine);
    Q_ASSERT((ops & (CGFill | CGEOFill)) != (CGFill | CGEOFill)); //can't really happen
    if((ops & (CGFill | CGEOFill))) {
        if (shading) {
            Q_ASSERT(path);
            CGContextBeginPath(hd);
            CGContextAddPath(hd, path);
            saveGraphicsState();
            if (ops & CGFill)
                CGContextClip(hd);
            else if (ops & CGEOFill)
                CGContextEOClip(hd);
            if (current.brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode) {
                CGRect boundingBox = CGPathGetBoundingBox(path);
                CGContextConcatCTM(hd,
                    CGAffineTransformMake(boundingBox.size.width, 0,
                                          0, boundingBox.size.height,
                                          boundingBox.origin.x, boundingBox.origin.y));
            }
            CGContextDrawShading(hd, shading);
            restoreGraphicsState();
            ops &= ~CGFill;
            ops &= ~CGEOFill;
        } else if (current.brush.style() == Qt::NoBrush) {
            ops &= ~CGFill;
            ops &= ~CGEOFill;
        }
    }
    if((ops & CGStroke) && current.pen.style() == Qt::NoPen)
        ops &= ~CGStroke;

    if(ops & (CGEOFill | CGFill)) {
        CGContextBeginPath(hd);
        CGContextAddPath(hd, path);
        if (ops & CGEOFill) {
            CGContextEOFillPath(hd);
        } else {
            CGContextFillPath(hd);
        }
    }

    // Avoid saving and restoring the context if we can.
    const bool needContextSave = (cosmeticPen != QCoreGraphicsPaintEnginePrivate::CosmeticNone ||
                                  !(q->state->renderHints() & QPainter::Antialiasing));
    if(ops & CGStroke) {
        if (needContextSave)
            saveGraphicsState();
        CGContextBeginPath(hd);

        // Translate a fraction of a pixel size in the y direction
        // to make sure that primitives painted at pixel borders
        // fills the right pixel. This is needed since the y xais
        // in the Quartz coordinate system is inverted compared to Qt.
        if (!(q->state->renderHints() & QPainter::Antialiasing)) {
            if (current.pen.style() == Qt::SolidLine || current.pen.width() >= 3)
                CGContextTranslateCTM(hd, double(pixelSize.x()) * 0.25, double(pixelSize.y()) * 0.25);
            else if (current.pen.style() == Qt::DotLine && QSysInfo::MacintoshVersion == QSysInfo::MV_10_3)
                ; // Do nothing.
            else
                CGContextTranslateCTM(hd, 0, double(pixelSize.y()) * 0.1);
        }

        if (cosmeticPen != QCoreGraphicsPaintEnginePrivate::CosmeticNone) {
            // If antialiazing is enabled, use the cosmetic pen size directly.
            if (q->state->renderHints() & QPainter::Antialiasing)
                CGContextSetLineWidth(hd,  cosmeticPenSize);
            else if (current.pen.widthF() <= 1)
                CGContextSetLineWidth(hd, cosmeticPenSize * 0.9f);
            else
                CGContextSetLineWidth(hd, cosmeticPenSize);
        }
        if(cosmeticPen == QCoreGraphicsPaintEnginePrivate::CosmeticTransformPath) {
            qt_mac_cg_transform_path t;
            t.transform = qt_mac_convert_transform_to_cg(current.transform);
            t.path = CGPathCreateMutable();
            CGPathApply(path, &t, qt_mac_cg_transform_path_apply); //transform the path
            setTransform(0); //unset the context transform
            CGContextSetLineWidth(hd,  cosmeticPenSize);
            CGContextAddPath(hd, t.path);
            CGPathRelease(t.path);
        } else {
            CGContextAddPath(hd, path);
        }

        CGContextStrokePath(hd);
        if (needContextSave)
            restoreGraphicsState();
    }
}

penOffset()

float QCoreGraphicsPaintEnginePrivate::penOffset

(

)

resetClip()

void QCoreGraphicsPaintEnginePrivate::resetClip

(

)

Definition at line 226 of file qpaintengine_mac.cpp.

{
    static bool inReset = false;
    if (inReset)
        return;
    inReset = true;

    CGAffineTransform old_xform = CGContextGetCTM(hd);

    //setup xforms
    CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));
    while (stackCount > 0) {
        restoreGraphicsState();
    }
    saveGraphicsState();
    inReset = false;
    //reset xforms
    CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
    CGContextConcatCTM(hd, old_xform);
}

restoreGraphicsState()

void QCoreGraphicsPaintEnginePrivate::restoreGraphicsState ( )

inline

Definition at line 209 of file qpaintengine_mac_p.h.

{
    --stackCount;
    Q_ASSERT(stackCount >= 0);
    CGContextRestoreGState(hd);
}

saveGraphicsState()

void QCoreGraphicsPaintEnginePrivate::saveGraphicsState ( )

inline

Definition at line 203 of file qpaintengine_mac_p.h.

{
    ++stackCount;
    CGContextSaveGState(hd);
}

setClip()

void QCoreGraphicsPaintEnginePrivate::setClip

(

const QRegion *

rgn = 0

)

Definition at line 1622 of file qpaintengine_mac.cpp.

{
    Q_Q(QCoreGraphicsPaintEngine);
    if(hd) {
        resetClip();
        QRegion sysClip = q->systemClip();
        if(!sysClip.isEmpty())
            qt_mac_clip_cg(hd, sysClip, &orig_xform);
        if(rgn)
            qt_mac_clip_cg(hd, *rgn, 0);
    }
}

setFillBrush()

void QCoreGraphicsPaintEnginePrivate::setFillBrush

(

const QPointF &

origin = QPoint()

)

Definition at line 1529 of file qpaintengine_mac.cpp.

{
    // pattern
    Qt::BrushStyle bs = current.brush.style();
#ifdef QT_MAC_USE_NATIVE_GRADIENTS
    if (bs == Qt::LinearGradientPattern || bs == Qt::RadialGradientPattern) {
        const QGradient *grad = static_cast<const QGradient*>(current.brush.gradient());
        if (drawGradientNatively(grad)) {
            Q_ASSERT(grad->spread() == QGradient::PadSpread);

            static const CGFloat domain[] = { 0.0f, +1.0f };
            static const CGFunctionCallbacks callbacks = { 0, qt_mac_color_gradient_function, 0 };
            CGFunctionRef fill_func = CGFunctionCreate(reinterpret_cast<void *>(&current.brush),
                    1, domain, 4, 0, &callbacks);

            CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pdev);
            if (bs == Qt::LinearGradientPattern) {
                const QLinearGradient *linearGrad = static_cast<const QLinearGradient *>(grad);
                const QPointF start(linearGrad->start());
                const QPointF stop(linearGrad->finalStop());
                shading = CGShadingCreateAxial(colorspace, CGPointMake(start.x(), start.y()),
                                               CGPointMake(stop.x(), stop.y()), fill_func, true, true);
            } else {
                Q_ASSERT(bs == Qt::RadialGradientPattern);
                const QRadialGradient *radialGrad = static_cast<const QRadialGradient *>(grad);
                QPointF center(radialGrad->center());
                QPointF focal(radialGrad->focalPoint());
                qreal radius = radialGrad->radius();
                qreal focalRadius = radialGrad->focalRadius();
                shading = CGShadingCreateRadial(colorspace, CGPointMake(focal.x(), focal.y()),
                                                focalRadius, CGPointMake(center.x(), center.y()), radius, fill_func, false, true);
            }

            CGFunctionRelease(fill_func);
        }
    } else
#endif
    if(bs != Qt::SolidPattern && bs != Qt::NoBrush
#ifndef QT_MAC_USE_NATIVE_GRADIENTS
       && (bs < Qt::LinearGradientPattern || bs > Qt::ConicalGradientPattern)
#endif
        )
    {
        QMacPattern *qpattern = new QMacPattern;
        qpattern->pdev = pdev;
        CGFloat components[4] = { 1.0, 1.0, 1.0, 1.0 };
        CGColorSpaceRef base_colorspace = 0;
        if(bs == Qt::TexturePattern) {
            qpattern->data.pixmap = current.brush.texture();
            if(qpattern->data.pixmap.isQBitmap()) {
                const QColor &col = current.brush.color();
                components[0] = qt_mac_convert_color_to_cg(col.red());
                components[1] = qt_mac_convert_color_to_cg(col.green());
                components[2] = qt_mac_convert_color_to_cg(col.blue());
                base_colorspace = QCoreGraphicsPaintEngine::macGenericColorSpace();
            }
        } else {
            qpattern->as_mask = true;

            qpattern->data.bytes = qt_mac_patternForBrush(bs);
            const QColor &col = current.brush.color();
            components[0] = qt_mac_convert_color_to_cg(col.red());
            components[1] = qt_mac_convert_color_to_cg(col.green());
            components[2] = qt_mac_convert_color_to_cg(col.blue());
            base_colorspace = QCoreGraphicsPaintEngine::macGenericColorSpace();
        }
        int width = qpattern->width(), height = qpattern->height();
        qpattern->foreground = current.brush.color();

        CGColorSpaceRef fill_colorspace = CGColorSpaceCreatePattern(base_colorspace);
        CGContextSetFillColorSpace(hd, fill_colorspace);

        CGAffineTransform xform = CGContextGetCTM(hd);
        xform = CGAffineTransformConcat(qt_mac_convert_transform_to_cg(current.brush.transform()), xform);
        xform = CGAffineTransformTranslate(xform, offset.x(), offset.y());

        CGPatternCallbacks callbks;
        callbks.version = 0;
        callbks.drawPattern = qt_mac_draw_pattern;
        callbks.releaseInfo = qt_mac_dispose_pattern;
        CGPatternRef fill_pattern = CGPatternCreate(qpattern, CGRectMake(0, 0, width, height),
                xform, width, height, kCGPatternTilingNoDistortion,
                !base_colorspace, &callbks);
        CGContextSetFillPattern(hd, fill_pattern, components);

        CGPatternRelease(fill_pattern);
        CGColorSpaceRelease(fill_colorspace);
    } else if(bs != Qt::NoBrush) {
        CGContextSetFillColorWithColor(hd, cgColorForQColor(current.brush.color(), pdev));
    }
}

setStrokePen()

void QCoreGraphicsPaintEnginePrivate::setStrokePen

(

const QPen &

pen

)

Definition at line 1443 of file qpaintengine_mac.cpp.

{
    //pencap
    CGLineCap cglinecap = kCGLineCapButt;
    if(pen.capStyle() == Qt::SquareCap)
        cglinecap = kCGLineCapSquare;
    else if(pen.capStyle() == Qt::RoundCap)
        cglinecap = kCGLineCapRound;
    CGContextSetLineCap(hd, cglinecap);
    CGContextSetLineWidth(hd, adjustPenWidth(pen.widthF()));

    //join
    CGLineJoin cglinejoin = kCGLineJoinMiter;
    if(pen.joinStyle() == Qt::BevelJoin)
        cglinejoin = kCGLineJoinBevel;
    else if(pen.joinStyle() == Qt::RoundJoin)
        cglinejoin = kCGLineJoinRound;
    CGContextSetLineJoin(hd, cglinejoin);
//    CGContextSetMiterLimit(hd, pen.miterLimit());

    //pen style
    QVector<CGFloat> linedashes;
    if(pen.style() == Qt::CustomDashLine) {
        QVector<qreal> customs = pen.dashPattern();
        for(int i = 0; i < customs.size(); ++i)
            linedashes.append(customs.at(i));
    } else if(pen.style() == Qt::DashLine) {
        linedashes.append(4);
        linedashes.append(2);
    } else if(pen.style() == Qt::DotLine) {
        linedashes.append(1);
        linedashes.append(2);
    } else if(pen.style() == Qt::DashDotLine) {
        linedashes.append(4);
        linedashes.append(2);
        linedashes.append(1);
        linedashes.append(2);
    } else if(pen.style() == Qt::DashDotDotLine) {
        linedashes.append(4);
        linedashes.append(2);
        linedashes.append(1);
        linedashes.append(2);
        linedashes.append(1);
        linedashes.append(2);
    }
    const CGFloat cglinewidth = pen.widthF() <= 0.0f ? 1.0f : float(pen.widthF());
    for(int i = 0; i < linedashes.size(); ++i) {
        linedashes[i] *= cglinewidth;
        if(cglinewidth < 3 && (cglinecap == kCGLineCapSquare || cglinecap == kCGLineCapRound)) {
            if((i%2))
                linedashes[i] += cglinewidth/2;
            else
                linedashes[i] -= cglinewidth/2;
        }
    }
    CGContextSetLineDash(hd, pen.dashOffset() * cglinewidth, linedashes.data(), linedashes.size());

    // color
    CGContextSetStrokeColorWithColor(hd, cgColorForQColor(pen.color(), pdev));
}

setTransform()

void QCoreGraphicsPaintEnginePrivate::setTransform ( const QTransform *  matrix = 0 )

inline

Definition at line 190 of file qpaintengine_mac_p.h.

    {
        CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
        CGAffineTransform xform = orig_xform;
        if(matrix) {
            extern CGAffineTransform qt_mac_convert_transform_to_cg(const QTransform &);
            xform = CGAffineTransformConcat(qt_mac_convert_transform_to_cg(*matrix), xform);
        }
        CGContextConcatCTM(hd, xform);
        CGContextSetTextMatrix(hd, xform);
    }

Properties

brush

QBrush QCoreGraphicsPaintEnginePrivate::brush

Definition at line 157 of file qpaintengine_mac_p.h.

clip

QRegion QCoreGraphicsPaintEnginePrivate::clip

Definition at line 159 of file qpaintengine_mac_p.h.

clipEnabled

uint QCoreGraphicsPaintEnginePrivate::clipEnabled

Definition at line 158 of file qpaintengine_mac_p.h.

complexXForm

bool QCoreGraphicsPaintEnginePrivate::complexXForm

Definition at line 170 of file qpaintengine_mac_p.h.

cosmeticPen

enum { ... } QCoreGraphicsPaintEnginePrivate::cosmeticPen

cosmeticPenSize

float QCoreGraphicsPaintEnginePrivate::cosmeticPenSize

Definition at line 176 of file qpaintengine_mac_p.h.

current

struct { ... } QCoreGraphicsPaintEnginePrivate::current

disabledSmoothFonts

bool QCoreGraphicsPaintEnginePrivate::disabledSmoothFonts

Definition at line 171 of file qpaintengine_mac_p.h.

hd

CGContextRef QCoreGraphicsPaintEnginePrivate::hd

Definition at line 167 of file qpaintengine_mac_p.h.

orig_xform

CGAffineTransform QCoreGraphicsPaintEnginePrivate::orig_xform

Definition at line 164 of file qpaintengine_mac_p.h.

pen

QPen QCoreGraphicsPaintEnginePrivate::pen

Definition at line 156 of file qpaintengine_mac_p.h.

pixelSize

QPointF QCoreGraphicsPaintEnginePrivate::pixelSize

Definition at line 175 of file qpaintengine_mac_p.h.

shading

CGShadingRef QCoreGraphicsPaintEnginePrivate::shading

Definition at line 168 of file qpaintengine_mac_p.h.

stackCount

int QCoreGraphicsPaintEnginePrivate::stackCount

Definition at line 169 of file qpaintengine_mac_p.h.

transform

QTransform QCoreGraphicsPaintEnginePrivate::transform

Definition at line 160 of file qpaintengine_mac_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/painting/qpaintengine_mac_p.h
• /src/gui/painting/qpaintengine_mac.cpp