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

**

** Copyright (C) 2010 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 <QtCore/qglobal.h>

#define QT_FT_BEGIN_HEADER

#define QT_FT_END_HEADER

#include <private/qrasterdefs_p.h>

#include <private/qgrayraster_p.h>

#include <qpainterpath.h>

#include <qdebug.h>

#include <qhash.h>

#include <qlabel.h>

#include <qbitmap.h>

#include <qmath.h>

#if defined (Q_WS_X11)

#  include <private/qfontengine_ft_p.h>

#endif

//   #include <private/qdatabuffer_p.h>

//   #include <private/qpainter_p.h>

#include <private/qmath_p.h>

#include <private/qtextengine_p.h>

#include <private/qfontengine_p.h>

#include <private/qpixmap_raster_p.h>

//   #include <private/qpolygonclipper_p.h>

//   #include <private/qrasterizer_p.h>

#include <private/qimage_p.h>

#include "qpaintengine_raster_p.h"

//   #include "qbezier_p.h"

#include "qoutlinemapper_p.h"

#if defined(Q_WS_WIN)

#  include <qt_windows.h>

#  include <qvarlengtharray.h>

#  include <private/qfontengine_p.h>

#  if defined(Q_OS_WINCE)

#    include "qguifunctions_wince.h"

#  endif

#elif defined(Q_WS_MAC)

#  include <private/qt_mac_p.h>

#  include <private/qpixmap_mac_p.h>

#  include <private/qpaintengine_mac_p.h>

#elif defined(Q_WS_QWS)

#  if !defined(QT_NO_FREETYPE)

#    include <private/qfontengine_ft_p.h>

#  endif

#  if !defined(QT_NO_QWS_QPF2)

#    include <private/qfontengine_qpf_p.h>

#  endif

#  include <private/qabstractfontengine_p.h>

#elif defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)

#  include <private/qfontengine_s60_p.h>

#endif

#if defined(Q_WS_WIN64)

#  include <malloc.h>

#endif

#include <limits.h>

QT_BEGIN_NAMESPACE

#define qreal_to_fixed_26_6(f) (int(f * 64))

#define qt_swap_int(x, y) { int tmp = (x); (x) = (y); (y) = tmp; }

#define qt_swap_qreal(x, y) { qreal tmp = (x); (x) = (y); (y) = tmp; }

// #define QT_DEBUG_DRAW

#ifdef QT_DEBUG_DRAW

void dumpClip(int width, int height, const QClipData *clip);

#endif

#define QT_FAST_SPANS

// A little helper macro to get a better approximation of dimensions.

// If we have a rect that starting at 0.5 of width 3.5 it should span

// 4 pixels.

#define int_dim(pos, dim) (int(pos+dim) - int(pos))

// use the same rounding as in qrasterizer.cpp (6 bit fixed point)

static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;

#ifdef Q_WS_WIN

extern bool qt_cleartype_enabled;

#endif

#ifdef Q_WS_MAC

extern bool qt_applefontsmoothing_enabled;

#endif

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

 * Span functions

 */

static void qt_span_fill_clipRect(int count, const QSpan *spans, void *userData);

static void qt_span_fill_clipped(int count, const QSpan *spans, void *userData);

static void qt_span_clip(int count, const QSpan *spans, void *userData);

static void qt_merge_clip(const QClipData *c1, const QClipData *c2, QClipData *result);

struct ClipData

{

    QClipData *oldClip;

    QClipData *newClip;

    Qt::ClipOperation operation;

};

enum LineDrawMode {

    LineDrawClipped,

    LineDrawNormal,

    LineDrawIncludeLastPixel

};

static void drawLine_midpoint_i(int x1, int y1, int x2, int y2, ProcessSpans span_func, QSpanData *data,

                                LineDrawMode style, const QIntRect &rect);

static void drawLine_midpoint_dashed_i(int x1, int y1, int x2, int y2,

                                       QPen *pen, ProcessSpans span_func, QSpanData *data,

                                       LineDrawMode style, const QIntRect &devRect,

                                       int *patternOffset);

