QX11PaintEngine Class Reference

#include <qpaintengine_x11_p.h>

Inheritance diagram for QX11PaintEngine:

[legend]Collaboration diagram for QX11PaintEngine:

[legend]List of all members.

---

Detailed Description

Definition at line 56 of file qpaintengine_x11_p.h.

Public Member Functions
	QX11PaintEngine ()
	~QX11PaintEngine ()
bool	begin (QPaintDevice *pdev)
bool	end ()
void	updateState (const QPaintEngineState &state)
void	updatePen (const QPen &pen)
void	updateBrush (const QBrush &brush, const QPointF &pt)
void	updateRenderHints (QPainter::RenderHints hints)
void	updateFont (const QFont &font)
void	updateMatrix (const QMatrix &matrix)
void	updateClipRegion_dev (const QRegion &region, Qt::ClipOperation op)
void	drawLines (const QLine *lines, int lineCount)
void	drawLines (const QLineF *lines, int lineCount)
void	drawRects (const QRect *rects, int rectCount)
void	drawRects (const QRectF *rects, int rectCount)
void	drawPoints (const QPoint *points, int pointCount)
void	drawPoints (const QPointF *points, int pointCount)
void	drawEllipse (const QRect &r)
void	drawEllipse (const QRectF &r)
virtual void	drawPolygon (const QPointF *points, int pointCount, PolygonDrawMode mode)
void	drawPolygon (const QPoint *points, int pointCount, PolygonDrawMode mode)
void	drawPixmap (const QRectF &r, const QPixmap &pm, const QRectF &sr)
void	drawTiledPixmap (const QRectF &r, const QPixmap &pixmap, const QPointF &s)
void	drawPath (const QPainterPath &path)
void	drawTextItem (const QPointF &p, const QTextItem &textItem)
void	drawImage (const QRectF &r, const QImage &img, const QRectF &sr, Qt::ImageConversionFlags flags=Qt::AutoColor)
virtual Qt::HANDLE	handle () const
Type	type () const
QPainter::RenderHints	supportedRenderHints () const
Protected Member Functions
	QX11PaintEngine (QX11PaintEnginePrivate &dptr)
void	drawBox (const QPointF &p, const QTextItemInt &si)
void	drawXLFD (const QPointF &p, const QTextItemInt &si)
void	drawFreetype (const QPointF &p, const QTextItemInt &si)
void	core_render_glyph (QFontEngineFT *fe, int xp, int yp, uint glyph)
Friends
class	QPixmap
class	QFontEngineBox
Q_GUI_EXPORT GC	qt_x11_get_pen_gc (QPainter *)
Q_GUI_EXPORT GC	qt_x11_get_brush_gc (QPainter *)

---

Constructor & Destructor Documentation

QX11PaintEngine::QX11PaintEngine

(

)

Definition at line 689 of file qpaintengine_x11.cpp.

    : QPaintEngine(*(new QX11PaintEnginePrivate), qt_decide_features())
{
    d_func()->init();
}

QX11PaintEngine::~QX11PaintEngine

(

)

Definition at line 701 of file qpaintengine_x11.cpp.

{
}

QX11PaintEngine::QX11PaintEngine

(

QX11PaintEnginePrivate &

dptr

)

[protected]

Definition at line 695 of file qpaintengine_x11.cpp.

    : QPaintEngine(dptr, qt_decide_features())
{
    d_func()->init();
}

---

Member Function Documentation

bool QX11PaintEngine::begin

(

QPaintDevice *

pdev

)

[virtual]

Reimplement this function to initialise your paint engine when painting is to start on the paint device pdev. Return true if the initialization was successful; otherwise return false.

See also:

end() isActive()

Implements QPaintEngine.

Definition at line 705 of file qpaintengine_x11.cpp.

References Qt::black, d, QPaintDevice::devType(), QPaintEngine::DirtyBackground, QPaintEngine::DirtyBrush, QPaintEngine::DirtyClipRegion, QPaintEngine::DirtyPen, QPaintDevice::height(), QPaintEngine::Picture, QInternal::Pixmap, qt_x11Handle(), qt_x11Info(), QPaintEngine::setDirty(), QPainterPrivate::TxNone, updateBrush(), updatePen(), w, Qt::WA_PaintUnclipped, Qt::white, QInternal::Widget, QPaintDevice::width(), and QPaintEngine::X11.

{
    Q_D(QX11PaintEngine);
    d->xinfo = qt_x11Info(pdev);
#ifndef QT_NO_XRENDER
    if (pdev->devType() == QInternal::Widget) {
        d->picture = (::Picture)static_cast<const QWidget *>(pdev)->x11PictureHandle();
    } else if (pdev->devType() == QInternal::Pixmap) {
        const QPixmap *pm = static_cast<const QPixmap *>(pdev);
        if (X11->use_xrender && pm->data->d != 32 && pm->data->x11_mask)
            pm->data->convertToARGB32();
        d->picture = (::Picture)static_cast<const QPixmap *>(pdev)->x11PictureHandle();
    }
#else
    d->picture = 0;
#endif
    d->hd = qt_x11Handle(pdev);

    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_custom_pen = false;
    d->matrix = QMatrix();
    d->pdev_depth = d->pdev->depth();
    d->render_hints = 0;
    d->txop = QPainterPrivate::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);

    QPixmap::x11SetDefaultScreen(d->xinfo->screen());

    QWidget *w = d->pdev->devType() == QInternal::Widget ? static_cast<QWidget *>(d->pdev) : 0;
    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;
}

