qpaintengine_x11.cpp File Reference

#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 <qmath.h>
#include "qpainter_p.h"
#include <qtextlayout.h>
#include <qvarlengtharray.h>
#include <private/qfont_p.h>
#include <private/qtextengine_p.h>
#include <private/qpaintengine_x11_p.h>
#include <private/qfontengine_x11_p.h>
#include <private/qwidget_p.h>
#include <private/qpainterpath_p.h>
#include "qpen.h"
#include "qcolor.h"
#include "qcolormap.h"
#include <private/qpaintengine_p.h>
#include "qpaintengine_x11_p.h"
#include <private/qt_x11_p.h>
#include <private/qnumeric_p.h>
#include <limits.h>
#include <private/qtessellator_p.h>
#include <private/qstylehelper_p.h>

Go to the source code of this file.

Classes
class	QXRenderTessellator

Macros
#define	DITHER_SIZE   16
#define	X11   qt_x11Data

Functions
static bool	clipLine (QLineF *line, const QRect &rect)
static QLine	clipStraightLine (const QRect &clip, const QLine &l)
static bool	complexPictOp (int op)
static Picture	getPatternFill (int screen, const QBrush &b)
static QPainterPath	path_for_glyphs (const QVarLengthArray< glyph_t > &glyphs, const QVarLengthArray< QFixedPoint > &positions, const QFontEngineFT *ft)
static int	qpainterOpToXrender (QPainter::CompositionMode mode)
static QPaintEngine::PaintEngineFeatures	qt_decide_features ()
void	qt_draw_tile (QPaintEngine *, qreal, qreal, qreal, qreal, const QPixmap &, qreal, qreal)
Q_GUI_EXPORT void *	qt_getClipRects (const QRegion &r, int &num)
static QPixmap	qt_patternForAlpha (uchar alpha, int screen)
QPixmap	qt_pixmapForBrush (int brushStyle, bool invert)
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)
QPixmap	qt_toX11Pixmap (const QPixmap &pixmap)
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_GUI_EXPORT GC	qt_x11_get_brush_gc (QPainter *p)
	Returns the X11 specific brush GC for the painter p. More...
Q_GUI_EXPORT GC	qt_x11_get_pen_gc (QPainter *p)
	Returns the X11 specific pen GC for the painter p. More...
Drawable	qt_x11Handle (const QPaintDevice *pd)
	Returns the X11 Drawable of the paint device. More...
const QX11Info *	qt_x11Info (const QPaintDevice *pd)
static void	qt_XRenderCompositeTrapezoids (Display *dpy, int op, Picture src, Picture dst, _Xconst XRenderPictFormat *maskFormat, int xSrc, int ySrc, const XTrapezoid *traps, int size)
static void	setCapStyle (int cap_style, GC gc)
static void	x11ClearClipRegion (Display *dpy, GC gc, GC gc2, Picture picture)
static void	x11SetClipRegion (Display *dpy, GC gc, GC gc2, Picture picture, const QRegion &r)

Variables
static const qreal	aliasedCoordinateDelta = 0.5 - 0.015625
static const uchar	base_dither_matrix [DITHER_SIZE][DITHER_SIZE]
static const int	compositionModeToRenderOp [QPainter::CompositionMode_Xor+1]

Macro Definition Documentation

DITHER_SIZE

#define DITHER_SIZE   16

Definition at line 211 of file qpaintengine_x11.cpp.

Referenced by qt_patternForAlpha().

X11

#define X11   qt_x11Data

Definition at line 124 of file qpaintengine_x11.cpp.

Referenced by getPatternFill(), qt_decide_features(), and qt_render_bitmap().

Function Documentation

clipLine()

static bool clipLine ( QLineF *  line, const QRect &  rect  )

static

Definition at line 604 of file qpaintengine_x11.cpp.

Referenced by QCosmeticStroker::calculateLastPoint(), and QX11PaintEngine::drawLines().

{
    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;
}

clipStraightLine()

static QLine clipStraightLine ( const QRect &  clip, const QLine &  l  )

inlinestatic

Definition at line 749 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawRects().

{
    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);
    }
}

complexPictOp()

static bool complexPictOp ( int  op )

inlinestatic

Definition at line 148 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawRects().

{
    return op != PictOpOver && op != PictOpSrc;
}

getPatternFill()

static Picture getPatternFill ( int  screen, const QBrush &  b  )

static

Definition at line 303 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEnginePrivate::fillPolygon_dev().

{
    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 = qrand() % 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;
}

path_for_glyphs()

