qpaintengine_vg.cpp File Reference

#include "qpaintengine_vg_p.h"
#include "qpixmapdata_vg_p.h"
#include "qpixmapfilter_vg_p.h"
#include "qvgcompositionhelper_p.h"
#include "qvgimagepool_p.h"
#include "qvgfontglyphcache_p.h"
#include <QtGui/private/qeglcontext_p.h>
#include "qwindowsurface_vgegl_p.h"
#include <QtCore/qvarlengtharray.h>
#include <QtGui/private/qdrawhelper_p.h>
#include <QtGui/private/qtextengine_p.h>
#include <QtGui/private/qfontengine_p.h>
#include <QtGui/private/qpainterpath_p.h>
#include <QtGui/private/qstatictext_p.h>
#include <QtGui/QApplication>
#include <QtGui/QDesktopWidget>
#include <QtCore/qmath.h>
#include <QDebug>
#include <QSet>
#include "qpaintengine_vg.moc"

Go to the source code of this file.

Classes
class	QVGFontEngineCleaner
class	QVGPaintEnginePrivate

Functions
static bool	clipTransformIsSimple (const QTransform &transform)
static QImage	colorizeBitmap (const QImage &image, const QColor &color)
static void	drawImageTiled (QVGPaintEnginePrivate *d, const QRectF &r, const QImage &image, const QRectF &sr=QRectF())
static void	drawVGImage (QVGPaintEnginePrivate *d, const QRectF &r, VGImage vgImg, const QSize &imageSize, const QRectF &sr)
static void	drawVGImage (QVGPaintEnginePrivate *d, const QPointF &pos, VGImage vgImg)
static void	fillBackgroundRect (const QRect &rect, QVGPaintEnginePrivate *d)
Q_GUI_EXPORT QImage	qt_imageForBrush (int style, bool invert)
Q_GUI_EXPORT QPainterPath	qt_painterPathFromVectorPath (const QVectorPath &path)
Q_GUI_EXPORT bool	qt_scaleForTransform (const QTransform &transform, qreal *scale)
void	qt_vg_drawVGImage (QPainter *painter, const QPointF &pos, VGImage vgImg)
void	qt_vg_drawVGImageStencil (QPainter *painter, const QPointF &pos, VGImage vgImg, const QBrush &brush)
VGImageFormat	qt_vg_image_to_vg_format (QImage::Format format)
static bool	qt_vg_pathToRect (const QPainterPath &path, QRectF *rect)
static VGImage	toVGImage (const QImage &image, Qt::ImageConversionFlags flags=Qt::AutoColor)
static VGImage	toVGImageSubRect (const QImage &image, const QRect &sr, Qt::ImageConversionFlags flags=Qt::AutoColor)
static VGImage	toVGImageWithOpacity (const QImage &image, qreal opacity)
static VGImage	toVGImageWithOpacitySubRect (const QImage &image, qreal opacity, const QRect &sr)

Variables
static const qreal	aliasedCoordinateDelta = 0.5 - 0.015625

Function Documentation

clipTransformIsSimple()

static bool clipTransformIsSimple ( const QTransform &  transform )

inlinestatic

Definition at line 1618 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::clip(), and QVGPaintEngine::fillRect().

{
    QTransform::TransformationType type = transform.type();
    if (type == QTransform::TxNone || type == QTransform::TxTranslate)
        return true;
    if (type == QTransform::TxRotate) {
        // Check for 0, 90, 180, and 270 degree rotations.
        // (0 might happen after 4 rotations of 90 degrees).
        qreal m11 = transform.m11();
        qreal m12 = transform.m12();
        qreal m21 = transform.m21();
        qreal m22 = transform.m22();
        if (m11 == 0.0f && m22 == 0.0f) {
            if (m12 == 1.0f && m21 == -1.0f)
                return true;    // 90 degrees.
            else if (m12 == -1.0f && m21 == 1.0f)
                return true;    // 270 degrees.
        } else if (m12 == 0.0f && m21 == 0.0f) {
            if (m11 == -1.0f && m22 == -1.0f)
                return true;    // 180 degrees.
            else if (m11 == 1.0f && m22 == 1.0f)
                return true;    // 0 degrees.
        }
    }
    return false;
}

