FCL/sf/mw/qt: comparison src/openvg/qpaintengine

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenVG module of the Qt Toolkit.
 **
 QTransform imageTransform; // Calculated VG image transformation.
 bool pathTransformSet;  // True if path transform set in the VG context.
 bool maskValid;         // True if vgMask() contains valid data.
 bool maskIsSet;         // True if mask would be fully set if it was valid.
+bool scissorMask;       // True if scissor is used in place of the mask.
 bool rawVG;             // True if processing a raw VG escape.
 QRect maskRect;         // Rectangle version of mask if it is simple.
 QTransform penTransform;   // Transform for the pen.
 VGMatrixMode matrixMode;    // Last matrix mode that was set.
 VGImageMode imageMode;      // Last image mode that was set.
 QRegion scissorRegion;  // Currently active scissor region.
 bool scissorActive;     // True if scissor region is active.
+bool scissorDirty;      // True if scissor is dirty after native painting.
 QPaintEngine::DirtyFlags dirty;
 QColor clearColor;      // Last clear color that was set.
 VGfloat clearOpacity;   // Opacity during the last clear.
 pathTransformSet = false;
 penScale = 1.0;
 maskValid = false;
 maskIsSet = false;
+scissorMask = false;
 rawVG = false;
 scissorActive = false;
+scissorDirty = false;
 dirty = 0;
 clearOpacity = 1.0f;
 //      3. Flip the co-ordinate system upside down.
 QTransform viewport(1.0f, 0.0f, 0.0f,
 0.0f, -1.0f, 0.0f,
 0.5f, devh + 0.5f, 1.0f);
-// The image transform is always the full transformation,
+// Compute the path transform and determine if it is projective.
-// because it can be projective.
+pathTransform = transform * viewport;
-imageTransform = transform * viewport;
+bool projective = (pathTransform.m13() != 0.0f ||
+pathTransform.m23() != 0.0f ||
-// Determine if the transformation is projective.
+pathTransform.m33() != 1.0f);
-bool projective = (imageTransform.m13() != 0.0f ||
-imageTransform.m23() != 0.0f ||
-imageTransform.m33() != 1.0f);
 if (projective) {
 // The engine cannot do projective path transforms for us,
 // so we will have to convert the co-ordinates ourselves.
 // Change the matrix to just the viewport transformation.
 pathTransform = viewport;
 simpleTransform = false;
 } else {
-pathTransform = imageTransform;
 simpleTransform = true;
 }
 pathTransformSet = false;
+// The image transform is always the full transformation,
+// because it can be projective.  It also does not need the
+// (0.5, -0.5) translation because vgDrawImage() implicitly
+// adds 0.5 to each co-ordinate.
+QTransform viewport2(1.0f, 0.0f, 0.0f,
+0.0f, -1.0f, 0.0f,
+0.0f, devh + 1, 1.0f);
+imageTransform = transform * viewport2;
 // Calculate the scaling factor to use for turning cosmetic pens
 // into ordinary non-cosmetic pens.
 qt_scaleForTransform(transform, &penScale);
 }
 for (int x=0; x < width; ++x)
 target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
 }
 return dest;
 }
+// defined in qpixmapdata_vg.cpp.
+const uchar *qt_vg_imageBits(const QImage& image);
 static VGImage toVGImage
 (const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor)
 {
 QImage img(image);
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 (vgImg, pixels, img.bytesPerLine(), format, 0, 0,
 img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied, flags);
 format = VG_sARGB_8888_PRE;
 break;
 }
-const uchar *pixels = img.bits() + bpp * sr.x() +
+const uchar *pixels = qt_vg_imageBits(img) + bpp * sr.x() +
 img.bytesPerLine() * sr.y();
 VGImage vgImg = QVGImagePool::instance()->createPermanentImage
 (format, sr.width(), sr.height(), VG_IMAGE_QUALITY_FASTER);
 vgImageSubData
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(0, 0, image);
 painter.end();
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 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,
 painter.begin(&img);
 painter.setOpacity(opacity);
 painter.drawImage(QPoint(0, 0), image, sr);
 painter.end();