static QPainterPath path_for_glyphs ( const QVarLengthArray< glyph_t > &  glyphs, const QVarLengthArray< QFixedPoint > &  positions, const QFontEngineFT *  ft  )

static

Definition at line 2315 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawFreetype().

{
    QPainterPath path;
    path.setFillRule(Qt::WindingFill);
    ft->lockFace();
    int i = 0;
    while (i < glyphs.size()) {
        QFontEngineFT::Glyph *glyph = ft->loadGlyph(glyphs[i], 0, 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+1 < glyph->width && 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;
}

qpainterOpToXrender()

static int qpainterOpToXrender ( QPainter::CompositionMode  mode )

inlinestatic

Definition at line 142 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::updateState().

{
    Q_ASSERT(mode <= QPainter::CompositionMode_Xor);
    return compositionModeToRenderOp[mode];
}

qt_decide_features()

static QPaintEngine::PaintEngineFeatures qt_decide_features ( )

static

Definition at line 433 of file qpaintengine_x11.cpp.

{
    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;
}

qt_draw_tile()

void qt_draw_tile	(	QPaintEngine *	,
		qreal	,
		qreal	,
		qreal	,
		qreal	,
		const QPixmap &	,
		qreal	,
		qreal
	)

Definition at line 600 of file qpaintengine.cpp.

Referenced by QX11PaintEngine::drawTiledPixmap(), QPaintEngine::drawTiledPixmap(), and QX11PaintEngine::handle().

{
    qreal yPos, xPos, drawH, drawW, yOff, xOff;
    yPos = y;
    yOff = yOffset;
    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 = xOffset;
        while(xPos < x + w) {
            drawW = pixmap.width() - xOff; // Cropping first column
            if (xPos + drawW > x + w)           // Cropping last column
                drawW = x + w - xPos;
            if (drawW > 0 && drawH > 0)
                gc->drawPixmap(QRectF(xPos, yPos, drawW, drawH), pixmap, QRectF(xOff, yOff, drawW, drawH));
            xPos += drawW;
            xOff = 0;
        }
        yPos += drawH;
        yOff = 0;
    }
}

qt_getClipRects()

Q_GUI_EXPORT void* qt_getClipRects	(	const QRegion &	r,
		int &	num
	)

Definition at line 156 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawPixmap(), QX11GLWindowSurface::flush(), QX11WindowSurface::flush(), QRasterWindowSurface::flush(), QRegion::operator!=(), QX11GLWindowSurface::paintDevice(), QX11WindowSurface::setGeometry(), and x11SetClipRegion().

{
    return r.clipRectangles(num);
}

qt_patternForAlpha()

static QPixmap qt_patternForAlpha ( uchar  alpha, int  screen  )

static

Definition at line 231 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::updateBrush().

{
    QPixmap pm;
    QString key = QLatin1Literal("$qt-alpha-brush$")
                  % HexString<uchar>(alpha)
                  % HexString<int>(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;
}

qt_pixmapForBrush()

QPixmap qt_pixmapForBrush	(	int	brushStyle,
		bool	invert
	)

Definition at line 99 of file qbrush.cpp.

Referenced by getPatternFill(), and QX11PaintEngine::updateBrush().

{

    QPixmap pm;
    QString key = QLatin1Literal("$qt-brush$")
                  % HexString<uint>(brushStyle)
                  % QLatin1Char(invert ? '1' : '0');
    if (!QPixmapCache::find(key, pm)) {
        pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
                               QImage::Format_MonoLSB);
        QPixmapCache::insert(key, pm);
    }

    return pm;
}

qt_render_bitmap()

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  )

static

Definition at line 366 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawPixmap(), and QX11PaintEngine::drawTiledPixmap().

{
    Picture fill_fg = X11->getSolidFill(scrn, pen.color());
    XRenderComposite(dpy, PictOpOver,
                     fill_fg, src, dst, sx, sy, sx, sy, x, y, sw, sh);
}

qt_toX11Pixmap()

QPixmap qt_toX11Pixmap

(

const QPixmap &

pixmap

)

Definition at line 93 of file qpixmap_x11.cpp.

Referenced by QX11PaintEngine::drawPixmap(), and QX11PaintEngine::updateBrush().

{
    if (pixmap.isNull())
        return QPixmap();

    if (QPixmap(pixmap).data_ptr()->classId() == QPixmapData::X11Class)
        return pixmap;

    return qt_toX11Pixmap(pixmap.toImage());
}

qt_x11_drawImage()

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
	)

Definition at line 1833 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawImage(), and QRasterWindowSurface::flush().

{
    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);
}

qt_x11_get_brush_gc()

Q_GUI_EXPORT GC qt_x11_get_brush_gc