colorizeBitmap()

static QImage colorizeBitmap ( const QImage &  image, const QColor &  color  )

static

Definition at line 1024 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEnginePrivate::setBrush().

{
    QImage sourceImage = image.convertToFormat(QImage::Format_MonoLSB);
    QImage dest = QImage(sourceImage.size(), QImage::Format_ARGB32_Premultiplied);

    QRgb fg = PREMUL(color.rgba());
    QRgb bg = 0;

    int height = sourceImage.height();
    int width = sourceImage.width();
    for (int y=0; y<height; ++y) {
        const uchar *source = sourceImage.constScanLine(y);
        QRgb *target = reinterpret_cast<QRgb *>(dest.scanLine(y));
        for (int x=0; x < width; ++x)
            target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
    }
    return dest;
}

drawImageTiled()

static void drawImageTiled ( QVGPaintEnginePrivate *  d, const QRectF &  r, const QImage &  image, const QRectF &  sr = QRectF()  )

static

Definition at line 3181 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawImage().

{
    const int minTileSize = 16;
    int tileWidth = 512;
    int tileHeight = tileWidth;

    VGImageFormat tileFormat = qt_vg_image_to_vg_format(image.format());
    VGImage tile = VG_INVALID_HANDLE;
    QVGImagePool *pool = QVGImagePool::instance();
    while (tile == VG_INVALID_HANDLE && tileWidth >= minTileSize) {
        tile = pool->createPermanentImage(tileFormat, tileWidth, tileHeight,
            VG_IMAGE_QUALITY_FASTER);
        if (tile == VG_INVALID_HANDLE) {
            tileWidth /= 2;
            tileHeight /= 2;
        }
    }
    if (tile == VG_INVALID_HANDLE) {
        qWarning("drawImageTiled: Failed to create %dx%d tile, giving up", tileWidth, tileHeight);
        return;
    }

    VGfloat opacityMatrix[20] = {
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, d->opacity,
        0.0f, 0.0f, 0.0f, 0.0f
    };
    VGImage tileWithOpacity = VG_INVALID_HANDLE;
    if (d->opacity != 1) {
        tileWithOpacity = pool->createPermanentImage(VG_sARGB_8888_PRE,
            tileWidth, tileHeight, VG_IMAGE_QUALITY_NONANTIALIASED);
        if (tileWithOpacity == VG_INVALID_HANDLE)
            qWarning("drawImageTiled: Failed to create extra tile, ignoring opacity");
    }

    QRect sourceRect = sr.toRect();
    if (sourceRect.isNull())
        sourceRect = QRect(0, 0, image.width(), image.height());

    VGfloat scaleX = r.width() / sourceRect.width();
    VGfloat scaleY = r.height() / sourceRect.height();

    d->setImageOptions();
    VGImageQuality oldImageQuality = d->imageQuality;
    VGRenderingQuality oldRenderingQuality = d->renderingQuality;
    d->setImageQuality(VG_IMAGE_QUALITY_NONANTIALIASED);
    d->setRenderingQuality(VG_RENDERING_QUALITY_NONANTIALIASED);

    for (int y = sourceRect.y(); y < sourceRect.height(); y += tileHeight) {
        int h = qMin(tileHeight, sourceRect.height() - y);
        if (h < 1)
            break;
        for (int x = sourceRect.x(); x < sourceRect.width(); x += tileWidth) {
            int w = qMin(tileWidth, sourceRect.width() - x);
            if (w < 1)
                break;

            int bytesPerPixel = image.depth() / 8;
            const uchar *sptr = image.constBits() + x * bytesPerPixel + y * image.bytesPerLine();
            vgImageSubData(tile, sptr, image.bytesPerLine(), tileFormat, 0, 0, w, h);

            QTransform transform(d->imageTransform);
            transform.translate(r.x() + x, r.y() + y);
            transform.scale(scaleX, scaleY);
            d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);

            VGImage actualTile = tile;
            if (tileWithOpacity != VG_INVALID_HANDLE) {
                vgColorMatrix(tileWithOpacity, actualTile, opacityMatrix);
                if (w < tileWidth || h < tileHeight)
                    actualTile = vgChildImage(tileWithOpacity, 0, 0, w, h);
                else
                    actualTile = tileWithOpacity;
            } else if (w < tileWidth || h < tileHeight) {
                actualTile = vgChildImage(tile, 0, 0, w, h);
            }
            vgDrawImage(actualTile);

            if (actualTile != tile && actualTile != tileWithOpacity)
                vgDestroyImage(actualTile);
        }
    }

    vgDestroyImage(tile);
    if (tileWithOpacity != VG_INVALID_HANDLE)
        vgDestroyImage(tileWithOpacity);

    d->setImageQuality(oldImageQuality);
    d->setRenderingQuality(oldRenderingQuality);
}

