/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the either Technology Preview License Agreement or the ** Beta Release License Agreement. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain ** additional rights. These rights are described in the Nokia Qt LGPL ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this ** package. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 3.0 as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU General Public License version 3.0 requirements will be ** met: http://www.gnu.org/copyleft/gpl.html. ** ** If you are unsure which license is appropriate for your use, please ** contact the sales department at http://www.qtsoftware.com/contact. ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "qplatformdefs.h" #include "private/qpixmap_x11_p.h" #include "qapplication.h" #include "qdebug.h" #include "qfont.h" #include "qwidget.h" #include "qbitmap.h" #include "qpixmapcache.h" #include "qtextcodec.h" #include "qcoreevent.h" #include "qiodevice.h" #include #include "qpainter_p.h" #include #include #include #include #include #include #include #include #include "qpen.h" #include "qcolor.h" #include "qcolormap.h" #include #include "qpaintengine_x11_p.h" #include #include #include #ifndef QT_NO_XRENDER #include #endif QT_BEGIN_NAMESPACE extern Drawable qt_x11Handle(const QPaintDevice *pd); extern const QX11Info *qt_x11Info(const QPaintDevice *pd); extern QPixmap qt_pixmapForBrush(int brushStyle, bool invert); //in qbrush.cpp extern QPixmap qt_toX11Pixmap(const QPixmap &pixmap); // use the same rounding as in qrasterizer.cpp (6 bit fixed point) static const qreal aliasedCoordinateDelta = 0.5 - 0.015625; #undef X11 // defined in qt_x11_p.h /*! Returns the X11 specific pen GC for the painter \a p. Note that QPainter::begin() must be called before this function returns a valid GC. */ Q_GUI_EXPORT GC qt_x11_get_pen_gc(QPainter *p) { if (p && p->paintEngine() && p->paintEngine()->isActive() && p->paintEngine()->type() == QPaintEngine::X11) { return static_cast(p->paintEngine())->d_func()->gc; } return 0; } /*! Returns the X11 specific brush GC for the painter \a p. Note that QPainter::begin() must be called before this function returns a valid GC. */ Q_GUI_EXPORT GC qt_x11_get_brush_gc(QPainter *p) { if (p && p->paintEngine() && p->paintEngine()->isActive() && p->paintEngine()->type() == QPaintEngine::X11) { return static_cast(p->paintEngine())->d_func()->gc_brush; } return 0; } #define X11 qt_x11Data #ifndef QT_NO_XRENDER static const int compositionModeToRenderOp[QPainter::CompositionMode_Xor + 1] = { PictOpOver, //CompositionMode_SourceOver, PictOpOverReverse, //CompositionMode_DestinationOver, PictOpClear, //CompositionMode_Clear, PictOpSrc, //CompositionMode_Source, PictOpDst, //CompositionMode_Destination, PictOpIn, //CompositionMode_SourceIn, PictOpInReverse, //CompositionMode_DestinationIn, PictOpOut, //CompositionMode_SourceOut, PictOpOutReverse, //CompositionMode_DestinationOut, PictOpAtop, //CompositionMode_SourceAtop, PictOpAtopReverse, //CompositionMode_DestinationAtop, PictOpXor //CompositionMode_Xor }; static inline int qpainterOpToXrender(QPainter::CompositionMode mode) { Q_ASSERT(mode <= QPainter::CompositionMode_Xor); return compositionModeToRenderOp[mode]; } #endif // hack, so we don't have to make QRegion::clipRectangles() public or include // X11 headers in qregion.h Q_AUTOTEST_EXPORT void *qt_getClipRects(const QRegion &r, int &num) { return r.clipRectangles(num); } static inline void x11SetClipRegion(Display *dpy, GC gc, GC gc2, #ifndef QT_NO_XRENDER Picture picture, #else Qt::HANDLE picture, #endif const QRegion &r) { int num; XRectangle *rects = (XRectangle *)qt_getClipRects(r, num); if (gc) XSetClipRectangles( dpy, gc, 0, 0, rects, num, YXBanded ); if (gc2) XSetClipRectangles( dpy, gc2, 0, 0, rects, num, YXBanded ); #ifndef QT_NO_XRENDER if (picture) XRenderSetPictureClipRectangles(dpy, picture, 0, 0, rects, num); #else Q_UNUSED(picture); #endif // QT_NO_XRENDER } static inline void x11ClearClipRegion(Display *dpy, GC gc, GC gc2, #ifndef QT_NO_XRENDER Picture picture #else Qt::HANDLE picture #endif ) { if (gc) XSetClipMask(dpy, gc, XNone); if (gc2) XSetClipMask(dpy, gc2, XNone); #ifndef QT_NO_XRENDER if (picture) { XRenderPictureAttributes attrs; attrs.clip_mask = XNone; XRenderChangePicture (dpy, picture, CPClipMask, &attrs); } #else Q_UNUSED(picture); #endif // QT_NO_XRENDER } #define DITHER_SIZE 16 static const uchar base_dither_matrix[DITHER_SIZE][DITHER_SIZE] = { { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 }, { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 }, { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 }, { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 }, { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 }, { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 }, { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 }, { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 }, { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 }, { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 }, { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 }, { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 }, { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 }, { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 }, { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 }, { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 } }; static QPixmap qt_patternForAlpha(uchar alpha, int screen) { QPixmap pm; QString key = QLatin1String("$qt-alpha-brush$") + QString::number(alpha) + QString::number(screen); if (!QPixmapCache::find(key, pm)) { // #### why not use a mono image here???? QImage pattern(DITHER_SIZE, DITHER_SIZE, QImage::Format_ARGB32); pattern.fill(0xffffffff); for (int y = 0; y < DITHER_SIZE; ++y) { for (int x = 0; x < DITHER_SIZE; ++x) { if (base_dither_matrix[x][y] <= alpha) pattern.setPixel(x, y, 0x00000000); } } pm = QBitmap::fromImage(pattern); pm.x11SetScreen(screen); QPixmapCache::insert(key, pm); } return pm; } #if !defined(QT_NO_XRENDER) class QXRenderTessellator : public QTessellator { public: QXRenderTessellator() : traps(0), allocated(0), size(0) {} ~QXRenderTessellator() { free(traps); } XTrapezoid *traps; int allocated; int size; void addTrap(const Trapezoid &trap); QRect tessellate(const QPointF *points, int nPoints, bool winding) { size = 0; setWinding(winding); return QTessellator::tessellate(points, nPoints).toRect(); } void done() { if (allocated > 64) { free(traps); traps = 0; allocated = 0; } } }; void QXRenderTessellator::addTrap(const Trapezoid &trap) { if (size == allocated) { allocated = qMax(2*allocated, 64); traps = q_check_ptr((XTrapezoid *)realloc(traps, allocated * sizeof(XTrapezoid))); } traps[size].top = Q27Dot5ToXFixed(trap.top); traps[size].bottom = Q27Dot5ToXFixed(trap.bottom); traps[size].left.p1.x = Q27Dot5ToXFixed(trap.topLeft->x); traps[size].left.p1.y = Q27Dot5ToXFixed(trap.topLeft->y); traps[size].left.p2.x = Q27Dot5ToXFixed(trap.bottomLeft->x); traps[size].left.p2.y = Q27Dot5ToXFixed(trap.bottomLeft->y); traps[size].right.p1.x = Q27Dot5ToXFixed(trap.topRight->x); traps[size].right.p1.y = Q27Dot5ToXFixed(trap.topRight->y); traps[size].right.p2.x = Q27Dot5ToXFixed(trap.bottomRight->x); traps[size].right.p2.y = Q27Dot5ToXFixed(trap.bottomRight->y); ++size; } #endif // !defined(QT_NO_XRENDER) #ifndef QT_NO_XRENDER static Picture getPatternFill(int screen, const QBrush &b) { if (!X11->use_xrender) return XNone; XRenderColor color = X11->preMultiply(b.color()); XRenderColor bg_color; bg_color = X11->preMultiply(QColor(0, 0, 0, 0)); for (int i = 0; i < X11->pattern_fill_count; ++i) { if (X11->pattern_fills[i].screen == screen && X11->pattern_fills[i].opaque == false && X11->pattern_fills[i].style == b.style() && X11->pattern_fills[i].color.alpha == color.alpha && X11->pattern_fills[i].color.red == color.red && X11->pattern_fills[i].color.green == color.green && X11->pattern_fills[i].color.blue == color.blue && X11->pattern_fills[i].bg_color.alpha == bg_color.alpha && X11->pattern_fills[i].bg_color.red == bg_color.red && X11->pattern_fills[i].bg_color.green == bg_color.green && X11->pattern_fills[i].bg_color.blue == bg_color.blue) return X11->pattern_fills[i].picture; } // none found, replace one int i = rand() % 16; if (X11->pattern_fills[i].screen != screen && X11->pattern_fills[i].picture) { XRenderFreePicture (X11->display, X11->pattern_fills[i].picture); X11->pattern_fills[i].picture = 0; } if (!X11->pattern_fills[i].picture) { Pixmap pixmap = XCreatePixmap (X11->display, RootWindow (X11->display, screen), 8, 8, 32); XRenderPictureAttributes attrs; attrs.repeat = True; X11->pattern_fills[i].picture = XRenderCreatePicture (X11->display, pixmap, XRenderFindStandardFormat(X11->display, PictStandardARGB32), CPRepeat, &attrs); XFreePixmap (X11->display, pixmap); } X11->pattern_fills[i].screen = screen; X11->pattern_fills[i].color = color; X11->pattern_fills[i].bg_color = bg_color; X11->pattern_fills[i].opaque = false; X11->pattern_fills[i].style = b.style(); XRenderFillRectangle(X11->display, PictOpSrc, X11->pattern_fills[i].picture, &bg_color, 0, 0, 8, 8); QPixmap pattern(qt_pixmapForBrush(b.style(), true)); XRenderPictureAttributes attrs; attrs.repeat = true; XRenderChangePicture(X11->display, pattern.x11PictureHandle(), CPRepeat, &attrs); Picture fill_fg = X11->getSolidFill(screen, b.color()); XRenderComposite(X11->display, PictOpOver, fill_fg, pattern.x11PictureHandle(), X11->pattern_fills[i].picture, 0, 0, 0, 0, 0, 0, 8, 8); return X11->pattern_fills[i].picture; } static void qt_render_bitmap(Display *dpy, int scrn, Picture src, Picture dst, int sx, int sy, int x, int y, int sw, int sh, const QPen &pen) { Picture fill_fg = X11->getSolidFill(scrn, pen.color()); XRenderComposite(dpy, PictOpOver, fill_fg, src, dst, sx, sy, sx, sy, x, y, sw, sh); } #endif void QX11PaintEnginePrivate::init() { dpy = 0; scrn = 0; hd = 0; picture = 0; xinfo = 0; #ifndef QT_NO_XRENDER current_brush = 0; composition_mode = PictOpOver; tessellator = new QXRenderTessellator; #endif } void QX11PaintEnginePrivate::setupAdaptedOrigin(const QPoint &p) { if (adapted_pen_origin) XSetTSOrigin(dpy, gc, p.x(), p.y()); if (adapted_brush_origin) XSetTSOrigin(dpy, gc_brush, p.x(), p.y()); } void QX11PaintEnginePrivate::resetAdaptedOrigin() { if (adapted_pen_origin) XSetTSOrigin(dpy, gc, 0, 0); if (adapted_brush_origin) XSetTSOrigin(dpy, gc_brush, 0, 0); } void QX11PaintEnginePrivate::clipPolygon_dev(const QPolygonF &poly, QPolygonF *clipped_poly) { int clipped_count = 0; qt_float_point *clipped_points = 0; polygonClipper.clipPolygon((qt_float_point *) poly.data(), poly.size(), &clipped_points, &clipped_count); clipped_poly->resize(clipped_count); for (int i=0; istate ? static_cast(q->state)->painter : 0; if (painter && painter->hasClipping()) { if (q->testDirty(QPaintEngine::DirtyTransform)) q->updateMatrix(q->state->transform()); QPolygonF clip_poly_dev(matrix.map(painter->clipPath().toFillPolygon())); QPolygonF clipped_poly_dev; clipPolygon_dev(clip_poly_dev, &clipped_poly_dev); q->updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), Qt::ReplaceClip); } else { q->updateClipRegion_dev(QRegion(), Qt::NoClip); } } static QPaintEngine::PaintEngineFeatures qt_decide_features() { QPaintEngine::PaintEngineFeatures features = QPaintEngine::PrimitiveTransform | QPaintEngine::PatternBrush | QPaintEngine::AlphaBlend | QPaintEngine::PainterPaths | QPaintEngine::RasterOpModes; if (X11->use_xrender) { features |= QPaintEngine::Antialiasing; features |= QPaintEngine::PorterDuff; features |= QPaintEngine::MaskedBrush; #if 0 if (X11->xrender_version > 10) { features |= QPaintEngine::LinearGradientFill; // ### } #endif } return features; } /* * QX11PaintEngine members */ QX11PaintEngine::QX11PaintEngine() : QPaintEngine(*(new QX11PaintEnginePrivate), qt_decide_features()) { d_func()->init(); } QX11PaintEngine::QX11PaintEngine(QX11PaintEnginePrivate &dptr) : QPaintEngine(dptr, qt_decide_features()) { d_func()->init(); } QX11PaintEngine::~QX11PaintEngine() { #ifndef QT_NO_XRENDER Q_D(QX11PaintEngine); delete d->tessellator; #endif } bool QX11PaintEngine::begin(QPaintDevice *pdev) { Q_D(QX11PaintEngine); d->xinfo = qt_x11Info(pdev); QWidget *w = d->pdev->devType() == QInternal::Widget ? static_cast(d->pdev) : 0; const bool isAlienWidget = w && !w->internalWinId() && w->testAttribute(Qt::WA_WState_Created); #ifndef QT_NO_XRENDER if (w) { if (isAlienWidget) d->picture = (::Picture)w->nativeParentWidget()->x11PictureHandle(); else d->picture = (::Picture)w->x11PictureHandle(); } else if (pdev->devType() == QInternal::Pixmap) { const QPixmap *pm = static_cast(pdev); QX11PixmapData *data = static_cast(pm->data); if (X11->use_xrender && data->depth() != 32 && data->x11_mask) data->convertToARGB32(); d->picture = (::Picture)static_cast(pdev)->x11PictureHandle(); } #else d->picture = 0; #endif d->hd = !isAlienWidget ? qt_x11Handle(pdev) : qt_x11Handle(w->nativeParentWidget()); Q_ASSERT(d->xinfo != 0); d->dpy = d->xinfo->display(); // get display variable d->scrn = d->xinfo->screen(); // get screen variable d->crgn = QRegion(); d->gc = XCreateGC(d->dpy, d->hd, 0, 0); d->gc_brush = XCreateGC(d->dpy, d->hd, 0, 0); d->has_alpha_brush = false; d->has_alpha_pen = false; d->has_clipping = false; d->has_complex_xform = false; d->has_scaling_xform = false; d->has_non_scaling_xform = true; d->xform_scale = 1; d->has_custom_pen = false; d->matrix = QTransform(); d->pdev_depth = d->pdev->depth(); d->render_hints = 0; d->txop = QTransform::TxNone; d->use_path_fallback = false; #if !defined(QT_NO_XRENDER) d->composition_mode = PictOpOver; #endif d->xlibMaxLinePoints = 32762; // a safe number used to avoid, call to XMaxRequestSize(d->dpy) - 3; d->opacity = 1; // Set up the polygon clipper. Note: This will only work in // polyline mode as long as we have a buffer zone, since a // polyline may be clipped into several non-connected polylines. const int BUFFERZONE = 1000; QRect devClipRect(-BUFFERZONE, -BUFFERZONE, pdev->width() + 2*BUFFERZONE, pdev->height() + 2*BUFFERZONE); d->polygonClipper.setBoundingRect(devClipRect); if (isAlienWidget) { // Set system clip for alien widgets painting outside the paint event. // This is not a problem with native windows since the windowing system // will handle the clip. QWidgetPrivate *wd = w->d_func(); QRegion widgetClip(wd->clipRect()); wd->clipToEffectiveMask(widgetClip); wd->subtractOpaqueSiblings(widgetClip); widgetClip.translate(w->mapTo(w->nativeParentWidget(), QPoint())); setSystemClip(widgetClip); } QPixmap::x11SetDefaultScreen(d->xinfo->screen()); if (w && w->testAttribute(Qt::WA_PaintUnclipped)) { // paint direct on device updatePen(QPen(Qt::black)); updateBrush(QBrush(Qt::white), QPoint()); XSetSubwindowMode(d->dpy, d->gc, IncludeInferiors); XSetSubwindowMode(d->dpy, d->gc_brush, IncludeInferiors); #ifndef QT_NO_XRENDER XRenderPictureAttributes attrs; attrs.subwindow_mode = IncludeInferiors; XRenderChangePicture(d->dpy, d->picture, CPSubwindowMode, &attrs); #endif } setDirty(QPaintEngine::DirtyClipRegion); setDirty(QPaintEngine::DirtyPen); setDirty(QPaintEngine::DirtyBrush); setDirty(QPaintEngine::DirtyBackground); return true; } bool QX11PaintEngine::end() { Q_D(QX11PaintEngine); #if !defined(QT_NO_XRENDER) if (d->picture) { // reset clipping/subwindow mode on our render picture XRenderPictureAttributes attrs; attrs.subwindow_mode = ClipByChildren; attrs.clip_mask = XNone; XRenderChangePicture(d->dpy, d->picture, CPClipMask|CPSubwindowMode, &attrs); } #endif if (d->gc_brush && d->pdev->painters < 2) { XFreeGC(d->dpy, d->gc_brush); d->gc_brush = 0; } if (d->gc && d->pdev->painters < 2) { XFreeGC(d->dpy, d->gc); d->gc = 0; } // Restore system clip for alien widgets painting outside the paint event. if (d->pdev->devType() == QInternal::Widget && !static_cast(d->pdev)->internalWinId()) setSystemClip(QRegion()); return true; } static bool clipLine(QLineF *line, const QRect &rect) { qreal x1 = line->x1(); qreal x2 = line->x2(); qreal y1 = line->y1(); qreal y2 = line->y2(); qreal left = rect.x(); qreal right = rect.x() + rect.width() - 1; qreal top = rect.y(); qreal bottom = rect.y() + rect.height() - 1; enum { Left, Right, Top, Bottom }; // clip the lines, after cohen-sutherland, see e.g. http://www.nondot.org/~sabre/graphpro/line6.html int p1 = ((x1 < left) << Left) | ((x1 > right) << Right) | ((y1 < top) << Top) | ((y1 > bottom) << Bottom); int p2 = ((x2 < left) << Left) | ((x2 > right) << Right) | ((y2 < top) << Top) | ((y2 > bottom) << Bottom); if (p1 & p2) // completely outside return false; if (p1 | p2) { qreal dx = x2 - x1; qreal dy = y2 - y1; // clip x coordinates if (x1 < left) { y1 += dy/dx * (left - x1); x1 = left; } else if (x1 > right) { y1 -= dy/dx * (x1 - right); x1 = right; } if (x2 < left) { y2 += dy/dx * (left - x2); x2 = left; } else if (x2 > right) { y2 -= dy/dx * (x2 - right); x2 = right; } p1 = ((y1 < top) << Top) | ((y1 > bottom) << Bottom); p2 = ((y2 < top) << Top) | ((y2 > bottom) << Bottom); if (p1 & p2) return false; // clip y coordinates if (y1 < top) { x1 += dx/dy * (top - y1); y1 = top; } else if (y1 > bottom) { x1 -= dx/dy * (y1 - bottom); y1 = bottom; } if (y2 < top) { x2 += dx/dy * (top - y2); y2 = top; } else if (y2 > bottom) { x2 -= dx/dy * (y2 - bottom); y2 = bottom; } *line = QLineF(QPointF(x1, y1), QPointF(x2, y2)); } return true; } void QX11PaintEngine::drawLines(const QLine *lines, int lineCount) { Q_ASSERT(lines); Q_ASSERT(lineCount); Q_D(QX11PaintEngine); if (d->has_alpha_brush || d->has_alpha_pen || d->has_custom_pen || (d->cpen.widthF() > 0 && d->has_complex_xform && !d->has_non_scaling_xform) || (d->render_hints & QPainter::Antialiasing)) { for (int i = 0; i < lineCount; ++i) { QPainterPath path(lines[i].p1()); path.lineTo(lines[i].p2()); drawPath(path); } return; } if (d->has_pen) { for (int i = 0; i < lineCount; ++i) { QLineF linef; if (d->txop == QTransform::TxNone) { linef = lines[i]; } else { linef = d->matrix.map(QLineF(lines[i])); } if (clipLine(&linef, d->polygonClipper.boundingRect())) { int x1 = qRound(linef.x1() + aliasedCoordinateDelta); int y1 = qRound(linef.y1() + aliasedCoordinateDelta); int x2 = qRound(linef.x2() + aliasedCoordinateDelta); int y2 = qRound(linef.y2() + aliasedCoordinateDelta); XDrawLine(d->dpy, d->hd, d->gc, x1, y1, x2, y2); } } } } void QX11PaintEngine::drawLines(const QLineF *lines, int lineCount) { Q_ASSERT(lines); Q_ASSERT(lineCount); Q_D(QX11PaintEngine); if (d->has_alpha_brush || d->has_alpha_pen || d->has_custom_pen || (d->cpen.widthF() > 0 && d->has_complex_xform && !d->has_non_scaling_xform) || (d->render_hints & QPainter::Antialiasing)) { for (int i = 0; i < lineCount; ++i) { QPainterPath path(lines[i].p1()); path.lineTo(lines[i].p2()); drawPath(path); } return; } if (d->has_pen) { for (int i = 0; i < lineCount; ++i) { QLineF linef = d->matrix.map(lines[i]); if (clipLine(&linef, d->polygonClipper.boundingRect())) { int x1 = qRound(linef.x1() + aliasedCoordinateDelta); int y1 = qRound(linef.y1() + aliasedCoordinateDelta); int x2 = qRound(linef.x2() + aliasedCoordinateDelta); int y2 = qRound(linef.y2() + aliasedCoordinateDelta); XDrawLine(d->dpy, d->hd, d->gc, x1, y1, x2, y2); } } } } static inline QLine clipStraightLine(const QRect &clip, const QLine &l) { if (l.p1().x() == l.p2().x()) { int x = qBound(clip.left(), l.p1().x(), clip.right()); int y1 = qBound(clip.top(), l.p1().y(), clip.bottom()); int y2 = qBound(clip.top(), l.p2().y(), clip.bottom()); return QLine(x, y1, x, y2); } else { Q_ASSERT(l.p1().y() == l.p2().y()); int x1 = qBound(clip.left(), l.p1().x(), clip.right()); int x2 = qBound(clip.left(), l.p2().x(), clip.right()); int y = qBound(clip.top(), l.p1().y(), clip.bottom()); return QLine(x1, y, x2, y); } } void QX11PaintEngine::drawRects(const QRectF *rects, int rectCount) { Q_D(QX11PaintEngine); Q_ASSERT(rects); Q_ASSERT(rectCount); if (rectCount != 1 || d->has_pen || d->has_alpha_brush || d->has_complex_xform || d->has_custom_pen || d->cbrush.style() != Qt::SolidPattern) { QPaintEngine::drawRects(rects, rectCount); return; } QPoint alignedOffset; if (d->txop == QTransform::TxTranslate) { QPointF offset(d->matrix.dx(), d->matrix.dy()); alignedOffset = offset.toPoint(); if (offset != QPointF(alignedOffset)) { QPaintEngine::drawRects(rects, rectCount); return; } } const QRectF& r = rects[0]; QRect alignedRect = r.toAlignedRect(); if (r != QRectF(alignedRect)) { QPaintEngine::drawRects(rects, rectCount); return; } alignedRect.translate(alignedOffset); QRect clip(d->polygonClipper.boundingRect()); alignedRect = alignedRect.intersected(clip); if (alignedRect.isEmpty()) return; // simple-case: // the rectangle is pixel-aligned // the fill brush is just a solid non-alpha color // the painter transform is only integer translation // ignore: antialiasing and just XFillRectangles directly XRectangle xrect; xrect.x = short(alignedRect.x()); xrect.y = short(alignedRect.y()); xrect.width = ushort(alignedRect.width()); xrect.height = ushort(alignedRect.height()); XFillRectangles(d->dpy, d->hd, d->gc_brush, &xrect, 1); } void QX11PaintEngine::drawRects(const QRect *rects, int rectCount) { Q_D(QX11PaintEngine); Q_ASSERT(rects); Q_ASSERT(rectCount); if (d->has_alpha_pen || d->has_complex_xform || d->has_custom_pen || (d->render_hints & QPainter::Antialiasing)) { for (int i = 0; i < rectCount; ++i) { QPainterPath path; path.addRect(rects[i]); drawPath(path); } return; } QRect clip(d->polygonClipper.boundingRect()); QPoint offset(qRound(d->matrix.dx()), qRound(d->matrix.dy())); #if !defined(QT_NO_XRENDER) ::Picture pict = d->picture; if (X11->use_xrender && pict && d->has_brush && d->pdev_depth != 1 && (d->has_texture || d->has_alpha_brush)) { XRenderColor xc; if (!d->has_texture && !d->has_pattern) xc = X11->preMultiply(d->cbrush.color()); for (int i = 0; i < rectCount; ++i) { QRect r(rects[i]); if (d->txop == QTransform::TxTranslate) r.translate(offset); if (r.width() == 0 || r.height() == 0) { if (d->has_pen) { const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height())); XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y()); } continue; } r = r.intersected(clip); if (r.isEmpty()) continue; if (d->has_texture || d->has_pattern) { XRenderComposite(d->dpy, d->composition_mode, d->current_brush, 0, pict, qRound(r.x() - d->bg_origin.x()), qRound(r.y() - d->bg_origin.y()), 0, 0, r.x(), r.y(), r.width(), r.height()); } else { XRenderFillRectangle(d->dpy, d->composition_mode, pict, &xc, r.x(), r.y(), r.width(), r.height()); } if (d->has_pen) XDrawRectangle(d->dpy, d->hd, d->gc, r.x(), r.y(), r.width(), r.height()); } } else #endif // !QT_NO_XRENDER { if (d->has_brush && d->has_pen) { for (int i = 0; i < rectCount; ++i) { QRect r(rects[i]); if (d->txop == QTransform::TxTranslate) r.translate(offset); if (r.width() == 0 || r.height() == 0) { const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height())); XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y()); continue; } r = r.intersected(clip); if (r.isEmpty()) continue; d->setupAdaptedOrigin(r.topLeft()); XFillRectangle(d->dpy, d->hd, d->gc_brush, r.x(), r.y(), r.width(), r.height()); XDrawRectangle(d->dpy, d->hd, d->gc, r.x(), r.y(), r.width(), r.height()); } d->resetAdaptedOrigin(); } else { QVarLengthArray xrects(rectCount); int numClipped = rectCount; for (int i = 0; i < rectCount; ++i) { QRect r(rects[i]); if (d->txop == QTransform::TxTranslate) r.translate(offset); if (r.width() == 0 || r.height() == 0) { --numClipped; if (d->has_pen) { const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height())); XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y()); } continue; } r = r.intersected(clip); if (r.isEmpty()) { --numClipped; continue; } xrects[i].x = short(r.x()); xrects[i].y = short(r.y()); xrects[i].width = ushort(r.width()); xrects[i].height = ushort(r.height()); } if (numClipped) { d->setupAdaptedOrigin(rects[0].topLeft()); if (d->has_brush) XFillRectangles(d->dpy, d->hd, d->gc_brush, xrects.data(), numClipped); else if (d->has_pen) XDrawRectangles(d->dpy, d->hd, d->gc, xrects.data(), numClipped); d->resetAdaptedOrigin(); } } } } static inline void setCapStyle(int cap_style, GC gc) { ulong mask = GCCapStyle; XGCValues vals; vals.cap_style = cap_style; XChangeGC(X11->display, gc, mask, &vals); } void QX11PaintEngine::drawPoints(const QPoint *points, int pointCount) { Q_ASSERT(points); Q_ASSERT(pointCount); Q_D(QX11PaintEngine); if (!d->has_pen) return; // use the same test here as in drawPath to ensure that we don't use the path fallback // and end up in XDrawLines for pens with width <= 1 if (d->cpen.widthF() > 1.0f || (X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing))) || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate)) { Qt::PenCapStyle capStyle = d->cpen.capStyle(); if (capStyle == Qt::FlatCap) { setCapStyle(CapProjecting, d->gc); d->cpen.setCapStyle(Qt::SquareCap); } const QPoint *end = points + pointCount; while (points < end) { QPainterPath path; path.moveTo(*points); path.lineTo(points->x()+.005, points->y()); drawPath(path); ++points; } if (capStyle == Qt::FlatCap) { setCapStyle(CapButt, d->gc); d->cpen.setCapStyle(capStyle); } return; } static const int BUF_SIZE = 1024; XPoint xPoints[BUF_SIZE]; int i = 0, j = 0; while (i < pointCount) { while (i < pointCount && j < BUF_SIZE) { const QPoint &xformed = d->matrix.map(points[i]); int x = xformed.x(); int y = xformed.y(); if (x >= SHRT_MIN && y >= SHRT_MIN && x < SHRT_MAX && y < SHRT_MAX) { xPoints[j].x = x; xPoints[j].y = y; ++j; } ++i; } if (j) XDrawPoints(d->dpy, d->hd, d->gc, xPoints, j, CoordModeOrigin); j = 0; } } void QX11PaintEngine::drawPoints(const QPointF *points, int pointCount) { Q_ASSERT(points); Q_ASSERT(pointCount); Q_D(QX11PaintEngine); if (!d->has_pen) return; // use the same test here as in drawPath to ensure that we don't use the path fallback // and end up in XDrawLines for pens with width <= 1 if (d->cpen.widthF() > 1.0f || (X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing))) || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate)) { Qt::PenCapStyle capStyle = d->cpen.capStyle(); if (capStyle == Qt::FlatCap) { setCapStyle(CapProjecting, d->gc); d->cpen.setCapStyle(Qt::SquareCap); } const QPointF *end = points + pointCount; while (points < end) { QPainterPath path; path.moveTo(*points); path.lineTo(points->x() + 0.005, points->y()); drawPath(path); ++points; } if (capStyle == Qt::FlatCap) { setCapStyle(CapButt, d->gc); d->cpen.setCapStyle(capStyle); } return; } static const int BUF_SIZE = 1024; XPoint xPoints[BUF_SIZE]; int i = 0, j = 0; while (i < pointCount) { while (i < pointCount && j < BUF_SIZE) { const QPointF &xformed = d->matrix.map(points[i]); int x = qFloor(xformed.x()); int y = qFloor(xformed.y()); if (x >= SHRT_MIN && y >= SHRT_MIN && x < SHRT_MAX && y < SHRT_MAX) { xPoints[j].x = x; xPoints[j].y = y; ++j; } ++i; } if (j) XDrawPoints(d->dpy, d->hd, d->gc, xPoints, j, CoordModeOrigin); j = 0; } } QPainter::RenderHints QX11PaintEngine::supportedRenderHints() const { #if !defined(QT_NO_XRENDER) if (X11->use_xrender) return QPainter::Antialiasing; #endif return QFlag(0); } void QX11PaintEngine::updateState(const QPaintEngineState &state) { Q_D(QX11PaintEngine); QPaintEngine::DirtyFlags flags = state.state(); if (flags & DirtyOpacity) { d->opacity = state.opacity(); // Force update pen/brush as to get proper alpha colors propagated flags |= DirtyPen; flags |= DirtyBrush; } if (flags & DirtyTransform) updateMatrix(state.transform()); if (flags & DirtyPen) updatePen(state.pen()); if (flags & (DirtyBrush | DirtyBrushOrigin)) updateBrush(state.brush(), state.brushOrigin()); if (flags & DirtyFont) updateFont(state.font()); if (state.state() & DirtyClipEnabled) { if (state.isClipEnabled()) { QPolygonF clip_poly_dev(d->matrix.map(painter()->clipPath().toFillPolygon())); QPolygonF clipped_poly_dev; d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev); updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), Qt::ReplaceClip); } else { updateClipRegion_dev(QRegion(), Qt::NoClip); } } if (flags & DirtyClipPath) { QPolygonF clip_poly_dev(d->matrix.map(state.clipPath().toFillPolygon())); QPolygonF clipped_poly_dev; d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev); updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon(), state.clipPath().fillRule()), state.clipOperation()); } else if (flags & DirtyClipRegion) { extern QPainterPath qt_regionToPath(const QRegion ®ion); QPainterPath clip_path = qt_regionToPath(state.clipRegion()); QPolygonF clip_poly_dev(d->matrix.map(clip_path.toFillPolygon())); QPolygonF clipped_poly_dev; d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev); updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), state.clipOperation()); } if (flags & DirtyHints) updateRenderHints(state.renderHints()); if (flags & DirtyCompositionMode) { int function = GXcopy; if (state.compositionMode() >= QPainter::RasterOp_SourceOrDestination) { switch (state.compositionMode()) { case QPainter::RasterOp_SourceOrDestination: function = GXor; break; case QPainter::RasterOp_SourceAndDestination: function = GXand; break; case QPainter::RasterOp_SourceXorDestination: function = GXxor; break; case QPainter::RasterOp_NotSourceAndNotDestination: function = GXnor; break; case QPainter::RasterOp_NotSourceOrNotDestination: function = GXnand; break; case QPainter::RasterOp_NotSourceXorDestination: function = GXequiv; break; case QPainter::RasterOp_NotSource: function = GXcopyInverted; break; case QPainter::RasterOp_SourceAndNotDestination: function = GXandReverse; break; case QPainter::RasterOp_NotSourceAndDestination: function = GXandInverted; break; default: function = GXcopy; } } #if !defined(QT_NO_XRENDER) else { d->composition_mode = qpainterOpToXrender(state.compositionMode()); } #endif XSetFunction(X11->display, d->gc, function); XSetFunction(X11->display, d->gc_brush, function); } d->decidePathFallback(); d->decideCoordAdjust(); } void QX11PaintEngine::updateRenderHints(QPainter::RenderHints hints) { Q_D(QX11PaintEngine); d->render_hints = hints; #if !defined(QT_NO_XRENDER) if (X11->use_xrender && d->picture) { XRenderPictureAttributes attrs; attrs.poly_edge = (hints & QPainter::Antialiasing) ? PolyEdgeSmooth : PolyEdgeSharp; XRenderChangePicture(d->dpy, d->picture, CPPolyEdge, &attrs); } #endif } void QX11PaintEngine::updatePen(const QPen &pen) { Q_D(QX11PaintEngine); d->cpen = pen; int cp = CapButt; int jn = JoinMiter; int ps = pen.style(); if (d->opacity < 1.0) { QColor c = d->cpen.color(); c.setAlpha(qRound(c.alpha()*d->opacity)); d->cpen.setColor(c); } d->has_pen = (ps != Qt::NoPen); d->has_alpha_pen = (pen.color().alpha() != 255); switch (pen.capStyle()) { case Qt::SquareCap: cp = CapProjecting; break; case Qt::RoundCap: cp = CapRound; break; case Qt::FlatCap: default: cp = CapButt; break; } switch (pen.joinStyle()) { case Qt::BevelJoin: jn = JoinBevel; break; case Qt::RoundJoin: jn = JoinRound; break; case Qt::MiterJoin: default: jn = JoinMiter; break; } d->adapted_pen_origin = false; char dashes[10]; // custom pen dashes int dash_len = 0; // length of dash list int xStyle = LineSolid; /* We are emulating Windows here. Windows treats cpen.width() == 1 (or 0) as a very special case. The fudge variable unifies this case with the general case. */ qreal pen_width = pen.widthF(); int scale = qRound(pen_width < 1 ? 1 : pen_width); int space = (pen_width < 1 && pen_width > 0 ? 1 : (2 * scale)); int dot = 1 * scale; int dash = 4 * scale; d->has_custom_pen = false; switch (ps) { case Qt::NoPen: case Qt::SolidLine: xStyle = LineSolid; break; case Qt::DashLine: dashes[0] = dash; dashes[1] = space; dash_len = 2; xStyle = LineOnOffDash; break; case Qt::DotLine: dashes[0] = dot; dashes[1] = space; dash_len = 2; xStyle = LineOnOffDash; break; case Qt::DashDotLine: dashes[0] = dash; dashes[1] = space; dashes[2] = dot; dashes[3] = space; dash_len = 4; xStyle = LineOnOffDash; break; case Qt::DashDotDotLine: dashes[0] = dash; dashes[1] = space; dashes[2] = dot; dashes[3] = space; dashes[4] = dot; dashes[5] = space; dash_len = 6; xStyle = LineOnOffDash; break; case Qt::CustomDashLine: d->has_custom_pen = true; break; } ulong mask = GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCCapStyle | GCJoinStyle | GCLineStyle; XGCValues vals; vals.graphics_exposures = false; if (d->pdev_depth == 1) { vals.foreground = qGray(pen.color().rgb()) > 127 ? 0 : 1; vals.background = qGray(QColor(Qt::transparent).rgb()) > 127 ? 0 : 1; } else if (d->pdev->devType() == QInternal::Pixmap && d->pdev_depth == 32 && X11->use_xrender) { vals.foreground = pen.color().rgba(); vals.background = QColor(Qt::transparent).rgba(); } else { QColormap cmap = QColormap::instance(d->scrn); vals.foreground = cmap.pixel(pen.color()); vals.background = cmap.pixel(QColor(Qt::transparent)); } vals.line_width = qRound(pen.widthF()); vals.cap_style = cp; vals.join_style = jn; vals.line_style = xStyle; XChangeGC(d->dpy, d->gc, mask, &vals); if (dash_len) { // make dash list XSetDashes(d->dpy, d->gc, 0, dashes, dash_len); } if (!d->has_clipping) { // if clipping is set the paintevent clip region is merged with the clip region QRegion sysClip = systemClip(); if (!sysClip.isEmpty()) x11SetClipRegion(d->dpy, d->gc, 0, d->picture, sysClip); else x11ClearClipRegion(d->dpy, d->gc, 0, d->picture); } } void QX11PaintEngine::updateBrush(const QBrush &brush, const QPointF &origin) { Q_D(QX11PaintEngine); d->cbrush = brush; d->bg_origin = origin; d->adapted_brush_origin = false; #if !defined(QT_NO_XRENDER) d->current_brush = 0; #endif if (d->opacity < 1.0) { QColor c = d->cbrush.color(); c.setAlpha(qRound(c.alpha()*d->opacity)); d->cbrush.setColor(c); } int s = FillSolid; int bs = d->cbrush.style(); d->has_brush = (bs != Qt::NoBrush); d->has_pattern = bs >= Qt::Dense1Pattern && bs <= Qt::DiagCrossPattern; d->has_texture = bs == Qt::TexturePattern; d->has_alpha_brush = brush.color().alpha() != 255; d->has_alpha_texture = d->has_texture && d->cbrush.texture().hasAlphaChannel(); ulong mask = GCForeground | GCBackground | GCGraphicsExposures | GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle; XGCValues vals; vals.graphics_exposures = false; if (d->pdev_depth == 1) { vals.foreground = qGray(d->cbrush.color().rgb()) > 127 ? 0 : 1; vals.background = qGray(QColor(Qt::transparent).rgb()) > 127 ? 0 : 1; } else if (X11->use_xrender && d->pdev->devType() == QInternal::Pixmap && d->pdev_depth == 32) { vals.foreground = d->cbrush.color().rgba(); vals.background = QColor(Qt::transparent).rgba(); } else { QColormap cmap = QColormap::instance(d->scrn); vals.foreground = cmap.pixel(d->cbrush.color()); vals.background = cmap.pixel(QColor(Qt::transparent)); if (!X11->use_xrender && d->has_brush && !d->has_pattern && !brush.isOpaque()) { QPixmap pattern = qt_patternForAlpha(brush.color().alpha(), d->scrn); mask |= GCStipple; vals.stipple = pattern.handle(); s = FillStippled; d->adapted_brush_origin = true; } } vals.cap_style = CapButt; vals.join_style = JoinMiter; vals.line_style = LineSolid; if (d->has_pattern || d->has_texture) { if (bs == Qt::TexturePattern) { d->brush_pm = qt_toX11Pixmap(d->cbrush.texture()); #if !defined(QT_NO_XRENDER) if (X11->use_xrender) { XRenderPictureAttributes attrs; attrs.repeat = true; XRenderChangePicture(d->dpy, d->brush_pm.x11PictureHandle(), CPRepeat, &attrs); QX11PixmapData *data = static_cast(d->brush_pm.data); if (data->mask_picture) XRenderChangePicture(d->dpy, data->mask_picture, CPRepeat, &attrs); } #endif } else { d->brush_pm = qt_toX11Pixmap(qt_pixmapForBrush(bs, true)); } d->brush_pm.x11SetScreen(d->scrn); if (d->brush_pm.depth() == 1) { mask |= GCStipple; vals.stipple = d->brush_pm.handle(); s = FillStippled; #if !defined(QT_NO_XRENDER) if (X11->use_xrender) { d->bitmap_texture = QPixmap(d->brush_pm.size()); d->bitmap_texture.fill(Qt::transparent); d->bitmap_texture = qt_toX11Pixmap(d->bitmap_texture); d->bitmap_texture.x11SetScreen(d->scrn); ::Picture src = X11->getSolidFill(d->scrn, d->cbrush.color()); XRenderComposite(d->dpy, PictOpSrc, src, d->brush_pm.x11PictureHandle(), d->bitmap_texture.x11PictureHandle(), 0, 0, d->brush_pm.width(), d->brush_pm.height(), 0, 0, d->brush_pm.width(), d->brush_pm.height()); XRenderPictureAttributes attrs; attrs.repeat = true; XRenderChangePicture(d->dpy, d->bitmap_texture.x11PictureHandle(), CPRepeat, &attrs); d->current_brush = d->bitmap_texture.x11PictureHandle(); } #endif } else { mask |= GCTile; #ifndef QT_NO_XRENDER if (d->pdev_depth == 32 && d->brush_pm.depth() != 32) { QX11PixmapData *brushData = static_cast(d->brush_pm.data); brushData->convertToARGB32(); } #endif vals.tile = (d->brush_pm.depth() == d->pdev_depth ? d->brush_pm.handle() : static_cast(d->brush_pm.data)->x11ConvertToDefaultDepth()); s = FillTiled; #if !defined(QT_NO_XRENDER) d->current_brush = d->cbrush.texture().x11PictureHandle(); #endif } mask |= GCTileStipXOrigin | GCTileStipYOrigin; vals.ts_x_origin = qRound(origin.x()); vals.ts_y_origin = qRound(origin.y()); } #if !defined(QT_NO_XRENDER) else if (d->has_alpha_brush) { d->current_brush = X11->getSolidFill(d->scrn, d->cbrush.color()); } #endif vals.fill_style = s; XChangeGC(d->dpy, d->gc_brush, mask, &vals); if (!d->has_clipping) { QRegion sysClip = systemClip(); if (!sysClip.isEmpty()) x11SetClipRegion(d->dpy, d->gc_brush, 0, d->picture, sysClip); else x11ClearClipRegion(d->dpy, d->gc_brush, 0, d->picture); } } void QX11PaintEngine::drawEllipse(const QRectF &rect) { QRect aligned = rect.toAlignedRect(); if (aligned == rect) drawEllipse(aligned); else QPaintEngine::drawEllipse(rect); } void QX11PaintEngine::drawEllipse(const QRect &rect) { Q_D(QX11PaintEngine); QRect devclip(SHRT_MIN, SHRT_MIN, SHRT_MAX*2 - 1, SHRT_MAX*2 - 1); QRect r(rect); if (d->txop < QTransform::TxRotate) { r = d->matrix.mapRect(rect); } else if (d->txop == QTransform::TxRotate && rect.width() == rect.height()) { QPainterPath path; path.addEllipse(rect); r = d->matrix.map(path).boundingRect().toRect(); } if (d->has_alpha_brush || d->has_alpha_pen || d->has_custom_pen || (d->render_hints & QPainter::Antialiasing) || d->has_alpha_texture || devclip.intersected(r) != r || (d->has_complex_xform && !(d->has_non_scaling_xform && rect.width() == rect.height()))) { QPainterPath path; path.addEllipse(rect); drawPath(path); return; } int x = r.x(); int y = r.y(); int w = r.width(); int h = r.height(); if (w < 1 || h < 1) return; if (w == 1 && h == 1) { XDrawPoint(d->dpy, d->hd, d->has_pen ? d->gc : d->gc_brush, x, y); return; } d->setupAdaptedOrigin(rect.topLeft()); if (d->has_brush) { // draw filled ellipse XFillArc(d->dpy, d->hd, d->gc_brush, x, y, w, h, 0, 360*64); if (!d->has_pen) // make smoother outline XDrawArc(d->dpy, d->hd, d->gc_brush, x, y, w-1, h-1, 0, 360*64); } if (d->has_pen) // draw outline XDrawArc(d->dpy, d->hd, d->gc, x, y, w, h, 0, 360*64); d->resetAdaptedOrigin(); } void QX11PaintEnginePrivate::fillPolygon_translated(const QPointF *polygonPoints, int pointCount, QX11PaintEnginePrivate::GCMode gcMode, QPaintEngine::PolygonDrawMode mode) { QVarLengthArray translated_points(pointCount); QPointF offset(matrix.dx(), matrix.dy()); qreal offs = adjust_coords ? aliasedCoordinateDelta : 0.0; if (!X11->use_xrender || !(render_hints & QPainter::Antialiasing)) offset += QPointF(aliasedCoordinateDelta, aliasedCoordinateDelta); for (int i = 0; i < pointCount; ++i) { translated_points[i] = polygonPoints[i] + offset; translated_points[i].rx() = qRound(translated_points[i].x()) + offs; translated_points[i].ry() = qRound(translated_points[i].y()) + offs; } fillPolygon_dev(translated_points.data(), pointCount, gcMode, mode); } #ifndef QT_NO_XRENDER static void qt_XRenderCompositeTrapezoids(Display *dpy, int op, Picture src, Picture dst, _Xconst XRenderPictFormat *maskFormat, int xSrc, int ySrc, const XTrapezoid *traps, int size) { const int MAX_TRAPS = 50000; while (size) { int to_draw = size; if (to_draw > MAX_TRAPS) to_draw = MAX_TRAPS; XRenderCompositeTrapezoids(dpy, op, src, dst, maskFormat, xSrc, ySrc, traps, to_draw); size -= to_draw; traps += to_draw; } } #endif void QX11PaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int pointCount, QX11PaintEnginePrivate::GCMode gcMode, QPaintEngine::PolygonDrawMode mode) { Q_Q(QX11PaintEngine); int clippedCount = 0; qt_float_point *clippedPoints = 0; #ifndef QT_NO_XRENDER //can change if we switch to pen if gcMode != BrushGC bool has_fill_texture = has_texture; bool has_fill_pattern = has_pattern; ::Picture src; #endif QBrush fill; GC fill_gc; if (gcMode == BrushGC) { fill = cbrush; fill_gc = gc_brush; #ifndef QT_NO_XRENDER if (current_brush) src = current_brush; else src = X11->getSolidFill(scrn, fill.color()); #endif } else { fill = QBrush(cpen.brush()); fill_gc = gc; #ifndef QT_NO_XRENDER //we use the pens brush has_fill_texture = (fill.style() == Qt::TexturePattern); has_fill_pattern = (fill.style() >= Qt::Dense1Pattern && fill.style() <= Qt::DiagCrossPattern); if (has_fill_texture) src = fill.texture().x11PictureHandle(); else if (has_fill_pattern) src = getPatternFill(scrn, fill); else src = X11->getSolidFill(scrn, fill.color()); #endif } polygonClipper.clipPolygon((qt_float_point *) polygonPoints, pointCount, &clippedPoints, &clippedCount); #ifndef QT_NO_XRENDER bool solid_fill = fill.color().alpha() == 255; if (has_fill_texture && fill.texture().depth() == 1 && solid_fill) { has_fill_texture = false; has_fill_pattern = true; } bool antialias = render_hints & QPainter::Antialiasing; if (X11->use_xrender && picture && !has_fill_pattern && (clippedCount > 0) && (fill.style() != Qt::NoBrush) && ((has_fill_texture && fill.texture().hasAlpha()) || antialias || !solid_fill || has_alpha_pen != has_alpha_brush)) { QRect br = tessellator->tessellate((QPointF *)clippedPoints, clippedCount, mode == QPaintEngine::WindingMode); if (tessellator->size > 0) { XRenderPictureAttributes attrs; attrs.poly_edge = antialias ? PolyEdgeSmooth : PolyEdgeSharp; XRenderChangePicture(dpy, picture, CPPolyEdge, &attrs); int x_offset = int(XFixedToDouble(tessellator->traps[0].left.p1.x) - bg_origin.x()); int y_offset = int(XFixedToDouble(tessellator->traps[0].left.p1.y) - bg_origin.y()); qt_XRenderCompositeTrapezoids(dpy, composition_mode, src, picture, antialias ? XRenderFindStandardFormat(dpy, PictStandardA8) : XRenderFindStandardFormat(dpy, PictStandardA1), x_offset, y_offset, tessellator->traps, tessellator->size); tessellator->done(); } } else #endif if (fill.style() != Qt::NoBrush) { if (clippedCount > 200000) { QPolygon poly; for (int i = 0; i < clippedCount; ++i) poly << QPoint(qFloor(clippedPoints[i].x), qFloor(clippedPoints[i].y)); const QRect bounds = poly.boundingRect(); const QRect aligned = bounds & QRect(QPoint(), QSize(pdev->width(), pdev->height())); QImage img(aligned.size(), QImage::Format_ARGB32_Premultiplied); img.fill(0); QPainter painter(&img); painter.translate(-aligned.x(), -aligned.y()); painter.setPen(Qt::NoPen); painter.setBrush(fill); if (gcMode == BrushGC) painter.setBrushOrigin(q->painter()->brushOrigin()); painter.drawPolygon(poly); painter.end(); q->drawImage(aligned, img, img.rect(), Qt::AutoColor); } else if (clippedCount > 0) { QVarLengthArray xpoints(clippedCount); for (int i = 0; i < clippedCount; ++i) { xpoints[i].x = qFloor(clippedPoints[i].x); xpoints[i].y = qFloor(clippedPoints[i].y); } if (mode == QPaintEngine::WindingMode) XSetFillRule(dpy, fill_gc, WindingRule); setupAdaptedOrigin(QPoint(xpoints[0].x, xpoints[0].y)); XFillPolygon(dpy, hd, fill_gc, xpoints.data(), clippedCount, mode == QPaintEngine::ConvexMode ? Convex : Complex, CoordModeOrigin); resetAdaptedOrigin(); if (mode == QPaintEngine::WindingMode) XSetFillRule(dpy, fill_gc, EvenOddRule); } } } void QX11PaintEnginePrivate::strokePolygon_translated(const QPointF *polygonPoints, int pointCount, bool close) { QVarLengthArray translated_points(pointCount); QPointF offset(matrix.dx(), matrix.dy()); for (int i = 0; i < pointCount; ++i) translated_points[i] = polygonPoints[i] + offset; strokePolygon_dev(translated_points.data(), pointCount, close); } void QX11PaintEnginePrivate::strokePolygon_dev(const QPointF *polygonPoints, int pointCount, bool close) { int clippedCount = 0; qt_float_point *clippedPoints = 0; polygonClipper.clipPolygon((qt_float_point *) polygonPoints, pointCount, &clippedPoints, &clippedCount, close); if (clippedCount > 0) { QVarLengthArray xpoints(clippedCount); for (int i = 0; i < clippedCount; ++i) { xpoints[i].x = qRound(clippedPoints[i].x + aliasedCoordinateDelta); xpoints[i].y = qRound(clippedPoints[i].y + aliasedCoordinateDelta); } uint numberPoints = qMin(clippedCount, xlibMaxLinePoints); XPoint *pts = xpoints.data(); XDrawLines(dpy, hd, gc, pts, numberPoints, CoordModeOrigin); pts += numberPoints; clippedCount -= numberPoints; numberPoints = qMin(clippedCount, xlibMaxLinePoints-1); while (clippedCount) { XDrawLines(dpy, hd, gc, pts-1, numberPoints+1, CoordModeOrigin); pts += numberPoints; clippedCount -= numberPoints; numberPoints = qMin(clippedCount, xlibMaxLinePoints-1); } } } void QX11PaintEngine::drawPolygon(const QPointF *polygonPoints, int pointCount, PolygonDrawMode mode) { Q_D(QX11PaintEngine); if (d->use_path_fallback) { QPainterPath path(polygonPoints[0]); for (int i = 1; i < pointCount; ++i) path.lineTo(polygonPoints[i]); if (mode == PolylineMode) { QBrush oldBrush = d->cbrush; d->cbrush = QBrush(Qt::NoBrush); path.setFillRule(Qt::WindingFill); drawPath(path); d->cbrush = oldBrush; } else { path.setFillRule(mode == OddEvenMode ? Qt::OddEvenFill : Qt::WindingFill); path.closeSubpath(); drawPath(path); } return; } if (mode != PolylineMode && d->has_brush) d->fillPolygon_translated(polygonPoints, pointCount, QX11PaintEnginePrivate::BrushGC, mode); if (d->has_pen) d->strokePolygon_translated(polygonPoints, pointCount, mode != PolylineMode); } void QX11PaintEnginePrivate::fillPath(const QPainterPath &path, QX11PaintEnginePrivate::GCMode gc_mode, bool transform) { qreal offs = adjust_coords ? aliasedCoordinateDelta : 0.0; QPainterPath clippedPath; QPainterPath clipPath; clipPath.addRect(polygonClipper.boundingRect()); if (transform) clippedPath = (path*matrix).intersected(clipPath); else clippedPath = path.intersected(clipPath); QList polys = clippedPath.toFillPolygons(); for (int i = 0; i < polys.size(); ++i) { QVarLengthArray translated_points(polys.at(i).size()); for (int j = 0; j < polys.at(i).size(); ++j) { translated_points[j] = polys.at(i).at(j); if (!X11->use_xrender || !(render_hints & QPainter::Antialiasing)) { translated_points[j].rx() = qRound(translated_points[j].rx() + aliasedCoordinateDelta) + offs; translated_points[j].ry() = qRound(translated_points[j].ry() + aliasedCoordinateDelta) + offs; } } fillPolygon_dev(translated_points.data(), polys.at(i).size(), gc_mode, path.fillRule() == Qt::OddEvenFill ? QPaintEngine::OddEvenMode : QPaintEngine::WindingMode); } } void QX11PaintEngine::drawPath(const QPainterPath &path) { Q_D(QX11PaintEngine); if (path.isEmpty()) return; QTransform old_matrix = d->matrix; if (d->has_brush) d->fillPath(path, QX11PaintEnginePrivate::BrushGC, true); if (d->has_pen && ((X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing))) || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate && !d->has_non_scaling_xform) || (d->cpen.style() == Qt::CustomDashLine))) { QPainterPathStroker stroker; if (d->cpen.style() == Qt::CustomDashLine) { stroker.setDashPattern(d->cpen.dashPattern()); stroker.setDashOffset(d->cpen.dashOffset()); } else { stroker.setDashPattern(d->cpen.style()); } stroker.setCapStyle(d->cpen.capStyle()); stroker.setJoinStyle(d->cpen.joinStyle()); QPainterPath stroke; qreal width = d->cpen.widthF(); QPolygonF poly; QRectF deviceRect(0, 0, d->pdev->width(), d->pdev->height()); // necessary to get aliased alphablended primitives to be drawn correctly if (d->cpen.isCosmetic() || d->has_scaling_xform) { if (d->cpen.isCosmetic()) stroker.setWidth(width == 0 ? 1 : width); else stroker.setWidth(width * d->xform_scale); stroker.d_ptr->stroker.setClipRect(deviceRect); stroke = stroker.createStroke(path * d->matrix); if (stroke.isEmpty()) return; stroke.setFillRule(Qt::WindingFill); d->fillPath(stroke, QX11PaintEnginePrivate::PenGC, false); } else { stroker.setWidth(width); stroker.d_ptr->stroker.setClipRect(d->matrix.inverted().mapRect(deviceRect)); stroke = stroker.createStroke(path); if (stroke.isEmpty()) return; stroke.setFillRule(Qt::WindingFill); d->fillPath(stroke, QX11PaintEnginePrivate::PenGC, true); } } else if (d->has_pen) { // if we have a cosmetic pen - use XDrawLine() for speed QList polys = path.toSubpathPolygons(d->matrix); for (int i = 0; i < polys.size(); ++i) d->strokePolygon_dev(polys.at(i).data(), polys.at(i).size(), false); } } Q_GUI_EXPORT void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image, Drawable hd, GC gc, Display *dpy, Visual *visual, int depth) { Q_ASSERT(image.format() == QImage::Format_RGB32); Q_ASSERT(image.depth() == 32); XImage *xi; // Note: this code assumes either RGB or BGR, 8 bpc server layouts const uint red_mask = (uint) visual->red_mask; bool bgr_layout = (red_mask == 0xff); const int w = rect.width(); const int h = rect.height(); QImage im; int image_byte_order = ImageByteOrder(X11->display); if ((QSysInfo::ByteOrder == QSysInfo::BigEndian && ((image_byte_order == LSBFirst) || bgr_layout)) || (image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian) || (image_byte_order == LSBFirst && bgr_layout)) { im = image.copy(rect); const int iw = im.bytesPerLine() / 4; uint *data = (uint *)im.bits(); for (int i=0; i < h; i++) { uint *p = data; uint *end = p + w; if (bgr_layout && image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian) { while (p < end) { *p = ((*p << 8) & 0xffffff00) | ((*p >> 24) & 0x000000ff); p++; } } else if ((image_byte_order == LSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian) || (image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) { while (p < end) { *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000) | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff); p++; } } else if ((image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian) || (image_byte_order == LSBFirst && bgr_layout)) { while (p < end) { *p = ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff) | ((*p ) & 0xff00ff00); p++; } } data += iw; } xi = XCreateImage(dpy, visual, depth, ZPixmap, 0, (char *) im.bits(), w, h, 32, im.bytesPerLine()); } else { xi = XCreateImage(dpy, visual, depth, ZPixmap, 0, (char *) image.scanLine(rect.y())+rect.x()*sizeof(uint), w, h, 32, image.bytesPerLine()); } XPutImage(dpy, hd, gc, xi, 0, 0, pos.x(), pos.y(), w, h); xi->data = 0; // QImage owns these bits XDestroyImage(xi); } void QX11PaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags flags) { Q_D(QX11PaintEngine); if (image.format() == QImage::Format_RGB32 && d->pdev_depth >= 24 && image.depth() == 32 && r.size() == sr.size()) { int sx = qRound(sr.x()); int sy = qRound(sr.y()); int x = qRound(r.x()); int y = qRound(r.y()); int w = qRound(r.width()); int h = qRound(r.height()); qt_x11_drawImage(QRect(sx, sy, w, h), QPoint(x, y), image, d->hd, d->gc, d->dpy, (Visual *)d->xinfo->visual(), d->pdev_depth); } else { QPaintEngine::drawImage(r, image, sr, flags); } } void QX11PaintEngine::drawPixmap(const QRectF &r, const QPixmap &px, const QRectF &_sr) { Q_D(QX11PaintEngine); QRectF sr = _sr; int x = qRound(r.x()); int y = qRound(r.y()); int sx = qRound(sr.x()); int sy = qRound(sr.y()); int sw = qRound(sr.width()); int sh = qRound(sr.height()); QPixmap pixmap = qt_toX11Pixmap(px); if ((d->xinfo && d->xinfo->screen() != pixmap.x11Info().screen()) || (pixmap.x11Info().screen() != DefaultScreen(X11->display))) { QPixmap* p = const_cast(&pixmap); p->x11SetScreen(d->xinfo ? d->xinfo->screen() : DefaultScreen(X11->display)); } QPixmap::x11SetDefaultScreen(pixmap.x11Info().screen()); #ifndef QT_NO_XRENDER ::Picture src_pict = static_cast(pixmap.data)->picture; if (src_pict && d->picture) { const int pDepth = pixmap.depth(); if (pDepth == 1 && (d->has_alpha_pen)) { qt_render_bitmap(d->dpy, d->scrn, src_pict, d->picture, sx, sy, x, y, sw, sh, d->cpen); return; } else if (pDepth != 1 && (pDepth == 32 || pDepth != d->pdev_depth)) { XRenderComposite(d->dpy, d->composition_mode, src_pict, 0, d->picture, sx, sy, 0, 0, x, y, sw, sh); return; } } #endif bool mono_src = pixmap.depth() == 1; bool mono_dst = d->pdev_depth == 1; bool restore_clip = false; if (static_cast(pixmap.data)->x11_mask) { // pixmap has a mask QBitmap comb(sw, sh); GC cgc = XCreateGC(d->dpy, comb.handle(), 0, 0); XSetForeground(d->dpy, cgc, 0); XFillRectangle(d->dpy, comb.handle(), cgc, 0, 0, sw, sh); XSetBackground(d->dpy, cgc, 0); XSetForeground(d->dpy, cgc, 1); if (!d->crgn.isEmpty()) { int num; XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num); XSetClipRectangles(d->dpy, cgc, -x, -y, rects, num, Unsorted); } else if (d->has_clipping) { XSetClipRectangles(d->dpy, cgc, 0, 0, 0, 0, Unsorted); } XSetFillStyle(d->dpy, cgc, FillOpaqueStippled); XSetTSOrigin(d->dpy, cgc, -sx, -sy); XSetStipple(d->dpy, cgc, static_cast(pixmap.data)->x11_mask); XFillRectangle(d->dpy, comb.handle(), cgc, 0, 0, sw, sh); XFreeGC(d->dpy, cgc); XSetClipOrigin(d->dpy, d->gc, x, y); XSetClipMask(d->dpy, d->gc, comb.handle()); restore_clip = true; } if (mono_src) { if (!d->crgn.isEmpty()) { Pixmap comb = XCreatePixmap(d->dpy, d->hd, sw, sh, 1); GC cgc = XCreateGC(d->dpy, comb, 0, 0); XSetForeground(d->dpy, cgc, 0); XFillRectangle(d->dpy, comb, cgc, 0, 0, sw, sh); int num; XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num); XSetClipRectangles(d->dpy, cgc, -x, -y, rects, num, Unsorted); XCopyArea(d->dpy, pixmap.handle(), comb, cgc, sx, sy, sw, sh, 0, 0); XFreeGC(d->dpy, cgc); XSetClipMask(d->dpy, d->gc, comb); XSetClipOrigin(d->dpy, d->gc, x, y); XFreePixmap(d->dpy, comb); } else { XSetClipMask(d->dpy, d->gc, pixmap.handle()); XSetClipOrigin(d->dpy, d->gc, x - sx, y - sy); } if (mono_dst) { XSetForeground(d->dpy, d->gc, qGray(d->cpen.color().rgb()) > 127 ? 0 : 1); } else { QColormap cmap = QColormap::instance(d->scrn); XSetForeground(d->dpy, d->gc, cmap.pixel(d->cpen.color())); } XFillRectangle(d->dpy, d->hd, d->gc, x, y, sw, sh); restore_clip = true; } else { XCopyArea(d->dpy, pixmap.handle(), d->hd, d->gc, sx, sy, sw, sh, x, y); } if (d->pdev->devType() == QInternal::Pixmap) { const QPixmap *px = static_cast(d->pdev); Pixmap src_mask = static_cast(pixmap.data)->x11_mask; Pixmap dst_mask = static_cast(px->data)->x11_mask; if (dst_mask) { GC cgc = XCreateGC(d->dpy, dst_mask, 0, 0); if (src_mask) { // copy src mask into dst mask XCopyArea(d->dpy, src_mask, dst_mask, cgc, sx, sy, sw, sh, x, y); } else { // no src mask, but make sure the area copied is opaque in dest XSetBackground(d->dpy, cgc, 0); XSetForeground(d->dpy, cgc, 1); XFillRectangle(d->dpy, dst_mask, cgc, x, y, sw, sh); } XFreeGC(d->dpy, cgc); } } if (restore_clip) { XSetClipOrigin(d->dpy, d->gc, 0, 0); int num; XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num); if (num == 0) XSetClipMask(d->dpy, d->gc, XNone); else XSetClipRectangles(d->dpy, d->gc, 0, 0, rects, num, Unsorted); } } void QX11PaintEngine::updateMatrix(const QTransform &mtx) { Q_D(QX11PaintEngine); d->txop = mtx.type(); d->matrix = mtx; d->has_complex_xform = (d->txop > QTransform::TxTranslate); extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); bool scaling = qt_scaleForTransform(d->matrix, &d->xform_scale); d->has_scaling_xform = scaling && d->xform_scale != 1.0; d->has_non_scaling_xform = scaling && d->xform_scale == 1.0; } /* NB! the clip region is expected to be in dev coordinates */ void QX11PaintEngine::updateClipRegion_dev(const QRegion &clipRegion, Qt::ClipOperation op) { Q_D(QX11PaintEngine); QRegion sysClip = systemClip(); if (op == Qt::NoClip) { d->has_clipping = false; d->crgn = sysClip; if (!sysClip.isEmpty()) { x11SetClipRegion(d->dpy, d->gc, d->gc_brush, d->picture, sysClip); } else { x11ClearClipRegion(d->dpy, d->gc, d->gc_brush, d->picture); } return; } switch (op) { case Qt::IntersectClip: if (d->has_clipping) { d->crgn &= clipRegion; break; } // fall through case Qt::ReplaceClip: if (!sysClip.isEmpty()) d->crgn = clipRegion.intersected(sysClip); else d->crgn = clipRegion; break; case Qt::UniteClip: d->crgn |= clipRegion; if (!sysClip.isEmpty()) d->crgn = d->crgn.intersected(sysClip); break; default: break; } d->has_clipping = true; x11SetClipRegion(d->dpy, d->gc, d->gc_brush, d->picture, d->crgn); } void QX11PaintEngine::updateFont(const QFont &) { } Qt::HANDLE QX11PaintEngine::handle() const { Q_D(const QX11PaintEngine); Q_ASSERT(isActive()); Q_ASSERT(d->hd); return d->hd; } extern void qt_draw_tile(QPaintEngine *, qreal, qreal, qreal, qreal, const QPixmap &, qreal, qreal); void QX11PaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &p) { int x = qRound(r.x()); int y = qRound(r.y()); int w = qRound(r.width()); int h = qRound(r.height()); int sx = qRound(p.x()); int sy = qRound(p.y()); bool mono_src = pixmap.depth() == 1; Q_D(QX11PaintEngine); if ((d->xinfo && d->xinfo->screen() != pixmap.x11Info().screen()) || (pixmap.x11Info().screen() != DefaultScreen(X11->display))) { QPixmap* p = const_cast(&pixmap); p->x11SetScreen(d->xinfo ? d->xinfo->screen() : DefaultScreen(X11->display)); } QPixmap::x11SetDefaultScreen(pixmap.x11Info().screen()); #ifndef QT_NO_XRENDER if (X11->use_xrender && d->picture && pixmap.x11PictureHandle()) { #if 0 // ### Qt 5: enable this XRenderPictureAttributes attrs; attrs.repeat = true; XRenderChangePicture(d->dpy, pixmap.x11PictureHandle(), CPRepeat, &attrs); if (mono_src) { qt_render_bitmap(d->dpy, d->scrn, pixmap.x11PictureHandle(), d->picture, sx, sy, x, y, w, h, d->cpen); } else { XRenderComposite(d->dpy, d->composition_mode, pixmap.x11PictureHandle(), XNone, d->picture, sx, sy, 0, 0, x, y, w, h); } #else const int numTiles = (w / pixmap.width()) * (h / pixmap.height()); if (numTiles < 100) { // this is essentially qt_draw_tile(), inlined for // the XRenderComposite call int yPos, xPos, drawH, drawW, yOff, xOff; yPos = y; yOff = sy; while(yPos < y + h) { drawH = pixmap.height() - yOff; // Cropping first row if (yPos + drawH > y + h) // Cropping last row drawH = y + h - yPos; xPos = x; xOff = sx; while(xPos < x + w) { drawW = pixmap.width() - xOff; // Cropping first column if (xPos + drawW > x + w) // Cropping last column drawW = x + w - xPos; if (mono_src) { qt_render_bitmap(d->dpy, d->scrn, pixmap.x11PictureHandle(), d->picture, xOff, yOff, xPos, yPos, drawW, drawH, d->cpen); } else { XRenderComposite(d->dpy, d->composition_mode, pixmap.x11PictureHandle(), XNone, d->picture, xOff, yOff, 0, 0, xPos, yPos, drawW, drawH); } xPos += drawW; xOff = 0; } yPos += drawH; yOff = 0; } } else { w = qMin(w, d->pdev->width() - x); h = qMin(h, d->pdev->height() - y); if (w <= 0 || h <= 0) return; const int pw = w + sx; const int ph = h + sy; QPixmap pm(pw, ph); if (pixmap.hasAlpha() || mono_src) pm.fill(Qt::transparent); const int mode = pixmap.hasAlpha() ? PictOpOver : PictOpSrc; const ::Picture pmPicture = pm.x11PictureHandle(); // first tile XRenderComposite(d->dpy, mode, pixmap.x11PictureHandle(), XNone, pmPicture, 0, 0, 0, 0, 0, 0, qMin(pw, pixmap.width()), qMin(ph, pixmap.height())); // first row of tiles int xPos = pixmap.width(); const int sh = qMin(ph, pixmap.height()); while (xPos < pw) { const int sw = qMin(xPos, pw - xPos); XRenderComposite(d->dpy, mode, pmPicture, XNone, pmPicture, 0, 0, 0, 0, xPos, 0, sw, sh); xPos *= 2; } // remaining rows int yPos = pixmap.height(); const int sw = pw; while (yPos < ph) { const int sh = qMin(yPos, ph - yPos); XRenderComposite(d->dpy, mode, pmPicture, XNone, pmPicture, 0, 0, 0, 0, 0, yPos, sw, sh); yPos *= 2; } // composite if (mono_src) qt_render_bitmap(d->dpy, d->scrn, pmPicture, d->picture, sx, sy, x, y, w, h, d->cpen); else XRenderComposite(d->dpy, d->composition_mode, pmPicture, XNone, d->picture, sx, sy, 0, 0, x, y, w, h); } #endif } else #endif // !QT_NO_XRENDER if (pixmap.depth() > 1 && !static_cast(pixmap.data)->x11_mask) { XSetTile(d->dpy, d->gc, pixmap.handle()); XSetFillStyle(d->dpy, d->gc, FillTiled); XSetTSOrigin(d->dpy, d->gc, x-sx, y-sy); XFillRectangle(d->dpy, d->hd, d->gc, x, y, w, h); XSetTSOrigin(d->dpy, d->gc, 0, 0); XSetFillStyle(d->dpy, d->gc, FillSolid); } else { qt_draw_tile(this, x, y, w, h, pixmap, sx, sy); } } void QX11PaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem) { const QTextItemInt &ti = static_cast(textItem); switch(ti.fontEngine->type()) { case QFontEngine::TestFontEngine: case QFontEngine::Box: d_func()->drawBoxTextItem(p, ti); break; case QFontEngine::XLFD: drawXLFD(p, ti); break; #ifndef QT_NO_FONTCONFIG case QFontEngine::Freetype: drawFreetype(p, ti); break; #endif default: Q_ASSERT(false); } } void QX11PaintEngine::drawXLFD(const QPointF &p, const QTextItemInt &ti) { Q_D(QX11PaintEngine); if (d->txop > QTransform::TxTranslate) { // XServer or font don't support server side transformations, need to do it by hand QPaintEngine::drawTextItem(p, ti); return; } if (!ti.glyphs.numGlyphs) return; QVarLengthArray positions; QVarLengthArray glyphs; QTransform matrix = d->matrix; matrix.translate(p.x(), p.y()); ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions); if (glyphs.size() == 0) return; QFontEngineXLFD *xlfd = static_cast(ti.fontEngine); Qt::HANDLE font_id = xlfd->fontStruct()->fid; XSetFont(d->dpy, d->gc, font_id); const QFixed offs = QFixed::fromReal(aliasedCoordinateDelta); for (int i = 0; i < glyphs.size(); i++) { int xp = qRound(positions[i].x + offs); int yp = qRound(positions[i].y + offs); if (xp < SHRT_MAX && xp > SHRT_MIN && yp > SHRT_MIN && yp < SHRT_MAX) { XChar2b ch; ch.byte1 = glyphs[i] >> 8; ch.byte2 = glyphs[i] & 0xff; XDrawString16(d->dpy, d->hd, d->gc, xp, yp, &ch, 1); } } } #ifndef QT_NO_FONTCONFIG static QPainterPath path_for_glyphs(const QVarLengthArray &glyphs, const QVarLengthArray &positions, const QFontEngineFT *ft) { QPainterPath path; path.setFillRule(Qt::WindingFill); ft->lockFace(); int i = 0; while (i < glyphs.size()) { QFontEngineFT::Glyph *glyph = ft->loadGlyph(glyphs[i], QFontEngineFT::Format_Mono); // #### fix case where we don't get a glyph if (!glyph) break; Q_ASSERT(glyph->format == QFontEngineFT::Format_Mono); int n = 0; int h = glyph->height; int xp = qRound(positions[i].x); int yp = qRound(positions[i].y); xp += glyph->x; yp += -glyph->y + glyph->height; int pitch = ((glyph->width + 31) & ~31) >> 3; uchar *src = glyph->data; while (h--) { for (int x = 0; x < glyph->width; ++x) { bool set = src[x >> 3] & (0x80 >> (x & 7)); if (set) { QRect r(xp + x, yp - h, 1, 1); while (x < glyph->width-1 && src[(x+1) >> 3] & (0x80 >> ((x+1) & 7))) { ++x; r.setRight(r.right()+1); } path.addRect(r); ++n; } } src += pitch; } ++i; } ft->unlockFace(); return path; } void QX11PaintEngine::drawFreetype(const QPointF &p, const QTextItemInt &ti) { Q_D(QX11PaintEngine); if (!ti.glyphs.numGlyphs) return; QFontEngineX11FT *ft = static_cast(ti.fontEngine); if (!d->cpen.isSolid()) { QPaintEngine::drawTextItem(p, ti); return; } const bool xrenderPath = (X11->use_xrender && !(d->pdev->devType() == QInternal::Pixmap && static_cast(d->pdev)->data->pixelType() == QPixmapData::BitmapType)); QVarLengthArray positions; QVarLengthArray glyphs; QTransform matrix; if (xrenderPath) matrix = d->matrix; matrix.translate(p.x(), p.y()); ft->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions); if (glyphs.count() == 0) return; #ifndef QT_NO_XRENDER QFontEngineFT::QGlyphSet *set = ft->defaultGlyphs(); if (d->txop >= QTransform::TxScale && xrenderPath) set = ft->loadTransformedGlyphSet(d->matrix); if (!set || set->outline_drawing || !ft->loadGlyphs(set, glyphs.data(), glyphs.size(), QFontEngineFT::Format_Render)) { QPaintEngine::drawTextItem(p, ti); return; } if (xrenderPath) { GlyphSet glyphSet = set->id; const QColor &pen = d->cpen.color(); ::Picture src = X11->getSolidFill(d->scrn, pen); XRenderPictFormat *maskFormat = 0; if (ft->xglyph_format != PictStandardA1) maskFormat = XRenderFindStandardFormat(X11->display, ft->xglyph_format); enum { t_min = SHRT_MIN, t_max = SHRT_MAX }; int i = 0; for (; i < glyphs.size() && (positions[i].x < t_min || positions[i].x > t_max || positions[i].y < t_min || positions[i].y > t_max); ++i) ; if (i >= glyphs.size()) return; ++i; QFixed xp = positions[i - 1].x; QFixed yp = positions[i - 1].y; QFixed offs = QFixed::fromReal(aliasedCoordinateDelta); XGlyphElt32 elt; elt.glyphset = glyphSet; elt.chars = &glyphs[i - 1]; elt.nchars = 1; elt.xOff = qRound(xp + offs); elt.yOff = qRound(yp + offs); for (; i < glyphs.size(); ++i) { if (positions[i].x < t_min || positions[i].x > t_max || positions[i].y < t_min || positions[i].y > t_max) { break; } QFontEngineFT::Glyph *g = ft->cachedGlyph(glyphs[i - 1]); if (g && positions[i].x == xp + g->advance && positions[i].y == yp && elt.nchars < 253 // don't draw more than 253 characters as some X servers // hang with it ) { elt.nchars++; xp += g->advance; } else { xp = positions[i].x; yp = positions[i].y; XRenderCompositeText32(X11->display, PictOpOver, src, d->picture, maskFormat, 0, 0, 0, 0, &elt, 1); elt.chars = &glyphs[i]; elt.nchars = 1; elt.xOff = qRound(xp + offs); elt.yOff = qRound(yp + offs); } } XRenderCompositeText32(X11->display, PictOpOver, src, d->picture, maskFormat, 0, 0, 0, 0, &elt, 1); return; } #endif QPainterPath path = path_for_glyphs(glyphs, positions, ft); if (path.elementCount() <= 1) return; Q_ASSERT((path.elementCount() % 5) == 0); if (d->txop >= QTransform::TxScale) { painter()->save(); painter()->setBrush(d->cpen.brush()); painter()->setPen(Qt::NoPen); painter()->drawPath(path); painter()->restore(); return; } const int rectcount = 256; XRectangle rects[rectcount]; int num_rects = 0; for (int i=0; i < path.elementCount(); i+=5) { int x = qRound(path.elementAt(i).x); int y = qRound(path.elementAt(i).y); int w = qRound(path.elementAt(i+1).x) - x; int h = qRound(path.elementAt(i+2).y) - y; rects[num_rects].x = x + qRound(d->matrix.dx()); rects[num_rects].y = y + qRound(d->matrix.dy()); rects[num_rects].width = w; rects[num_rects].height = h; ++num_rects; if (num_rects == rectcount) { XFillRectangles(d->dpy, d->hd, d->gc, rects, num_rects); num_rects = 0; } } if (num_rects > 0) XFillRectangles(d->dpy, d->hd, d->gc, rects, num_rects); } #endif // !QT_NO_XRENDER QT_END_NAMESPACE