// static void drawLine_midpoint_f(qreal x1, qreal y1, qreal x2, qreal y2,

//                                 ProcessSpans span_func, QSpanData *data,

//                                 LineDrawMode style, const QRect &devRect);

static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,

                                   ProcessSpans pen_func, ProcessSpans brush_func,

                                   QSpanData *pen_data, QSpanData *brush_data);

struct QRasterFloatPoint {

    qreal x;

    qreal y;

};

#ifdef QT_DEBUG_DRAW

static const QRectF boundingRect(const QPointF *points, int pointCount)

{

    const QPointF *e = points;

    const QPointF *last = points + pointCount;

    qreal minx, maxx, miny, maxy;

    minx = maxx = e->x();

    miny = maxy = e->y();

    while (++e < last) {

        if (e->x() < minx)

            minx = e->x();

        else if (e->x() > maxx)

            maxx = e->x();

        if (e->y() < miny)

            miny = e->y();

        else if (e->y() > maxy)

            maxy = e->y();

    }

    return QRectF(QPointF(minx, miny), QPointF(maxx, maxy));

}

#endif

template <typename T> static inline bool isRect(const T *pts, int elementCount) {

    return (elementCount == 5 // 5-point polygon, check for closed rect

            && pts[0] == pts[8] && pts[1] == pts[9] // last point == first point

            && pts[0] == pts[6] && pts[2] == pts[4] // x values equal

            && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...

            && pts[0] < pts[4] && pts[1] < pts[5]

            ) ||

           (elementCount == 4 // 4-point polygon, check for unclosed rect

            && pts[0] == pts[6] && pts[2] == pts[4] // x values equal

            && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...

            && pts[0] < pts[4] && pts[1] < pts[5]

            );

}

static void qt_ft_outline_move_to(qfixed x, qfixed y, void *data)

{

    ((QOutlineMapper *) data)->moveTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));

}

static void qt_ft_outline_line_to(qfixed x, qfixed y, void *data)

{

    ((QOutlineMapper *) data)->lineTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));

}

static void qt_ft_outline_cubic_to(qfixed c1x, qfixed c1y,

                             qfixed c2x, qfixed c2y,

                             qfixed ex, qfixed ey,

                             void *data)

{

    ((QOutlineMapper *) data)->curveTo(QPointF(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y)),

                                       QPointF(qt_fixed_to_real(c2x), qt_fixed_to_real(c2y)),

                                       QPointF(qt_fixed_to_real(ex), qt_fixed_to_real(ey)));

}

#if !defined(QT_NO_DEBUG) && 0

static void qt_debug_path(const QPainterPath &path)