drawVGImage() [1/2]

static void drawVGImage ( QVGPaintEnginePrivate *  d, const QRectF &  r, VGImage  vgImg, const QSize &  imageSize, const QRectF &  sr  )

static

Definition at line 3134 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawImage(), QVGPaintEngine::drawPixmap(), and qt_vg_drawVGImage().

{
    if (vgImg == VG_INVALID_HANDLE)
        return;
    VGImage child = VG_INVALID_HANDLE;

    if (sr.topLeft().isNull() && sr.size() == imageSize) {
        child = vgImg;
    } else {
        QRect src = sr.toRect();
#if !defined(QT_SHIVAVG)
        child = vgChildImage(vgImg, src.x(), src.y(), src.width(), src.height());
#else
        child = vgImg;  // XXX: ShivaVG doesn't have vgChildImage().
#endif
    }

    QTransform transform(d->imageTransform);
    VGfloat scaleX = sr.width() == 0.0f ? 0.0f : r.width() / sr.width();
    VGfloat scaleY = sr.height() == 0.0f ? 0.0f : r.height() / sr.height();
    transform.translate(r.x(), r.y());
    transform.scale(scaleX, scaleY);
    d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);

    d->setImageOptions();
    vgDrawImage(child);

    if(child != vgImg)
        vgDestroyImage(child);
}

drawVGImage() [2/2]

static void drawVGImage ( QVGPaintEnginePrivate *  d, const QPointF &  pos, VGImage  vgImg  )

static

Definition at line 3167 of file qpaintengine_vg.cpp.

{
    if (vgImg == VG_INVALID_HANDLE)
        return;

    QTransform transform(d->imageTransform);
    transform.translate(pos.x(), pos.y());
    d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);

    d->setImageOptions();
    vgDrawImage(vgImg);
}

fillBackgroundRect()

static void fillBackgroundRect ( const QRect &  rect, QVGPaintEnginePrivate *  d  )

static

Definition at line 4069 of file qpaintengine_vg.cpp.

Referenced by QVGCompositionHelper::fillBackground().

{
    VGfloat coords[8];
    coords[0] = rect.x();
    coords[1] = rect.y();
    coords[2] = rect.x() + rect.width();
    coords[3] = coords[1];
    coords[4] = coords[2];
    coords[5] = rect.y() + rect.height();
    coords[6] = coords[0];
    coords[7] = coords[5];
#if !defined(QVG_NO_MODIFY_PATH)
    vgModifyPathCoords(d->rectPath, 0, 4, coords);
    vgDrawPath(d->rectPath, VG_FILL_PATH);
#else
    Q_UNUSED(d);
    VGPath rectPath = vgCreatePath
            (VG_PATH_FORMAT_STANDARD,
             VG_PATH_DATATYPE_F,
             1.0f, // scale
             0.0f, // bias
             5,    // segmentCapacityHint
             8,    // coordCapacityHint
             VG_PATH_CAPABILITY_ALL);
    static VGubyte const segments[5] = {
        VG_MOVE_TO_ABS,
        VG_LINE_TO_ABS,
        VG_LINE_TO_ABS,
        VG_LINE_TO_ABS,
        VG_CLOSE_PATH
    };
    vgAppendPathData(rectPath, 5, segments, coords);
    vgDrawPath(rectPath, VG_FILL_PATH);
    vgDestroyPath(rectPath);
#endif
}