-const uchar *pixels = img.bits();
+const uchar *pixels = qt_vg_imageBits(img);
 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,
 // rectangle-based clipping with vgMask().  Simple transforms most
 // often result from origin translations.
 static inline bool clipTransformIsSimple(const QTransform& transform)
 {
 QTransform::TransformationType type = transform.type();
-return (type == QTransform::TxNone || type == QTransform::TxTranslate);
+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;
 }
 #if defined(QVG_SCISSOR_CLIP)
 void QVGPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 d->dirty |= QPaintEngine::DirtyClipRegion;
 if (op == Qt::NoClip) {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 return;
 }
-#if defined(QVG_NO_RENDER_TO_MASK)
 // We don't have vgRenderToMask(), so handle simple QRectF's only.
 if (path.shape() == QVectorPath::RectangleHint &&
 path.elementCount() == 4 && clipTransformIsSimple(d->transform)) {
 // Clipping region that resulted from QPainter::setClipRect(QRectF).
 // Convert it into a QRect and apply.
 const qreal *points = path.points();
 QRectF rect(points[0], points[1], points[2] - points[0],
 points[5] - points[1]);
 clip(rect.toRect(), op);
-}
+return;
-#else
+}
+#if !defined(QVG_NO_RENDER_TO_MASK)
 QPaintDevice *pdev = paintDevice();
 int width = pdev->width();
 int height = pdev->height();
 if (op == Qt::ReplaceClip) {
 vgDestroyPath(vgpath);
 vgSeti(VG_MASKING, VG_TRUE);
 d->maskValid = true;
 d->maskIsSet = false;
+d->scissorMask = false;
 #endif
 }
 void QVGPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
 {
 switch (op) {
 case Qt::NoClip:
 {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 }
 break;
 // same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 // Special case: if the intersection of the system
 // clip and "r" is a single rectangle, then use the
 // scissor for clipping.  We try to avoid allocating a
 } else {
 clip = clip.intersect(r);
 if (clip.rectCount() != 1) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 d->modifyMask(this, VG_FILL_MASK, r);
 break;
 }
 clipRect = clip.boundingRect();
 }
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = true;
 d->maskRect = clipRect;
 vgSeti(VG_MASKING, VG_FALSE);
 updateScissor();
 }
 }
 break;
 case Qt::IntersectClip:
 {
 QRect r = d->transform.mapRect(rect);
-if (d->maskIsSet && isDefaultClipRect(r)) {
+if (!d->maskValid) {
+// Mask has not been used yet, so intersect with
+// the previous scissor-based region in maskRect.
+if (d->scissorMask)
+r = r.intersect(d->maskRect);
+if (isDefaultClipRect(r)) {
+// The clip is the full window, so turn off clipping.
+d->maskIsSet = true;
+d->maskRect = QRect();
+} else {
+// Activate the scissor on a smaller maskRect.
+d->maskIsSet = false;
+d->maskRect = r;
+}
+d->scissorMask = true;
+updateScissor();
+} else if (d->maskIsSet && isDefaultClipRect(r)) {
 // Intersecting a full-window clip with a full-window
 // region is the same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 d->modifyMask(this, VG_INTERSECT_MASK, r);
 }
 }
 switch (op) {
 case Qt::NoClip:
 {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 }
 break;
 // same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 // Special case: if the intersection of the system
 // clip and the region is a single rectangle, then
 // use the scissor for clipping.
 else
 clip = clip.intersect(r);
 if (clip.rectCount() == 1) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = true;
 d->maskRect = clip.boundingRect();
 vgSeti(VG_MASKING, VG_FALSE);
 updateScissor();
 } else {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 d->modifyMask(this, VG_FILL_MASK, r);
 }
 }
 }
 // region is the same as turning off clipping.
 if (d->maskValid)
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 } else {
 d->modifyMask(this, VG_INTERSECT_MASK, r);
 }
 }
 d->dirty |= QPaintEngine::DirtyClipRegion;
 if (op == Qt::NoClip) {
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 vgSeti(VG_MASKING, VG_FALSE);
 return;
 }
 vgDestroyPath(vgpath);
 vgSeti(VG_MASKING, VG_TRUE);
 d->maskValid = true;
 d->maskIsSet = false;