{

    const char *names[] = {

        "MoveTo     ",

        "LineTo     ",

        "CurveTo    ",

        "CurveToData"

    };

    fprintf(stderr,"\nQPainterPath: elementCount=%d\n", path.elementCount());

    for (int i=0; i<path.elementCount(); ++i) {

        const QPainterPath::Element &e = path.elementAt(i);

        Q_ASSERT(e.type >= 0 && e.type <= QPainterPath::CurveToDataElement);

        fprintf(stderr," - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);

    }

}

#endif

/*!

    \class QRasterPaintEngine

    \preliminary

    \ingroup qws

    \since 4.2

    \brief The QRasterPaintEngine class enables hardware acceleration

    of painting operations in Qt for Embedded Linux.

    Note that this functionality is only available in

    \l{Qt for Embedded Linux}.

    In \l{Qt for Embedded Linux}, painting is a pure software

    implementation. But starting with Qt 4.2, it is

    possible to add an accelerated graphics driver to take advantage

    of available hardware resources.

    Hardware acceleration is accomplished by creating a custom screen

    driver, accelerating the copying from memory to the screen, and

    implementing a custom paint engine accelerating the various

    painting operations. Then a custom paint device (derived from the

    QCustomRasterPaintDevice class) and a custom window surface

    (derived from QWSWindowSurface) must be implemented to make

    \l{Qt for Embedded Linux} aware of the accelerated driver.

    \note The QRasterPaintEngine class does not support 8-bit images.

    Instead, they need to be converted to a supported format, such as

    QImage::Format_ARGB32_Premultiplied.

    See the \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}

    documentation for details.

    \sa QCustomRasterPaintDevice, QPaintEngine

*/

/*!

    \fn Type QRasterPaintEngine::type() const

    \reimp

*/

/*!

    \typedef QSpan

    \relates QRasterPaintEngine

    A struct equivalent to QT_FT_Span, containing a position (x,

    y), the span's length in pixels and its color/coverage (a value

    ranging from 0 to 255).

*/

/*!

    \since 4.5

    Creates a raster based paint engine for operating on the given

    \a device, with the complete set of \l

    {QPaintEngine::PaintEngineFeature}{paint engine features and

    capabilities}.

*/

QRasterPaintEngine::QRasterPaintEngine(QPaintDevice *device)

    : QPaintEngineEx(*(new QRasterPaintEnginePrivate))

{

    d_func()->device = device;

    init();

}

/*!

    \internal

*/

QRasterPaintEngine::QRasterPaintEngine(QRasterPaintEnginePrivate &dd, QPaintDevice *device)

    : QPaintEngineEx(dd)

{

    d_func()->device = device;

    init();

}

void QRasterPaintEngine::init()

{

    Q_D(QRasterPaintEngine);

#ifdef Q_WS_WIN

    d->hdc = 0;

#endif

    d->rasterPoolSize = 8192;

    d->rasterPoolBase =

#if defined(Q_WS_WIN64)

        // We make use of setjmp and longjmp in qgrayraster.c which requires

        // 16-byte alignment, hence we hardcode this requirement here..

        (unsigned char *) _aligned_malloc(d->rasterPoolSize, sizeof(void*) * 2);

#else

        (unsigned char *) malloc(d->rasterPoolSize);

#endif

    Q_CHECK_PTR(d->rasterPoolBase);

    // The antialiasing raster.

    d->grayRaster.reset(new QT_FT_Raster);

    Q_CHECK_PTR(d->grayRaster.data());

    if (qt_ft_grays_raster.raster_new(0, d->grayRaster.data()))

        QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc

    qt_ft_grays_raster.raster_reset(*d->grayRaster.data(), d->rasterPoolBase, d->rasterPoolSize);

    d->rasterizer.reset(new QRasterizer);

    d->rasterBuffer.reset(new QRasterBuffer());

    d->outlineMapper.reset(new QOutlineMapper);

    d->outlinemapper_xform_dirty = true;

    d->basicStroker.setMoveToHook(qt_ft_outline_move_to);

    d->basicStroker.setLineToHook(qt_ft_outline_line_to);

    d->basicStroker.setCubicToHook(qt_ft_outline_cubic_to);

    d->baseClip.reset(new QClipData(d->device->height()));

    d->baseClip->setClipRect(QRect(0, 0, d->device->width(), d->device->height()));

    d->image_filler.init(d->rasterBuffer.data(), this);

    d->image_filler.type = QSpanData::Texture;

    d->image_filler_xform.init(d->rasterBuffer.data(), this);

    d->image_filler_xform.type = QSpanData::Texture;

    d->solid_color_filler.init(d->rasterBuffer.data(), this);

    d->solid_color_filler.type = QSpanData::Solid;

    d->deviceDepth = d->device->depth();

    d->mono_surface = false;

    gccaps &= ~PorterDuff;

    QImage::Format format = QImage::Format_Invalid;

    switch (d->device->devType()) {

    case QInternal::Pixmap:

        qWarning("QRasterPaintEngine: unsupported for pixmaps...");

        break;

    case QInternal::Image:

        format = d->rasterBuffer->prepare(static_cast<QImage *>(d->device));

        break;

#ifdef Q_WS_QWS

    case QInternal::CustomRaster:

        d->rasterBuffer->prepare(static_cast<QCustomRasterPaintDevice*>(d->device));

        break;

#endif

    default:

        qWarning("QRasterPaintEngine: unsupported target device %d\n", d->device->devType());

        d->device = 0;

        return;

    }

    switch (format) {

    case QImage::Format_MonoLSB:

    case QImage::Format_Mono:

        d->mono_surface = true;

        break;

    case QImage::Format_ARGB8565_Premultiplied:

    case QImage::Format_ARGB8555_Premultiplied:

    case QImage::Format_ARGB6666_Premultiplied:

    case QImage::Format_ARGB4444_Premultiplied:

    case QImage::Format_ARGB32_Premultiplied:

    case QImage::Format_ARGB32:

        gccaps |= PorterDuff;

        break;

    case QImage::Format_RGB32:

    case QImage::Format_RGB444:

    case QImage::Format_RGB555:

    case QImage::Format_RGB666:

    case QImage::Format_RGB888:

    case QImage::Format_RGB16:

        break;

    default:

        break;

    }

}

/*!

    Destroys this paint engine.

*/

QRasterPaintEngine::~QRasterPaintEngine()

{

    Q_D(QRasterPaintEngine);

#if defined(Q_WS_WIN64)

    _aligned_free(d->rasterPoolBase);

#else

    free(d->rasterPoolBase);

#endif

    qt_ft_grays_raster.raster_done(*d->grayRaster.data());

}

/*!

    \reimp

*/

bool QRasterPaintEngine::begin(QPaintDevice *device)

{

    Q_D(QRasterPaintEngine);

    if (device->devType() == QInternal::Pixmap) {

        QPixmap *pixmap = static_cast<QPixmap *>(device);

        if (pixmap->data->classId() == QPixmapData::RasterClass)

            d->device = pixmap->data->buffer();

    } else {

        d->device = device;

    }

    // Make sure QPaintEngine::paintDevice() returns the proper device.

    d->pdev = d->device;

    Q_ASSERT(d->device->devType() == QInternal::Image

             || d->device->devType() == QInternal::CustomRaster);

    d->systemStateChanged();

    QRasterPaintEngineState *s = state();

    ensureOutlineMapper();

    d->outlineMapper->m_clip_rect = d->deviceRect.adjusted(-10, -10, 10, 10);

    // This is the upp

    QRect bounds(-QT_RASTER_COORD_LIMIT, -QT_RASTER_COORD_LIMIT,

                 QT_RASTER_COORD_LIMIT*2 - 1, QT_RASTER_COORD_LIMIT * 2 - 1);

    d->outlineMapper->m_clip_rect = bounds.intersected(d->outlineMapper->m_clip_rect);

    d->rasterizer->setClipRect(d->deviceRect);

    s->penData.init(d->rasterBuffer.data(), this);

    s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode);

    s->stroker = &d->basicStroker;

    d->basicStroker.setClipRect(d->deviceRect);

    s->brushData.init(d->rasterBuffer.data(), this);

    s->brushData.setup(s->brush, s->intOpacity, s->composition_mode);

    d->rasterBuffer->compositionMode = QPainter::CompositionMode_SourceOver;

    setDirty(DirtyBrushOrigin);

#ifdef QT_DEBUG_DRAW

    qDebug() << "QRasterPaintEngine::begin(" << (void *) device

             << ") devType:" << device->devType()

             << "devRect:" << d->deviceRect;

    if (d->baseClip) {

        dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);

    }

#endif

#if defined(Q_WS_WIN)

    d->isPlain45DegreeRotation = true;

#endif

    if (d->mono_surface)

        d->glyphCacheType = QFontEngineGlyphCache::Raster_Mono;

#if defined(Q_WS_WIN)

    else if (qt_cleartype_enabled)

#elif defined (Q_WS_MAC)

    else if (qt_applefontsmoothing_enabled)

#else

    else if (false)

#endif

    {

        QImage::Format format = static_cast<QImage *>(d->device)->format();

        if (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)

            d->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;

        else

            d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;

    } else

        d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;

    setActive(true);

    return true;