Here is the call graph for this function:

bool QX11PaintEngine::end

(

)

[virtual]

Reimplement this function to finish painting on the current paint device. Return true if painting was finished successfully; otherwise return false.

See also:

begin() isActive()

Implements QPaintEngine.

Definition at line 777 of file qpaintengine_x11.cpp.

References d, and XNone.

Referenced by drawImage(), and drawPoints().

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

    return true;
}

void QX11PaintEngine::updateState

(

const QPaintEngineState &

state

)

[virtual]

Reimplement this function to update the state of a paint engine.

When implemented, this function is responsible for checking the paint engine's current state and update the properties that are changed. Use the QPaintEngineState::state() function to find out which properties that must be updated, then use the corresponding {GetFunction}{get function} to retrieve the current values for the given properties.

See also:

QPaintEngineState

Implements QPaintEngine.

Definition at line 1104 of file qpaintengine_x11.cpp.

References QPaintEngineState::brush(), QPaintEngineState::brushOrigin(), QPaintEngineState::clipOperation(), QPaintEngineState::clipPath(), QPaintEngineState::clipRegion(), QPaintEngineState::compositionMode(), d, QPaintEngine::DirtyBrush, QPaintEngine::DirtyBrushOrigin, QPaintEngine::DirtyClipEnabled, QPaintEngine::DirtyClipPath, QPaintEngine::DirtyClipRegion, QPaintEngine::DirtyCompositionMode, QPaintEngine::DirtyFont, QPaintEngine::DirtyHints, QPaintEngine::DirtyOpacity, QPaintEngine::DirtyPen, QPaintEngine::DirtyTransform, QPainterPath::fillRule(), flags, QPaintEngineState::font(), QPaintEngineState::isClipEnabled(), QPaintEngineState::matrix(), Qt::NoClip, QPaintEngineState::opacity(), QPaintEngine::painter(), QPaintEngineState::pen(), qpainterOpToXrender(), QPaintEngineState::renderHints(), Qt::ReplaceClip, QPaintEngineState::state(), QPaintEngine::state, QPainterPath::toFillPolygon(), QPolygonF::toPolygon(), updateBrush(), updateClipRegion_dev(), updateFont(), updateMatrix(), updatePen(), and updateRenderHints().

{
    Q_D(QX11PaintEngine);
    QPaintEngine::DirtyFlags flags = state.state();


    if (flags & DirtyOpacity) {
        d->opacity = state.opacity();
        if (d->opacity > 1)
            d->opacity = 1;
        if (d->opacity < 0)
            d->opacity = 0;
        // Force update pen/brush as to get proper alpha colors propagated
        flags |= DirtyPen;
        flags |= DirtyBrush;
    }

    if (flags & DirtyTransform) updateMatrix(state.matrix());
    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) {
        updateClipRegion_dev(d->matrix.map(state.clipRegion()), state.clipOperation());
    }
    if (flags & DirtyHints) updateRenderHints(state.renderHints());
#if !defined(QT_NO_XRENDER)
    if (flags & DirtyCompositionMode) {
        d->composition_mode =
            qpainterOpToXrender(state.compositionMode());
    }
#endif
    d->decidePathFallback();
}

Here is the call graph for this function:

void QX11PaintEngine::updatePen

(

const QPen &

pen

)

Definition at line 1175 of file qpaintengine_x11.cpp.

References QColor::alpha, Qt::BevelJoin, c, QPen::capStyle(), QPen::color(), Qt::CustomDashLine, d, Qt::DashDotDotLine, Qt::DashDotLine, Qt::DashLine, Qt::DotLine, Qt::FlatCap, QColormap::instance(), QRegion::isEmpty(), QPen::joinStyle(), mask, Qt::MiterJoin, Qt::NoPen, QColormap::pixel(), QInternal::Pixmap, qGray(), qRound(), rgb, QColor::rgb(), QColor::rgba(), Qt::RoundCap, Qt::RoundJoin, scale(), Qt::SolidLine, Qt::SquareCap, QPen::style(), QPaintEngine::systemClip(), Qt::transparent, QPen::widthF(), QPaintEngine::X11, x11ClearClipRegion(), and x11SetClipRegion().

Referenced by begin(), and updateState().

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

Here is the call graph for this function:

void QX11PaintEngine::updateBrush	(	const QBrush &	brush,
		const QPointF &	pt
	)

Definition at line 1314 of file qpaintengine_x11.cpp.

References QColor::alpha, c, QBrush::color(), d, QPixmap::data, Qt::Dense1Pattern, QPixmap::depth(), Qt::DiagCrossPattern, QPixmap::height(), QColormap::instance(), QRegion::isEmpty(), QBrush::isOpaque(), mask, Qt::NoBrush, QPaintEngine::Picture, QColormap::pixel(), QInternal::Pixmap, qGray(), QPixmap, qRound(), qt_patternForAlpha(), qt_pixmapForBrush(), rgb, s, QPixmap::size(), QPaintEngine::systemClip(), Qt::TexturePattern, Qt::transparent, QPixmap::width(), QPointF::x(), QPaintEngine::X11, x11ClearClipRegion(), x11SetClipRegion(), and QPointF::y().