qt_imageForBrush()

Q_GUI_EXPORT QImage qt_imageForBrush	(	int	style,
		bool	invert
	)

Definition at line 167 of file qbrush.cpp.

Referenced by QVGPaintEnginePrivate::roundedRectPath(), and QVGPaintEnginePrivate::setBrush().

{
    return qt_brushPatternImageCache()->getImage(brushStyle, invert);
}

qt_painterPathFromVectorPath()

Q_GUI_EXPORT QPainterPath qt_painterPathFromVectorPath

(

const QVectorPath &

path

)

Definition at line 1033 of file qpaintengineex.cpp.

Referenced by QVGPaintEngine::draw(), and QVGPaintEngine::fill().

{
    const qreal *points = path.points();
    const QPainterPath::ElementType *types = path.elements();

    QPainterPath p;
    if (types) {
        int id = 0;
        for (int i=0; i<path.elementCount(); ++i) {
            switch(types[i]) {
            case QPainterPath::MoveToElement:
                p.moveTo(QPointF(points[id], points[id+1]));
                id+=2;
                break;
            case QPainterPath::LineToElement:
                p.lineTo(QPointF(points[id], points[id+1]));
                id+=2;
                break;
            case QPainterPath::CurveToElement: {
                QPointF p1(points[id], points[id+1]);
                QPointF p2(points[id+2], points[id+3]);
                QPointF p3(points[id+4], points[id+5]);
                p.cubicTo(p1, p2, p3);
                id+=6;
                break;
            }
            case QPainterPath::CurveToDataElement:
                ;
                break;
            }
        }
    } else {
        p.moveTo(QPointF(points[0], points[1]));
        int id = 2;
        for (int i=1; i<path.elementCount(); ++i) {
            p.lineTo(QPointF(points[id], points[id+1]));
            id+=2;
        }
    }
    if (path.hints() & QVectorPath::WindingFill)
        p.setFillRule(Qt::WindingFill);

    return p;
}

qt_scaleForTransform()

Q_GUI_EXPORT bool qt_scaleForTransform	(	const QTransform &	transform,
		qreal *	scale
	)

Definition at line 2407 of file qtransform.cpp.

Referenced by cubicTo_clipped(), lineTo_clipped(), QVGPaintEnginePrivate::setTransform(), and QVGPaintEnginePrivate::updateTransform().

{
    const QTransform::TransformationType type = transform.type();
    if (type <= QTransform::TxTranslate) {
        if (scale)
            *scale = 1;
        return true;
    } else if (type == QTransform::TxScale) {
        const qreal xScale = qAbs(transform.m11());
        const qreal yScale = qAbs(transform.m22());
        if (scale)
            *scale = qMax(xScale, yScale);
        return qFuzzyCompare(xScale, yScale);
    }

    const qreal xScale = transform.m11() * transform.m11()
                         + transform.m21() * transform.m21();
    const qreal yScale = transform.m12() * transform.m12()
                         + transform.m22() * transform.m22();
    if (scale)
        *scale = qSqrt(qMax(xScale, yScale));
    return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
}

qt_vg_drawVGImage()

void qt_vg_drawVGImage	(	QPainter *	painter,
		const QPointF &	pos,
		VGImage	vgImg
	)

Definition at line 3278 of file qpaintengine_vg.cpp.

Referenced by QVGPixmapConvolutionFilter::draw(), QVGPixmapColorizeFilter::draw(), QVGPixmapBlurFilter::draw(), and QVGPixmapConvolutionFilter::~QVGPixmapConvolutionFilter().

