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

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 #include "qpaintengine_vg_p.h"
 #include "qpixmapdata_vg_p.h"
 #include "qpixmapfilter_vg_p.h"
 #include "qvgcompositionhelper_p.h"
+#include "qvgimagepool_p.h"
 #if !defined(QT_NO_EGL)
 #include <QtGui/private/qegl_p.h>
 #include "qwindowsurface_vgegl_p.h"
 #endif
 #include <QtCore/qvarlengtharray.h>
 break;
 }
 const uchar *pixels = img.bits();
-VGImage vgImg = vgCreateImage
+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());
 }
 const uchar *pixels = img.bits() + bpp * sr.x() +
 img.bytesPerLine() * sr.y();
-VGImage vgImg = vgCreateImage
+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());
 painter.drawImage(0, 0, image);
 painter.end();
 const uchar *pixels = img.bits();
-VGImage vgImg = vgCreateImage
+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());
 painter.drawImage(QPoint(0, 0), image, sr);
 painter.end();
 const uchar *pixels = img.bits();
-VGImage vgImg = vgCreateImage
+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());
 }
 case Qt::TexturePattern: {
 // The brush is a texture specified by a QPixmap/QImage.
 QPixmapData *pd = brush.texture().pixmapData();
+if (!pd)
+break;  // null QPixmap
 VGImage vgImg;
 bool deref = false;
 if (pd->pixelType() == QPixmapData::BitmapType) {
 // Colorize bitmaps using the brush color and opacity.
 QColor color = brush.color();
 deref = true;
 } else if (opacity == 1.0) {
 if (pd->classId() == QPixmapData::OpenVGClass) {
 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
 vgImg = vgpd->toVGImage();
+// We don't want the pool to reclaim this image
+// because we cannot predict when the paint object
+// will stop using it.  Replacing the image with
+// new data will make the paint object invalid.
+vgpd->detachImageFromPool();
 } else {
 vgImg = toVGImage(*(pd->buffer()));
 deref = true;
 }
 } else if (pd->classId() == QPixmapData::OpenVGClass) {
 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
 vgImg = vgpd->toVGImage(opacity);
+vgpd->detachImageFromPool();
 } else {
 vgImg = toVGImageWithOpacity(*(pd->buffer()), opacity);
 deref = true;
 }
 if (vgImg == VG_INVALID_HANDLE)
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
 d->dirty |= QPaintEngine::DirtyClipRegion;
-// If we have a non-simple transform, then use path-based clipping.
-if (op != Qt::NoClip && !clipTransformIsSimple(d->transform)) {
-QPaintEngineEx::clip(rect, op);
-return;
-}
 switch (op) {
 case Qt::NoClip:
 {
 s->clipRegion = defaultClipRegion();
 }
 {
 Q_D(QVGPaintEngine);
 QVGPainterState *s = state();
 d->dirty |= QPaintEngine::DirtyClipRegion;
-// If we have a non-simple transform, then use path-based clipping.
-if (op != Qt::NoClip && !clipTransformIsSimple(d->transform)) {
-QPaintEngineEx::clip(region, op);
-return;
-}
 switch (op) {
 case Qt::NoClip:
 {
 s->clipRegion = defaultClipRegion();
 // clip and "r" is a single rectangle, then use the
 // scissor for clipping.  We try to avoid allocating a
 // QRegion copy on the heap for the test if we can.
 QRegion clip = d->systemClip; // Reference-counted, no alloc.
 QRect clipRect;
-if (clip.numRects() == 1) {
+if (clip.rectCount() == 1) {
 clipRect = clip.boundingRect().intersected(r);
 } else if (clip.isEmpty()) {
 clipRect = r;
 } else {
 clip = clip.intersect(r);
-if (clip.numRects() != 1) {
+if (clip.rectCount() != 1) {
 d->maskValid = false;
 d->maskIsSet = false;
 d->maskRect = QRect();
 d->modifyMask(this, VG_FILL_MASK, r);
 break;
 void QVGPaintEngine::clip(const QRegion &region, Qt::ClipOperation op)
 {
 Q_D(QVGPaintEngine);
 // Use the QRect case if the region consists of a single rectangle.
-if (region.numRects() == 1) {
+if (region.rectCount() == 1) {
 clip(region.boundingRect(), op);
 return;
 }
 d->dirty |= QPaintEngine::DirtyClipRegion;
 QRegion clip = d->systemClip;
 if (clip.isEmpty())
 clip = r;
 else
 clip = clip.intersect(r);
-if (clip.numRects() == 1) {
+if (clip.rectCount() == 1) {
 d->maskValid = false;
 d->maskIsSet = false;
 d->maskRect = clip.boundingRect();
 vgSeti(VG_MASKING, VG_FALSE);
 updateScissor();
 }
 break;
 case Qt::IntersectClip:
 {
-if (region.numRects() != 1) {
+if (region.rectCount() != 1) {
 // If there is more than one rectangle, then intersecting
 // the rectangles one by one in modifyMask() will not give
 // the desired result.  So fall back to path-based clipping.
 QPaintEngineEx::clip(region, op);
 return;
 return QRegion(0, 0, pdev->width(), pdev->height());
 }
 bool QVGPaintEngine::isDefaultClipRegion(const QRegion& region)
 {
-if (region.numRects() != 1)
+if (region.rectCount() != 1)
 return false;
 QPaintDevice *pdev = paintDevice();
 int width = pdev->width();
 int height = pdev->height();
 }
 void QVGPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
 {
 QPixmapData *pd = pm.pixmapData();
+if (!pd)
+return; // null QPixmap
 if (pd->classId() == QPixmapData::OpenVGClass) {
 Q_D(QVGPaintEngine);
 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
 if (!vgpd->isValid())
 return;
 }
 void QVGPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pm)
 {
 QPixmapData *pd = pm.pixmapData();
+if (!pd)
+return; // null QPixmap
 if (pd->classId() == QPixmapData::OpenVGClass) {
 Q_D(QVGPaintEngine);
 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
 if (!vgpd->isValid())
 return;
 Q_D(QVGPaintEngine);
 // If the pixmap is not VG, or the transformation is projective,
 // then fall back to the default implementation.
 QPixmapData *pd = pixmap.pixmapData();
+if (!pd)
+return; // null QPixmap
 if (pd->classId() != QPixmapData::OpenVGClass || !d->simpleTransform) {
 QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
 return;
 }
 #else
 updateScissor();
 #endif
 }
+void QVGPaintEngine::fillRegion
+(const QRegion& region, const QColor& color, const QSize& surfaceSize)
+{
+Q_D(QVGPaintEngine);
+if (d->clearColor != color || d->clearOpacity != 1.0f) {
+VGfloat values[4];
+values[0] = color.redF();
+values[1] = color.greenF();
+values[2] = color.blueF();
+values[3] = color.alphaF();
+vgSetfv(VG_CLEAR_COLOR, 4, values);
+d->clearColor = color;
+d->clearOpacity = 1.0f;
+}
+if (region.rectCount() == 1) {
+QRect r = region.boundingRect();
+vgClear(r.x(), surfaceSize.height() - r.y() - r.height(),
+r.width(), r.height());
+} else {
+const QVector<QRect> rects = region.rects();
+for (int i = 0; i < rects.size(); ++i) {
+QRect r = rects.at(i);
+vgClear(r.x(), surfaceSize.height() - r.y() - r.height(),
+r.width(), r.height());
+}
+}
+}
 #if !defined(QVG_NO_SINGLE_CONTEXT) && !defined(QT_NO_EGL)
 QVGCompositionHelper::QVGCompositionHelper()
 {
 d = qt_vg_create_paint_engine()->vgPrivate();
 {
 clearScissor();
 }
 void QVGCompositionHelper::blitWindow
-(QVGEGLWindowSurfacePrivate *surface, const QRect& rect,
+(VGImage image, const QSize& imageSize,
-const QPoint& topLeft, int opacity)
+const QRect& rect, const QPoint& topLeft, int opacity)
 {
-// Get the VGImage that is acting as a back buffer for the window.
-VGImage image = surface->surfaceImage();
 if (image == VG_INVALID_HANDLE)
 return;
-QSize imageSize = surface->surfaceSize();
 // Determine which sub rectangle of the window to draw.
 QRect sr = rect.translated(-topLeft);
 if (opacity >= 255) {
 }
 // Set the image transform.
 QTransform transform;
 int y = screenSize.height() - (rect.bottom() + 1);
-transform.translate(rect.x() + 0.5f, y + 0.5f);
+transform.translate(rect.x() - 0.5f, y - 0.5f);
 d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 // Enable opacity for image drawing if necessary.
-if (opacity < 255) {
+if (opacity != d->paintOpacity) {
-if (opacity != d->paintOpacity) {
+VGfloat values[4];
-VGfloat values[4];
+values[0] = 1.0f;
-values[0] = 1.0f;
+values[1] = 1.0f;
-values[1] = 1.0f;
+values[2] = 1.0f;
-values[2] = 1.0f;
+values[3] = ((VGfloat)opacity) / 255.0f;
-values[3] = ((VGfloat)opacity) / 255.0f;
+vgSetParameterfv(d->opacityPaint, VG_PAINT_COLOR, 4, values);
-vgSetParameterfv(d->opacityPaint, VG_PAINT_COLOR, 4, values);
+d->paintOpacity = values[3];
-d->paintOpacity = values[3];
+}
-}
+if (d->fillPaint != d->opacityPaint) {
-if (d->fillPaint != d->opacityPaint) {
+vgSetPaint(d->opacityPaint, VG_FILL_PATH);
-vgSetPaint(d->opacityPaint, VG_FILL_PATH);
+d->fillPaint = d->opacityPaint;
-d->fillPaint = d->opacityPaint;
+}
-}
+d->setImageMode(VG_DRAW_IMAGE_MULTIPLY);
-d->setImageMode(VG_DRAW_IMAGE_MULTIPLY);
-} else {
-d->setImageMode(VG_DRAW_IMAGE_NORMAL);
-}
 // Draw the child image.
 vgDrawImage(child);
 // Destroy the child image.
 }
 void QVGCompositionHelper::fillBackground
 (const QRegion& region, const QBrush& brush)
 {
-// Set the path transform to the default viewport transformation.
+if (brush.style() == Qt::SolidPattern) {
-VGfloat devh = screenSize.height() - 1;
+// Use vgClear() to quickly fill the background.
-QTransform viewport(1.0f, 0.0f, 0.0f,
+QColor color = brush.color();
-0.0f, -1.0f, 0.0f,
+if (d->clearColor != color || d->clearOpacity != 1.0f) {
-0.5f, devh + 0.5f, 1.0f);
+VGfloat values[4];
-d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
+values[0] = color.redF();
+values[1] = color.greenF();
-// Set the brush to use to fill the background.
+values[2] = color.blueF();
-d->ensureBrush(brush);
+values[3] = color.alphaF();
-d->setFillRule(VG_EVEN_ODD);
+vgSetfv(VG_CLEAR_COLOR, 4, values);
+d->clearColor = color;
-if (region.numRects() == 1) {
+d->clearOpacity = 1.0f;
-fillBackgroundRect(region.boundingRect(), d);
+}
+if (region.rectCount() == 1) {
+QRect r = region.boundingRect();
+vgClear(r.x(), screenSize.height() - r.y() - r.height(),
+r.width(), r.height());
+} else {
+const QVector<QRect> rects = region.rects();
+for (int i = 0; i < rects.size(); ++i) {
+QRect r = rects.at(i);
+vgClear(r.x(), screenSize.height() - r.y() - r.height(),
+r.width(), r.height());
+}
+}
 } else {
-const QVector<QRect> rects = region.rects();
+// Set the path transform to the default viewport transformation.
-for (int i = 0; i < rects.size(); ++i)
+VGfloat devh = screenSize.height() - 1;
-fillBackgroundRect(rects.at(i), d);
+QTransform viewport(1.0f, 0.0f, 0.0f,
-}
+0.0f, -1.0f, 0.0f,
+-0.5f, devh + 0.5f, 1.0f);
-// We will need to reset the path transform during the next paint.
+d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
-d->pathTransformSet = false;
-}
+// Set the brush to use to fill the background.
+d->ensureBrush(brush);
-void QVGCompositionHelper::drawCursorImage
+d->setFillRule(VG_EVEN_ODD);
-(const QImage& image, const QPoint& offset)
-{
+if (region.rectCount() == 1) {
-QImage img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+fillBackgroundRect(region.boundingRect(), d);
+} else {
-VGImage vgImg = vgCreateImage
+const QVector<QRect> rects = region.rects();
-(VG_sARGB_8888_PRE, img.width(), img.height(),
+for (int i = 0; i < rects.size(); ++i)
-VG_IMAGE_QUALITY_FASTER);
+fillBackgroundRect(rects.at(i), d);
-vgImageSubData
+}
-(vgImg, img.bits() + img.bytesPerLine() * (img.height() - 1),
--(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
+// We will need to reset the path transform during the next paint.
-img.width(), img.height());
+d->pathTransformSet = false;
+}
-QTransform transform;
-int y = screenSize.height() - (offset.y() + img.height());
-transform.translate(offset.x() + 0.5f, y + 0.5f);
-d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
-d->setImageMode(VG_DRAW_IMAGE_NORMAL);
-vgDrawImage(vgImg);
-vgDestroyImage(vgImg);
 }
 void QVGCompositionHelper::drawCursorPixmap
 (const QPixmap& pixmap, const QPoint& offset)
 {
+VGImage vgImage = VG_INVALID_HANDLE;
+// Fetch the VGImage from the pixmap if possible.
 QPixmapData *pd = pixmap.pixmapData();
+if (!pd)
+return; // null QPixmap
 if (pd->classId() == QPixmapData::OpenVGClass) {
 QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
-if (vgpd->isValid()) {
+if (vgpd->isValid())
-VGfloat devh = screenSize.height() - 1;
+vgImage = vgpd->toVGImage();
-QTransform transform(1.0f, 0.0f, 0.0f,
+}
-0.0f, -1.0f, 0.0f,
-0.5f, devh + 0.5f, 1.0f);
+// Set the image transformation and modes.
-transform.translate(offset.x(), offset.y());
+VGfloat devh = screenSize.height() - 1;
-d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
+QTransform transform(1.0f, 0.0f, 0.0f,
+0.0f, -1.0f, 0.0f,
-d->setImageMode(VG_DRAW_IMAGE_NORMAL);
+-0.5f, devh + 0.5f, 1.0f);
-vgDrawImage(vgpd->toVGImage());
+transform.translate(offset.x(), offset.y());
+d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
+d->setImageMode(VG_DRAW_IMAGE_NORMAL);
+// Draw the VGImage.
+if (vgImage != VG_INVALID_HANDLE) {
+vgDrawImage(vgImage);
+} else {
+QImage img = pixmap.toImage().convertToFormat
+(QImage::Format_ARGB32_Premultiplied);
+vgImage = vgCreateImage
+(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),
+-(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
-drawCursorImage(pixmap.toImage(), offset);
+img.width(), img.height());
+vgDrawImage(vgImage);
+vgDestroyImage(vgImage);
+}
 }
 void QVGCompositionHelper::setScissor(const QRegion& region)
 {
 QVector<QRect> rects = region.rects();

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611