Referenced by begin(), and updateState().

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

    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) {
        QPixmap pm;
        if (bs == Qt::TexturePattern) {
            pm = d->cbrush.texture();
#if !defined(QT_NO_XRENDER)
            if (X11->use_xrender) {
                XRenderPictureAttributes attrs;
                attrs.repeat = true;
                XRenderChangePicture(d->dpy, pm.x11PictureHandle(), CPRepeat, &attrs);
                if (pm.data->mask_picture)
                    XRenderChangePicture(d->dpy, pm.data->mask_picture, CPRepeat, &attrs);
            }
#endif
        } else {
            pm = qt_pixmapForBrush(bs, true);
        }
        pm.x11SetScreen(d->scrn);
        if (pm.depth() == 1) {
            mask |= GCStipple;
            vals.stipple = pm.handle();
            s = FillStippled;
#if !defined(QT_NO_XRENDER)
            if (X11->use_xrender) {
                d->bitmap_texture = QPixmap(pm.size());
                d->bitmap_texture.fill(Qt::transparent);

                ::Picture src  = X11->getSolidFill(d->scrn, d->cbrush.color());
                XRenderComposite(d->dpy, PictOpSrc, src, pm.x11PictureHandle(),
                                 d->bitmap_texture.x11PictureHandle(),
                                 0, 0, pm.width(), pm.height(),
                                 0, 0, pm.width(), 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 && pm.depth() != 32)
                pm.data->convertToARGB32();
#endif
            vals.tile = (pm.depth() == d->pdev_depth
                         ? pm.handle()
                         : 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);
    }
}

Here is the call graph for this function:

void QX11PaintEngine::updateRenderHints

(

QPainter::RenderHints

hints

)

Definition at line 1156 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, d, QPainterPrivate::TxTranslate, and QPaintEngine::X11.

Referenced by updateState().

{
    Q_D(QX11PaintEngine);
    d->render_hints = hints;
    if ((d->txop > QPainterPrivate::TxTranslate)
        || (hints & QPainter::Antialiasing))
        d->use_path_fallback = true;
    else
        d->use_path_fallback = false;

#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::updateFont

(

const QFont &

font

)

Definition at line 2026 of file qpaintengine_x11.cpp.

Referenced by updateState().

{
}

void QX11PaintEngine::updateMatrix

(

const QMatrix &

matrix

)

Definition at line 1967 of file qpaintengine_x11.cpp.

References d, QMatrix::dx(), QMatrix::dy(), QMatrix::m11(), QMatrix::m12(), QMatrix::m21(), QMatrix::m22(), QPainterPrivate::TxNone, QPainterPrivate::TxRotShear, QPainterPrivate::TxScale, and QPainterPrivate::TxTranslate.

Referenced by updateState().

{
    Q_D(QX11PaintEngine);
    d->matrix = mtx;
    if (mtx.m12() != 0 || mtx.m21() != 0)
        d->txop = QPainterPrivate::TxRotShear;
    else if (mtx.m11() != 1 || mtx.m22() != 1)
        d->txop = QPainterPrivate::TxScale;
    else if (mtx.dx() != 0 || mtx.dy() != 0)
        d->txop = QPainterPrivate::TxTranslate;
    else
        d->txop = QPainterPrivate::TxNone;

    d->has_complex_xform = (d->txop > QPainterPrivate::TxTranslate);
}

Here is the call graph for this function:

void QX11PaintEngine::updateClipRegion_dev	(	const QRegion &	region,
		Qt::ClipOperation	op
	)

Definition at line 1986 of file qpaintengine_x11.cpp.

References d, Qt::IntersectClip, QRegion::intersected(), QRegion::isEmpty(), Qt::NoClip, Qt::ReplaceClip, QPaintEngine::systemClip(), Qt::UniteClip, x11ClearClipRegion(), and x11SetClipRegion().

Referenced by updateState().

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

Here is the call graph for this function:

void QX11PaintEngine::drawLines	(	const QLine *	lines,
		int	lineCount
	)			[virtual]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The default implementation converts the first lineCount lines in lines to a QLineF and calls the floating point version of this function.

Reimplemented from QPaintEngine.

Definition at line 876 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, clipLine(), d, drawPath(), i, QLine::p1(), QLine::p2(), path, qFloor(), and QPainterPrivate::TxNone.

{
    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->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 == QPainterPrivate::TxNone) {
                linef = lines[i];
            } else {
                linef = QLineF(d->matrix.map(lines[i].p1()), d->matrix.map(lines[i].p2()));
            }
            if (clipLine(&linef, d->polygonClipper.boundingRect())) {
                XDrawLine(d->dpy, d->hd, d->gc,
                          qFloor(linef.x1()), qFloor(linef.y1()),
                          qFloor(linef.x2()), qFloor(linef.y2()));
            }
        }
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawLines	(	const QLineF *	lines,
		int	lineCount
	)			[inline, virtual]

The default implementation splits the list of lines in lines into lineCount separate calls to drawPath() or drawPolygon() depending on the feature set of the paint engine.

Reimplemented from QPaintEngine.

Definition at line 76 of file qpaintengine_x11_p.h.

References QPaintEngine::drawLines().

{ QPaintEngine::drawLines(lines, lineCount); }

Here is the call graph for this function:

void QX11PaintEngine::drawRects	(	const QRect *	rects,
		int	rectCount
	)			[virtual]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. The default implementation converts the first rectCount rectangles in the buffer rects to a QRectF and calls the floating point version of this function.

Reimplemented from QPaintEngine.

Definition at line 911 of file qpaintengine_x11.cpp.

References d, QVarLengthArray< T, Prealloc >::data(), drawPath(), i, path, QPaintEngine::Picture, qRound(), QPainterPrivate::TxTranslate, and QPaintEngine::X11.

{
    Q_D(QX11PaintEngine);
    Q_ASSERT(rects);
    Q_ASSERT(rectCount);

    if (d->use_path_fallback) {
        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 == QPainterPrivate::TxTranslate)
                r.translate(offset);
            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 == QPainterPrivate::TxTranslate)
                    r.translate(offset);
                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<XRectangle> xrects(rectCount);
            int numClipped = rectCount;
            for (int i = 0; i < rectCount; ++i) {
                QRect r(rects[i]);
                if (d->txop == QPainterPrivate::TxTranslate)
                    r.translate(offset);
                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 && !d->has_pen)
                    XFillRectangles(d->dpy, d->hd, d->gc_brush, xrects.data(), numClipped);
                else if (d->has_pen && !d->has_brush)
                    XDrawRectangles(d->dpy, d->hd, d->gc, xrects.data(), numClipped);
                d->resetAdaptedOrigin();
            }
        }
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawRects	(	const QRectF *	rects,
		int	rectCount
	)			[inline, virtual]