{
    QVGPaintEngine *engine =
        static_cast<QVGPaintEngine *>(painter->paintEngine());
    drawVGImage(engine->vgPrivate(), pos, vgImg);
}

qt_vg_drawVGImageStencil()

void qt_vg_drawVGImageStencil	(	QPainter *	painter,
		const QPointF &	pos,
		VGImage	vgImg,
		const QBrush &	brush
	)

Definition at line 3287 of file qpaintengine_vg.cpp.

Referenced by QVGPixmapDropShadowFilter::draw(), qt_vg_drawVGImage(), and QVGPixmapConvolutionFilter::~QVGPixmapConvolutionFilter().

{
    QVGPaintEngine *engine =
        static_cast<QVGPaintEngine *>(painter->paintEngine());

    QVGPaintEnginePrivate *d = engine->vgPrivate();

    QTransform transform(d->imageTransform);
    transform.translate(pos.x(), pos.y());
    d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);

    d->ensureBrush(brush);
    d->setImageMode(VG_DRAW_IMAGE_STENCIL);
    vgDrawImage(vgImg);
}

qt_vg_image_to_vg_format()

VGImageFormat qt_vg_image_to_vg_format

(

QImage::Format

format

)

Definition at line 4239 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::canVgWritePixels(), QVGPaintEngine::drawImage(), drawImageTiled(), QVGPixmapData::ensureReadback(), qt_vg_config_to_vg_format(), and QVGPixmapData::toVGImage().

{
    switch (format) {
        case QImage::Format_MonoLSB:
            return VG_BW_1;
        case QImage::Format_Indexed8:
            return VG_sL_8;
        case QImage::Format_ARGB32_Premultiplied:
            return VG_sARGB_8888_PRE;
        case QImage::Format_RGB32:
            return VG_sXRGB_8888;
        case QImage::Format_ARGB32:
            return VG_sARGB_8888;
        case QImage::Format_RGB16:
            return VG_sRGB_565;
        case QImage::Format_ARGB4444_Premultiplied:
            return VG_sARGB_4444;
        default:
            break;
    }
    return VG_sARGB_8888;   // XXX
}

qt_vg_pathToRect()

static bool qt_vg_pathToRect ( const QPainterPath &  path, QRectF *  rect  )

static

Definition at line 2077 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::clip().

{
    if (path.elementCount() != 5)
        return false;

    const bool mightBeRect = path.elementAt(0).isMoveTo()
        && path.elementAt(1).isLineTo()
        && path.elementAt(2).isLineTo()
        && path.elementAt(3).isLineTo()
        && path.elementAt(4).isLineTo();

    if (!mightBeRect)
        return false;

    const qreal x1 = path.elementAt(0).x;
    const qreal y1 = path.elementAt(0).y;

    const qreal x2 = path.elementAt(1).x;
    const qreal y2 = path.elementAt(2).y;

    if (path.elementAt(1).y != y1)
        return false;

    if (path.elementAt(2).x != x2)
        return false;

    if (path.elementAt(3).x != x1 || path.elementAt(3).y != y2)
        return false;

    if (path.elementAt(4).x != x1 || path.elementAt(4).y != y1)
        return false;

    if (rect)
        *rect = QRectF(QPointF(x1, y1), QPointF(x2, y2));

    return true;
}

toVGImage()

static VGImage toVGImage ( const QImage &  image, Qt::ImageConversionFlags  flags = Qt::AutoColor  )

static

Definition at line 1044 of file qpaintengine_vg.cpp.

Referenced by colorizeBitmap(), QVGPaintEngine::drawImage(), and QVGPaintEnginePrivate::setBrush().