(

QPainter *

p

)

Returns the X11 specific brush GC for the painter p.

Note that QPainter::begin() must be called before this function returns a valid GC.

Definition at line 115 of file qpaintengine_x11.cpp.

{
    if (p && p->paintEngine()
        && p->paintEngine()->isActive()
        && p->paintEngine()->type() == QPaintEngine::X11) {
        return static_cast<QX11PaintEngine *>(p->paintEngine())->d_func()->gc_brush;
    }
    return 0;
}

qt_x11_get_pen_gc()

Q_GUI_EXPORT GC qt_x11_get_pen_gc

(

QPainter *

p

)

Returns the X11 specific pen GC for the painter p.

Note that QPainter::begin() must be called before this function returns a valid GC.

Definition at line 100 of file qpaintengine_x11.cpp.

{
    if (p && p->paintEngine()
        && p->paintEngine()->isActive()
        && p->paintEngine()->type() == QPaintEngine::X11) {
        return static_cast<QX11PaintEngine *>(p->paintEngine())->d_func()->gc;
    }
    return 0;
}

qt_x11Handle()

Drawable qt_x11Handle

(

const QPaintDevice *

pd

)

Returns the X11 Drawable of the paint device.

Warning

This function is not part of the public interface.

0 is returned if it can't be obtained.

Definition at line 61 of file qpaintdevice_x11.cpp.

Referenced by QX11PaintEngine::begin().

{
    if (!pd) return 0;
    if (pd->devType() == QInternal::Widget)
        return static_cast<const QWidget *>(pd)->handle();
    else if (pd->devType() == QInternal::Pixmap)
        return static_cast<const QPixmap *>(pd)->handle();
    return 0;
}

qt_x11Info()

const QX11Info* qt_x11Info ( const QPaintDevice *  pd )

related

Referenced by QX11PaintEngine::begin().

qt_XRenderCompositeTrapezoids()

static void qt_XRenderCompositeTrapezoids ( Display *  dpy, int  op, Picture  src, Picture  dst, _Xconst XRenderPictFormat *  maskFormat, int  xSrc, int  ySrc, const XTrapezoid *  traps, int  size  )

static

Definition at line 1538 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEnginePrivate::fillPolygon_dev().

{
    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;
    }
}

setCapStyle()

static void setCapStyle ( int  cap_style, GC  gc  )

inlinestatic

Definition at line 944 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawPoints(), and QPen::swap().

{
    ulong mask = GCCapStyle;
    XGCValues vals;
    vals.cap_style = cap_style;
    XChangeGC(X11->display, gc, mask, &vals);
}

x11ClearClipRegion()

static void x11ClearClipRegion ( Display *  dpy, GC  gc, GC  gc2, Picture  picture  )

inlinestatic

Definition at line 186 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::updateBrush(), QX11PaintEngine::updateClipRegion_dev(), and QX11PaintEngine::updatePen().

{
    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
}

x11SetClipRegion()

static void x11SetClipRegion ( Display *  dpy, GC  gc, GC  gc2, Picture  picture, const QRegion &  r  )

inlinestatic

Definition at line 161 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::updateBrush(), QX11PaintEngine::updateClipRegion_dev(), and QX11PaintEngine::updatePen().

{
    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
}

Variable Documentation

aliasedCoordinateDelta

const qreal aliasedCoordinateDelta = 0.5 - 0.015625

static

Definition at line 92 of file qpaintengine_x11.cpp.

Referenced by QX11PaintEngine::drawFreetype(), QX11PaintEngine::drawLines(), QX11PaintEngine::drawXLFD(), QX11PaintEnginePrivate::fillPath(), QX11PaintEnginePrivate::fillPolygon_translated(), and QX11PaintEnginePrivate::strokePolygon_dev().

base_dither_matrix

const uchar base_dither_matrix[DITHER_SIZE][DITHER_SIZE]

static

Initial value:

= {
  {   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 }
}

Definition at line 212 of file qpaintengine_x11.cpp.

Referenced by qt_patternForAlpha().

compositionModeToRenderOp

const int compositionModeToRenderOp[QPainter::CompositionMode_Xor+1]

static

Initial value:

= {
    PictOpOver, 
    PictOpOverReverse, 
    PictOpClear, 
    PictOpSrc, 
    PictOpDst, 
    PictOpIn, 
    PictOpInReverse, 
    PictOpOut, 
    PictOpOutReverse, 
    PictOpAtop, 
    PictOpAtopReverse, 
    PictOpXor 
}

Definition at line 127 of file qpaintengine_x11.cpp.

Referenced by qpainterOpToXrender().