/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** 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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $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 <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>

#ifndef QT_NO_XRENDER

#include <private/qtessellator_p.h>

#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<QX11PaintEngine *>(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<QX11PaintEngine *>(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; i<clipped_count; ++i)

        (*clipped_poly)[i] = *((QPointF *)(&clipped_points[i]));

}

void QX11PaintEnginePrivate::systemStateChanged()

{

    Q_Q(QX11PaintEngine);

    QPainter *painter = q->state ? static_cast<QPainterState *>(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<QWidget *>(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<const QPixmap *>(pdev);

        QX11PixmapData *data = static_cast<QX11PixmapData*>(pm->data.data());

        if (X11->use_xrender && data->depth() != 32 && data->x11_mask)

            data->convertToARGB32();

        d->picture = (::Picture)static_cast<const QPixmap *>(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);