{
    QImage img(image);

    VGImageFormat format;
    switch (img.format()) {
    case QImage::Format_Mono:
        img = image.convertToFormat(QImage::Format_MonoLSB, flags);
        img.invertPixels();
        format = VG_BW_1;
        break;
    case QImage::Format_MonoLSB:
        img.invertPixels();
        format = VG_BW_1;
        break;
    case QImage::Format_RGB32:
        format = VG_sXRGB_8888;
        break;
    case QImage::Format_ARGB32:
        format = VG_sARGB_8888;
        break;
    case QImage::Format_ARGB32_Premultiplied:
        format = VG_sARGB_8888_PRE;
        break;
    case QImage::Format_RGB16:
        format = VG_sRGB_565;
        break;
    default:
        // Convert everything else into ARGB32_Premultiplied.
        img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
        format = VG_sARGB_8888_PRE;
        break;
    }

    const uchar *pixels = img.constBits();

    VGImage vgImg = QVGImagePool::instance()->createPermanentImage
        (format, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
    vgImageSubData
        (vgImg, pixels, img.bytesPerLine(), format, 0, 0,
         img.width(), img.height());

    return vgImg;
}

toVGImageSubRect()

static VGImage toVGImageSubRect ( const QImage &  image, const QRect &  sr, Qt::ImageConversionFlags  flags = Qt::AutoColor  )

static

Definition at line 1090 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawImage(), and toVGImage().

{
    QImage img(image);

    VGImageFormat format;
    int bpp = 4;

    switch (img.format()) {
    case QImage::Format_Mono:
    case QImage::Format_MonoLSB:
        return VG_INVALID_HANDLE;
    case QImage::Format_RGB32:
        format = VG_sXRGB_8888;
        break;
    case QImage::Format_ARGB32:
        format = VG_sARGB_8888;
        break;
    case QImage::Format_ARGB32_Premultiplied:
        format = VG_sARGB_8888_PRE;
        break;
    case QImage::Format_RGB16:
        format = VG_sRGB_565;
        bpp = 2;
        break;
    default:
        // Convert everything else into ARGB32_Premultiplied.
        img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
        format = VG_sARGB_8888_PRE;
        break;
    }

    const uchar *pixels = img.constBits() + bpp * sr.x() +
                          img.bytesPerLine() * sr.y();

    VGImage vgImg = QVGImagePool::instance()->createPermanentImage
        (format, sr.width(), sr.height(), VG_IMAGE_QUALITY_FASTER);
    vgImageSubData
        (vgImg, pixels, img.bytesPerLine(), format, 0, 0,
         sr.width(), sr.height());

    return vgImg;
}

toVGImageWithOpacity()

static VGImage toVGImageWithOpacity ( const QImage &  image, qreal  opacity  )

static

Definition at line 1134 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawImage(), and QVGPaintEnginePrivate::setBrush().

{
    QImage img(image.size(), QImage::Format_ARGB32_Premultiplied);
    img.fill(0);
    QPainter painter;
    painter.begin(&img);
    painter.setOpacity(opacity);
    painter.drawImage(0, 0, image);
    painter.end();

    const uchar *pixels = img.constBits();

    VGImage vgImg = QVGImagePool::instance()->createPermanentImage
        (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
    vgImageSubData
        (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
         img.width(), img.height());

    return vgImg;
}

toVGImageWithOpacitySubRect()

static VGImage toVGImageWithOpacitySubRect ( const QImage &  image, qreal  opacity, const QRect &  sr  )

static

Definition at line 1156 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawImage(), and toVGImageWithOpacity().

{
    QImage img(sr.size(), QImage::Format_ARGB32_Premultiplied);
    img.fill(0);
    QPainter painter;
    painter.begin(&img);
    painter.setOpacity(opacity);
    painter.drawImage(QPoint(0, 0), image, sr);
    painter.end();

    const uchar *pixels = img.constBits();

    VGImage vgImg = QVGImagePool::instance()->createPermanentImage
        (VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
    vgImageSubData
        (vgImg, pixels, img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0,
         img.width(), img.height());

    return vgImg;
}

Variable Documentation

aliasedCoordinateDelta

const qreal aliasedCoordinateDelta = 0.5 - 0.015625

static

Definition at line 76 of file qpaintengine_vg.cpp.

Referenced by QVGPaintEngine::drawCachedGlyphs(), and QVGPaintEnginePrivate::ensurePathTransform().