Draws the first rectCount rectangles in the buffer rects. The default implementation of this function calls drawPath() or drawPolygon() depending on the feature set of the paint engine.

Reimplemented from QPaintEngine.

Definition at line 79 of file qpaintengine_x11_p.h.

References QPaintEngine::drawRects().

{ QPaintEngine::drawRects(rects, rectCount); }

Here is the call graph for this function:

void QX11PaintEngine::drawPoints	(	const QPoint *	points,
		int	pointCount
	)			[virtual]

Draws the first pointCount points in the buffer points

The default implementation converts the first pointCount QPoints in points to QPointFs and calls the floating point version of drawPoints.

Reimplemented from QPaintEngine.

Definition at line 1001 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, d, drawPath(), end(), i, j, path, QPoint::x(), x, QPoint::y(), and y.

{
    Q_ASSERT(points);
    Q_ASSERT(pointCount);
    Q_D(QX11PaintEngine);

    if (!d->has_pen)
        return;

    if (d->cpen.widthF() > .0f
        || d->has_alpha_brush
        || d->has_alpha_pen
        || d->has_custom_pen
        || (d->render_hints & QPainter::Antialiasing)) {
        const QPoint *end = points + pointCount;
        while (points < end) {
            QPainterPath path;
            path.moveTo(*points);
            path.lineTo(points->x()+.005, points->y());
            drawPath(path);
            ++points;
        }
        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;
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawPoints	(	const QPointF *	points,
		int	pointCount
	)			[virtual]

Draws the first pointCount points in the buffer points

Reimplemented from QPaintEngine.

Definition at line 1048 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, d, drawPath(), end(), i, j, path, qFloor(), QPointF::x(), x, QPointF::y(), and y.

{
    Q_ASSERT(points);
    Q_ASSERT(pointCount);
    Q_D(QX11PaintEngine);

    if (!d->has_pen)
        return;

    if (d->cpen.widthF() > .0f
        || d->has_alpha_brush
        || d->has_alpha_pen
        || d->has_custom_pen
        || (d->render_hints & QPainter::Antialiasing)) {
        const QPointF *end = points + pointCount;
        while (points < end) {
            QPainterPath path;
            path.moveTo(*points);
            path.lineTo(points->x() + 0.005, points->y());
            drawPath(path);
            ++points;
        }
        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;
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawEllipse

(

const QRect &

r

)

[virtual]

The default implementation of this function calls the floating point version of this function

Reimplemented from QPaintEngine.

Definition at line 1439 of file qpaintengine_x11.cpp.

References d, drawPath(), h, QRect::height(), QRect::intersected(), path, qRound(), QRect::topLeft(), QRect::translate(), QPainterPrivate::TxTranslate, w, QRect::width(), QRect::x(), x, QRect::y(), and y.

{
    Q_D(QX11PaintEngine);
    QRect devclip(SHRT_MIN, SHRT_MIN, SHRT_MAX*2 - 1, SHRT_MAX*2 - 1);
    QRect r(rect);
    if (d->txop == QPainterPrivate::TxTranslate)
        r.translate(qRound(d->matrix.dx()), qRound(d->matrix.dy()));
    if (d->use_path_fallback || devclip.intersected(r) != r) {
        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
        if (!d->has_pen) {
            XFillArc(d->dpy, d->hd, d->gc_brush, x, y, w-1, h-1, 0, 360*64);
            XDrawArc(d->dpy, d->hd, d->gc_brush, x, y, w-1, h-1, 0, 360*64);
            return;
        } else{
            XFillArc(d->dpy, d->hd, d->gc_brush, x, y, w, h, 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();
}

Here is the call graph for this function:

void QX11PaintEngine::drawEllipse

(

const QRectF &

r

)

[inline, virtual]

Reimplement this function to draw the largest ellipse that can be contained within rectangle rect.

The default implementation calls drawPolygon().

Reimplemented from QPaintEngine.

Definition at line 85 of file qpaintengine_x11_p.h.

References QPaintEngine::drawEllipse().

{ QPaintEngine::drawEllipse(r); }

Here is the call graph for this function:

void QX11PaintEngine::drawPolygon	(	const QPointF *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)			[virtual]

Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode.

The default implementation of this function will try to use drawPath if the engine supports the feature QPaintEngine::PainterPaths or try the float based drawPolygon() implementation if not.

Reimplemented from QPaintEngine.

Definition at line 1695 of file qpaintengine_x11.cpp.

References QX11PaintEnginePrivate::BrushGC, d, drawPath(), i, Qt::NoBrush, Qt::OddEvenFill, QPaintEngine::OddEvenMode, path, QPaintEngine::PolylineMode, and Qt::WindingFill.

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

Here is the call graph for this function:

void QX11PaintEngine::drawPolygon	(	const QPoint *	points,
		int	pointCount,
		PolygonDrawMode	mode
	)			[inline, virtual]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Reimplement this virtual function to draw the polygon defined by the pointCount first points in points, using mode mode.

The default implementation of this function will try to use drawPath() if the engine supports the feature QPaintEngine::PainterPaths or try the int based drawPolygon() implementation if not.

Reimplemented from QPaintEngine.

Definition at line 88 of file qpaintengine_x11_p.h.

References QPaintEngine::drawPolygon().

        { QPaintEngine::drawPolygon(points, pointCount, mode); }

Here is the call graph for this function:

void QX11PaintEngine::drawPixmap	(	const QRectF &	r,
		const QPixmap &	pm,
		const QRectF &	sr
	)			[virtual]

Reimplement this function to draw the part of the pm specified by the sr rectangle in the given r.

Implements QPaintEngine.

Definition at line 1844 of file qpaintengine_x11.cpp.

References d, QPixmapData::d, QPixmap::data, QRectF::height(), QColormap::instance(), num, p, QPaintEngine::Picture, QColormap::pixel(), QInternal::Pixmap, qGray(), qRound(), qt_getClipRects(), qt_render_bitmap(), Unsorted, QRectF::width(), QRectF::x(), x, QPaintEngine::X11, XNone, QRectF::y(), and y.

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

    if ((d->xinfo && d->xinfo->screen() != pixmap.x11Info().screen())
        || (pixmap.x11Info().screen() != DefaultScreen(X11->display))) {
        QPixmap* p = const_cast<QPixmap *>(&pixmap);
        p->x11SetScreen(d->xinfo ? d->xinfo->screen() : DefaultScreen(X11->display));
    }

    QPixmap::x11SetDefaultScreen(pixmap.x11Info().screen());

#ifndef QT_NO_XRENDER
    ::Picture src_pict = pixmap.data->picture;
    if (src_pict && d->picture) {
        if (pixmap.data->d == 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 (pixmap.data->d != 1 && (pixmap.data->d == 32 || pixmap.data->d != 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.data->d == 1;
    bool mono_dst = d->pdev_depth == 1;
    bool restore_clip = false;

    if (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, 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, y);
        }

        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<const QPixmap*>(d->pdev);
        Pixmap src_mask = pixmap.data->x11_mask;
        Pixmap dst_mask = 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, pixmap.data->x11_mask, px->data->x11_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, px->data->x11_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);
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawTiledPixmap	(	const QRectF &	r,
		const QPixmap &	pixmap,
		const QPointF &	s
	)			[virtual]

Reimplement this function to draw the pixmap in the given rect, starting at the given p. The pixmap will be drawn repeatedly until the rect is filled.

Reimplemented from QPaintEngine.

Definition at line 2041 of file qpaintengine_x11.cpp.

References d, QPixmap::data, QPixmap::depth(), h, QRectF::height(), QPixmap::height(), p, qRound(), qt_draw_tile(), qt_render_bitmap(), w, QPixmap::width(), QRectF::width(), QRectF::x(), x, QPaintEngine::X11, XNone, QRectF::y(), and y.

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

    Q_D(QX11PaintEngine);
#ifndef QT_NO_XRENDER
    if (X11->use_xrender && d->picture && pixmap.x11PictureHandle()) {
        // 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 (pixmap.depth() == 1) {
                    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
#endif // !QT_NO_XRENDER
        if (pixmap.depth() > 1 && !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);
        }
}

Here is the call graph for this function:

void QX11PaintEngine::drawPath

(

const QPainterPath &

path

)

[virtual]

The default implementation ignores the path and does nothing.

Reimplemented from QPaintEngine.

Definition at line 1732 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, QList< T >::at(), QX11PaintEnginePrivate::BrushGC, QPainterPathStroker::createStroke(), Qt::CustomDashLine, d, QVector< T >::data(), i, QPainterPath::isEmpty(), path, QX11PaintEnginePrivate::PenGC, QPainterPathStroker::setCapStyle(), QPainterPathStroker::setDashPattern(), QPainterPath::setFillRule(), QPainterPathStroker::setJoinStyle(), QPainterPathStroker::setWidth(), QVector< T >::size(), QList< T >::size(), Qt::SolidLine, QPainterPrivate::TxTranslate, width, Qt::WindingFill, and QPaintEngine::X11.

Referenced by drawEllipse(), drawLines(), drawPoints(), drawPolygon(), and drawRects().

{
    Q_D(QX11PaintEngine);
    if (path.isEmpty())
        return;
    bool adjust_coords = (d->has_alpha_pen || (d->cpen.style() > Qt::SolidLine)) && !(d->render_hints & QPainter::Antialiasing);
    QMatrix old_matrix = d->matrix;
    if (adjust_coords) {
        d->matrix = QMatrix(d->matrix.m11(), d->matrix.m12(), d->matrix.m21(), d->matrix.m22(),
                            d->matrix.dx() + 0.5f, d->matrix.dy() + 0.5f);
    }
    if (d->has_brush)
        d->fillPath(path, QX11PaintEnginePrivate::BrushGC, true);

    if (d->has_pen
        && ((X11->use_xrender && (d->has_alpha_pen || d->has_alpha_brush
                                  || (d->render_hints & QPainter::Antialiasing)))
            || (d->cpen.widthF() > 0 && d->txop > QPainterPrivate::TxTranslate)
            || (d->cpen.style() > Qt::SolidLine))) {
        QPainterPathStroker stroker;
        if (d->cpen.style() == Qt::CustomDashLine)
            stroker.setDashPattern(d->cpen.dashPattern());
        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;
        // necessary to get aliased alphablended primitives to be drawn correctly
        if (width == 0) {
            stroker.setWidth(1);
            stroke = stroker.createStroke(path * d->matrix);
            if (stroke.isEmpty())
                return;
            stroke.setFillRule(Qt::WindingFill);
            d->fillPath(stroke, QX11PaintEnginePrivate::PenGC, false);
        } else {
            stroker.setWidth(width);
            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 pen width of 0 - use XDrawLine() for speed
        QList<QPolygonF> 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);
    }
    if (adjust_coords)
        d->matrix = old_matrix;
}

Here is the call graph for this function:

void QX11PaintEngine::drawTextItem	(	const QPointF &	p,
		const QTextItem &	textItem
	)			[virtual]

This function draws the text item textItem at position p. The default implementation of this function converts the text to a QPainterPath and paints the resulting path.

Reimplemented from QPaintEngine.

Definition at line 2096 of file qpaintengine_x11.cpp.

References QFontEngine::Box, drawBox(), drawFreetype(), drawXLFD(), QTextItemInt::fontEngine, QFontEngine::Freetype, p, QFontEngine::type(), and QFontEngine::XLFD.

{
    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);

    switch(ti.fontEngine->type()) {
    case QFontEngine::Box:
        drawBox(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);
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawImage	(	const QRectF &	r,
		const QImage &	img,
		const QRectF &	sr,
		Qt::ImageConversionFlags	flags = Qt::AutoColor
	)			[virtual]

Reimplement this function to draw the part of the image specified by the sr rectangle in the given rectangle using the given conversion flags flags, to convert it to a pixmap.

Reimplemented from QPaintEngine.

Definition at line 1787 of file qpaintengine_x11.cpp.

References QImage::bytesPerLine(), d, QPaintEngine::drawImage(), end(), h, QRectF::height(), QImage::height(), i, image, LSBFirst, MSBFirst, p, qRound(), QImage::scanLine(), QRectF::size(), w, QRectF::width(), QImage::width(), QRectF::x(), x, QRectF::y(), and y.

{
    Q_D(QX11PaintEngine);

    if (!image.hasAlphaChannel()
        && 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());
        XImage *xi;
        QImage im(image);
        // Note: this code assumes either RGB or BGR, 8 bpc server layouts
        const uint red_mask = (uint) ((Visual *) d->xinfo->visual())->red_mask;
        bool bgr_layout = (red_mask == 0xff);
        if ((QSysInfo::ByteOrder == QSysInfo::BigEndian
             && ((ImageByteOrder(d->dpy) == LSBFirst) || bgr_layout))
            || (ImageByteOrder(d->dpy) == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian))
        {
            for (int i=0; i < im.height(); i++) {
                uint *p = (uint*)im.scanLine(i);
                uint *end = p + im.width();
                if (bgr_layout && ImageByteOrder(d->dpy) == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
                    while (p < end) {
                        *p = ((*p << 8) & 0xffffff00) | ((*p >> 24) & 0x000000ff);
                        p++;
                    }
                } else if ((ImageByteOrder(d->dpy) == LSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian)
                           || (ImageByteOrder(d->dpy) == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) {
                    while (p < end) {
                        *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)
                             | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);
                        p++;
                    }
                } else if (ImageByteOrder(d->dpy) == MSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian) {
                    while (p < end) {
                        *p = ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff)
                             | ((*p ) & 0xff00ff00);
                        p++;
                    }
                }
            }
        }
        xi = XCreateImage(d->dpy, (Visual *) d->xinfo->visual(), d->pdev_depth, ZPixmap,
                          0, (char *) im.scanLine(sy)+sx*sizeof(uint), w, h, 32, im.bytesPerLine());
        XPutImage(d->dpy, d->hd, d->gc, xi, 0, 0, x, y, w, h);
        xi->data = 0; // QImage owns these bits
        XDestroyImage(xi);
    } else {
        QPaintEngine::drawImage(r, image, sr, flags);
    }
}

Here is the call graph for this function:

Qt::HANDLE QX11PaintEngine::handle

(

)

const [virtual]

Definition at line 2030 of file qpaintengine_x11.cpp.

References d, and QPaintEngine::isActive().

{
    Q_D(const QX11PaintEngine);
    Q_ASSERT(isActive());
    Q_ASSERT(d->hd);
    return d->hd;
}

Here is the call graph for this function:

Type QX11PaintEngine::type

(

)

const [inline, virtual]

Reimplement this function to return the paint engine {Type}.

Implements QPaintEngine.

Definition at line 99 of file qpaintengine_x11_p.h.

References QPaintEngine::X11.

{ return QPaintEngine::X11; }

QPainter::RenderHints QX11PaintEngine::supportedRenderHints

(

)

const

Definition at line 1095 of file qpaintengine_x11.cpp.

References QPainter::Antialiasing, and QPaintEngine::X11.

{
#if !defined(QT_NO_XRENDER)
    if (X11->use_xrender)
        return QPainter::Antialiasing;
#endif
    return QFlag(0);
}

void QX11PaintEngine::drawBox	(	const QPointF &	p,
		const QTextItemInt &	si
	)			[protected]

Definition at line 2118 of file qpaintengine_x11.cpp.

References QFontEngine::ascent(), QPainter::drawRect(), QTextItemInt::flags, QTextItemInt::fontEngine, QFontEngine::getGlyphPositions(), QTextItemInt::glyphs, QFontEngine::lineThickness(), Qt::NoBrush, QTextItemInt::num_glyphs, p, QPaintEngine::painter(), QPainter::pen(), positions, qRound(), QPainter::restore(), s, QPainter::save(), QPainter::setBrush(), QPainter::setPen(), QPen::setWidthF(), QVarLengthArray< T, Prealloc >::size(), size, QFixed::toReal(), and QMatrix::translate().

Referenced by drawTextItem().

{
    if (!ti.num_glyphs)
        return;

    QVarLengthArray<QFixedPoint> positions;
    QVarLengthArray<glyph_t> glyphs;
    QMatrix matrix;
    matrix.translate(p.x(), p.y());
    ti.fontEngine->getGlyphPositions(ti.glyphs, ti.num_glyphs, matrix, ti.flags, glyphs, positions);
    if (glyphs.size() == 0)
        return;

    int size = qRound(ti.fontEngine->ascent());
    QSize s(size - 3, size - 3);

    painter()->save();
    painter()->setBrush(Qt::NoBrush);
    QPen pen = painter()->pen();
    pen.setWidthF(ti.fontEngine->lineThickness().toReal());
    painter()->setPen(pen);
    for (int k = 0; k < positions.size(); k++)
        painter()->drawRect(QRectF(positions[k].toPointF(), s));
    painter()->restore();
}

Here is the call graph for this function:

void QX11PaintEngine::drawXLFD	(	const QPointF &	p,
		const QTextItemInt &	si
	)			[protected]

Definition at line 2144 of file qpaintengine_x11.cpp.

References d, QPaintEngine::drawTextItem(), QTextItemInt::flags, QTextItemInt::fontEngine, QFontEngineXLFD::fontStruct(), QFontEngine::getGlyphPositions(), QTextItemInt::glyphs, i, QTextItemInt::num_glyphs, p, positions, qRound(), QVarLengthArray< T, Prealloc >::size(), QMatrix::translate(), QPainterPrivate::TxTranslate, x, and y.

Referenced by drawTextItem().

{
    Q_D(QX11PaintEngine);

    if (d->txop > QPainterPrivate::TxTranslate) {
        // XServer or font don't support server side transformations, need to do it by hand
        QPaintEngine::drawTextItem(p, ti);
        return;
    }

    if (!ti.num_glyphs)
        return;

    QVarLengthArray<QFixedPoint> positions;
    QVarLengthArray<glyph_t> glyphs;
    QMatrix matrix = d->matrix;
    matrix.translate(p.x(), p.y());
    ti.fontEngine->getGlyphPositions(ti.glyphs, ti.num_glyphs, matrix, ti.flags, glyphs, positions);
    if (glyphs.size() == 0)
        return;

    QFontEngineXLFD *xlfd = static_cast<QFontEngineXLFD *>(ti.fontEngine);
    Qt::HANDLE font_id = xlfd->fontStruct()->fid;

    XSetFont(d->dpy, d->gc, font_id);

    for (int i = 0; i < glyphs.size(); i++) {
        int xp = qRound(positions[i].x);
        int yp = qRound(positions[i].y);
        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);
        }
    }
}

Here is the call graph for this function:

void QX11PaintEngine::drawFreetype	(	const QPointF &	p,
		const QTextItemInt &	si
	)			[protected]

Definition at line 2235 of file qpaintengine_x11.cpp.

References QPixmap::BitmapType, QFontEngineFT::cachedGlyph(), core_render_glyph(), QVarLengthArray< T, Prealloc >::count(), d, data, QVarLengthArray< T, Prealloc >::data(), QFontEngineFT::drawAsOutline(), QPaintEngine::drawTextItem(), QTextItemInt::flags, QFontEngineFT::fnt, QTextItemInt::fontEngine, QFixed::fromReal(), g, QFontEngine::getGlyphPositions(), QTextItemInt::glyphs, i, QFontEngineFT::loadTransformedGlyphSet(), QFontEngineFT::lockFace(), QTextItemInt::num_glyphs, p, QPaintEngine::Picture, QInternal::Pixmap, positions, qRound(), QVarLengthArray< T, Prealloc >::size(), QFixed::toInt(), QMatrix::translate(), QPainterPrivate::TxScale, QFontEngineFT::unlockFace(), x, QPaintEngine::X11, and y.

Referenced by drawTextItem().

{
    Q_D(QX11PaintEngine);
    if (!ti.num_glyphs)
        return;

    QFontEngineFT *ft = static_cast<QFontEngineFT *>(ti.fontEngine);

    if (!d->cpen.isSolid() || ft->drawAsOutline()) {
        QPaintEngine::drawTextItem(p, ti);
    }

    QFixed xpos = QFixed::fromReal(p.x() + d->matrix.dx());
    QFixed ypos = QFixed::fromReal(p.y() + d->matrix.dy());

    QVarLengthArray<QFixedPoint> positions;
    QVarLengthArray<glyph_t> glyphs;
    QMatrix matrix = d->matrix;
    matrix.translate(p.x(), p.y());
    ft->getGlyphPositions(ti.glyphs, ti.num_glyphs, matrix, ti.flags, glyphs, positions);
    if (glyphs.count() == 0)
        return;

    bool drawTransformed = false;
#ifndef QT_NO_XRENDER
    const bool xrenderPath = (X11->use_xrender
                              && !(d->pdev->devType() == QInternal::Pixmap
                              && static_cast<const QPixmap *>(d->pdev)->data->type == QPixmap::BitmapType));

    GlyphSet transformedGlyphSet = 0;
    if (d->txop >= QPainterPrivate::TxScale
        && xrenderPath) {
        drawTransformed = ft->loadTransformedGlyphSet(glyphs.data(), glyphs.size(), d->matrix, &transformedGlyphSet);
    }
#endif

    if ((d->txop >= QPainterPrivate::TxScale && !drawTransformed)) {
        QPaintEngine::drawTextItem(p, ti);
        return;
    }

#ifndef QT_NO_XRENDER
    if (xrenderPath) {

        GlyphSet glyphSet = drawTransformed ? transformedGlyphSet : ft->fnt.glyphSet;

        const QColor &pen = d->cpen.color();
        ::Picture src = X11->getSolidFill(d->scrn, pen);
        // XRenderPictFormat *maskFormat = XRenderFindStandardFormat(X11->display, ft->xglyph_format);
        // using a mask format other than 0 causes bitmap/XLFD fonts to garbled
        XRenderPictFormat *maskFormat = 0;

        enum { t_min = SHRT_MIN >> 1, t_max = SHRT_MAX >> 1};
        QFixed xp = positions[0].x;
        QFixed yp = positions[0].y;

        // better return instead of crashing the X server
        if (xp.toInt() < t_min || xp.toInt() > t_max
            || yp.toInt() < t_min || yp.toInt() > t_max)
            return;

        XGlyphElt32 elt;
        elt.glyphset = glyphSet;
        elt.chars = &glyphs[0];
        elt.nchars = 1;
        elt.xOff = qRound(xp);
        elt.yOff = qRound(yp);
        for (int i = 1; i < glyphs.size(); ++i) {
            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);
                elt.yOff = qRound(yp);
            }
        }
        XRenderCompositeText32(X11->display, PictOpOver, src, d->picture,
                               maskFormat, 0, 0, 0, 0,
                               &elt, 1);

        return;

    }
#endif
    ft->lockFace();
    int i = 0;
    while (i < glyphs.size()) {
        core_render_glyph(ft, qRound(positions[i].x), qRound(positions[i].y), glyphs[i]);
        ++i;
    }
    ft->unlockFace();
}

Here is the call graph for this function:

void QX11PaintEngine::core_render_glyph	(	QFontEngineFT *	fe,
		int	xp,
		int	yp,
		uint	glyph
	)			[protected]

Definition at line 2183 of file qpaintengine_x11.cpp.

References d, QFontEngineFT::Glyph::data, QFontEngineFT::Glyph::format, QFontEngineFT::Format_Mono, h, QFontEngineFT::Glyph::height, QFontEngineFT::loadGlyph(), n, Qt::NoPen, set(), QFontEngineFT::Glyph::width, width, QFontEngineFT::Glyph::x, x, x80, y, and QFontEngineFT::Glyph::y.

Referenced by drawFreetype().

{
    Q_D(QX11PaintEngine);
    if (xp < SHRT_MIN || xp > SHRT_MAX  || yp < SHRT_MIN || yp > SHRT_MAX
        || d->cpen.style() == Qt::NoPen)
        return;

    QFontEngineFT::Glyph *glyph = fe->loadGlyph(g, QFontEngineFT::Format_Mono);
    // #### fix case where we don't get a glyph
    if (!glyph)
        return;

    Q_ASSERT(glyph->format == QFontEngineFT::Format_Mono);

    const int rectcount = 256;
    XRectangle rects[rectcount];
    int n = 0;
    int h = glyph->height;
    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) {
                XRectangle r = { xp + x, yp - h, 1, 1 };
                while (x < glyph->width-1 && src[(x+1) >> 3] & (0x80 >> ((x+1) & 7))) {
                    ++x;
                    ++r.width;
                }

                rects[n] = r;
                ++n;
            }
            if (n == rectcount) {
                d->setupAdaptedOrigin(QPoint(rects[0].x, rects[0].y));
                XFillRectangles(d->dpy, d->hd, d->gc, rects, n);
                n = 0;
                d->resetAdaptedOrigin();
            }
        }
        src += pitch;
    }
    if (n) {
        d->setupAdaptedOrigin(QPoint(rects[0].x, rects[0].y));
        XFillRectangles(d->dpy, d->hd, d->gc, rects, n);
        d->resetAdaptedOrigin();
    }
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class QPixmap [friend]

Definition at line 113 of file qpaintengine_x11_p.h.

Referenced by updateBrush().

friend class QFontEngineBox [friend]

Reimplemented from QPaintEngine.

Definition at line 114 of file qpaintengine_x11_p.h.

Q_GUI_EXPORT GC qt_x11_get_pen_gc

(

QPainter *

p

)

[friend]

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

Q_GUI_EXPORT GC qt_x11_get_brush_gc

(

QPainter *

p

)

[friend]

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

---

The documentation for this class was generated from the following files:

• src/gui/painting/qpaintengine_x11_p.h
• src/gui/painting/qpaintengine_x11.cpp

---