+d->scissorMask = false;
 #else
 QPaintEngineEx::clip(path, op);
 #endif
 }
 void QVGPaintEnginePrivate::ensureMask
 (QVGPaintEngine *engine, int width, int height)
 {
+scissorMask = false;
 if (maskIsSet) {
 vgMask(VG_INVALID_HANDLE, VG_FILL_MASK, 0, 0, width, height);
 maskRect = QRect();
 } else {
 vgMask(VG_INVALID_HANDLE, VG_CLEAR_MASK, 0, 0, width, height);
 }
 vgSeti(VG_MASKING, VG_TRUE);
 maskValid = true;
 maskIsSet = false;
+scissorMask = false;
 }
 void QVGPaintEnginePrivate::modifyMask
 (QVGPaintEngine *engine, VGMaskOperation op, const QRect& rect)
 {
 }
 vgSeti(VG_MASKING, VG_TRUE);
 maskValid = true;
 maskIsSet = false;
+scissorMask = false;
 }
 #endif // !QVG_SCISSOR_CLIP
 void QVGPaintEngine::updateScissor()
 if (isDefaultClipRegion(region)) {
 // The scissor region is the entire drawing surface,
 // so there is no point doing any scissoring.
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 } else
 #endif
 {
 #if !defined(QVG_SCISSOR_CLIP)
 // Combine the system clip with the simple mask rectangle.
-if (!d->maskRect.isNull()) {
+if (d->scissorMask) {
 if (region.isEmpty())
 region = d->maskRect;
 else
 region = region.intersect(d->maskRect);
 if (isDefaultClipRegion(region)) {
 // The scissor region is the entire drawing surface,
 // so there is no point doing any scissoring.
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 } else
 #endif
 // Disable the scissor completely if the system clip is empty.
 if (region.isEmpty()) {
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 return;
 }
 }
-if (d->scissorActive && region == d->scissorRegion)
+if (d->scissorActive && region == d->scissorRegion && !d->scissorDirty)
 return;
 QVector<QRect> rects = region.rects();
 int count = rects.count();
 if (count > d->maxScissorRects)
 params[i * 4 + 3] = rects[i].height();
 }
 vgSetiv(VG_SCISSOR_RECTS, count * 4, params.data());
 vgSeti(VG_SCISSORING, VG_TRUE);
+d->scissorDirty = false;
 d->scissorActive = true;
 d->scissorRegion = region;
 }
 QRegion QVGPaintEngine::defaultClipRegion()
 d->dirty |= QPaintEngine::DirtyClipEnabled;
 if (s->clipEnabled && s->clipOperation != Qt::NoClip) {
 // Replay the entire clip stack to put the mask into the right state.
 d->maskValid = false;
 d->maskIsSet = true;
+d->scissorMask = false;
 d->maskRect = QRect();
 s->clipRegion = defaultClipRegion();
 d->replayClipOperations();
 d->transform = s->transform();
 d->updateTransform(paintDevice());
 } else {
 vgSeti(VG_MASKING, VG_FALSE);
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 }
 #endif
 }
 bool QVGPaintEngine::clearRect(const QRectF &rect, const QColor &color)
 {
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
 if (!s->clipEnabled || s->clipOperation == Qt::NoClip) {
-// The transform will either be identity or a simple translation,
+QRect r = d->transform.mapRect(rect).toRect();
-// so do a simpler version of "r = d->transform.map(rect).toRect()".
-QRect r = QRect(qRound(rect.x() + d->transform.dx()),
-qRound(rect.y() + d->transform.dy()),
-qRound(rect.width()),
-qRound(rect.height()));
 int height = paintDevice()->height();
 if (d->clearColor != color || d->clearOpacity != s->opacity) {
 VGfloat values[4];
 values[0] = color.redF();
 values[1] = color.greenF();
 if (brush.style() == Qt::NoBrush)
 return;
 // Check to see if we can use vgClear() for faster filling.
-if (brush.style() == Qt::SolidPattern &&
+if (brush.style() == Qt::SolidPattern && brush.isOpaque() &&
 clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
 clearRect(rect, brush.color())) {
 return;
 }
 void QVGPaintEngine::fillRect(const QRectF &rect, const QColor &color)
 {
 Q_D(QVGPaintEngine);
 // Check to see if we can use vgClear() for faster filling.
-if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f &&
+if (clipTransformIsSimple(d->transform) && d->opacity == 1.0f && color.alpha() == 255 &&
 clearRect(rect, color)) {
 return;
 }
 #if !defined(QVG_NO_MODIFY_PATH)
 VGImage vgImage = VG_INVALID_HANDLE;
 metrics = ti.fontEngine->boundingBox(glyph);
 if (!scaledImage.isNull()) {  // Not a space character
 if (scaledImage.format() == QImage::Format_Indexed8) {
 vgImage = vgCreateImage(VG_A_8, scaledImage.width(), scaledImage.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, scaledImage.bits(), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
+vgImageSubData(vgImage, qt_vg_imageBits(scaledImage), scaledImage.bytesPerLine(), VG_A_8, 0, 0, scaledImage.width(), scaledImage.height());
 } else if (scaledImage.format() == QImage::Format_Mono) {
 QImage img = scaledImage.convertToFormat(QImage::Format_Indexed8);
 vgImage = vgCreateImage(VG_A_8, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, img.bits(), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_A_8, 0, 0, img.width(), img.height());
 } else {
 QImage img = scaledImage.convertToFormat(QImage::Format_ARGB32_Premultiplied);
 vgImage = vgCreateImage(VG_sARGB_8888_PRE, img.width(), img.height(), VG_IMAGE_QUALITY_FASTER);
-vgImageSubData(vgImage, img.bits(), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
+vgImageSubData(vgImage, qt_vg_imageBits(img), img.bytesPerLine(), VG_sARGB_8888_PRE, 0, 0, img.width(), img.height());
 }
 }
 origin[0] = -metrics.x.toReal() + 0.5f;
 origin[1] = -metrics.y.toReal() + 0.5f;
 escapement[0] = metrics.xoff.toReal();
 d->forceBrushChange = true;
 d->penType = (VGPaintType)0;
 d->brushType = (VGPaintType)0;
 d->clearColor = QColor();
 d->fillPaint = d->brushPaint;
+d->scissorDirty = true;
 restoreState(QPaintEngine::AllDirty);
 d->dirty = dirty;
 d->rawVG = false;
 vgSetPaint(d->penPaint, VG_STROKE_PATH);
 vgSetPaint(d->brushPaint, VG_FILL_PATH);
 if ((dirty & (QPaintEngine::DirtyClipRegion |
 QPaintEngine::DirtyClipPath |
 QPaintEngine::DirtyClipEnabled)) != 0) {
 d->maskValid = false;
 d->maskIsSet = false;
+d->scissorMask = false;
 d->maskRect = QRect();
 clipEnabledChanged();
 }
 #if defined(QVG_SCISSOR_CLIP)
 (VG_sARGB_8888_PRE, img.width(), img.height(),
 VG_IMAGE_QUALITY_FASTER);
 if (vgImage == VG_INVALID_HANDLE)
 return;
 vgImageSubData
-(vgImage, img.bits() + img.bytesPerLine() * (img.height() - 1),
+(vgImage, qt_vg_imageBits(img) + img.bytesPerLine() * (img.height() - 1),
 -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
 img.width(), img.height());
 vgDrawImage(vgImage);
 vgDestroyImage(vgImage);
 params[i * 4 + 3] = rects[i].height();
 }
 vgSetiv(VG_SCISSOR_RECTS, count * 4, params.data());
 vgSeti(VG_SCISSORING, VG_TRUE);
+d->scissorDirty = false;
 d->scissorActive = true;
 d->scissorRegion = region;
 }
 void QVGCompositionHelper::clearScissor()
 {
-if (d->scissorActive) {
+if (d->scissorActive || d->scissorDirty) {
 vgSeti(VG_SCISSORING, VG_FALSE);
 d->scissorActive = false;
+d->scissorDirty = false;
 }
 }
 #endif // !QVG_NO_SINGLE_CONTEXT && !QT_NO_EGL

changeset 7	f7bc934e204c
parent 3	41300fa6a67c