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

**

** 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 "qpaintengine.h"

#include "qpaintengine_p.h"

#include "qpainter_p.h"

#include "qpolygon.h"

#include "qbitmap.h"

#include "qapplication.h"

#include <qdebug.h>

#include <qmath.h>

#include <private/qtextengine_p.h>

#include <qvarlengtharray.h>

#include <private/qfontengine_p.h>

#include <private/qpaintengineex_p.h>

QT_BEGIN_NAMESPACE

/*!

    \class QTextItem

    \brief The QTextItem class provides all the information required to draw

    text in a custom paint engine.

    When you reimplement your own paint engine, you must reimplement

    QPaintEngine::drawTextItem(), a function that takes a QTextItem as

    one of its arguments.

*/

/*!

  \enum QTextItem::RenderFlag

  \value  RightToLeft Render the text from right to left.

  \value  Overline    Paint a line above the text.

  \value  Underline   Paint a line under the text.

  \value  StrikeOut   Paint a line through the text.

  \omitvalue Dummy

*/

/*!

    \fn qreal QTextItem::descent() const

    Corresponds to the \l{QFontMetrics::descent()}{descent} of the piece of text that is drawn.

*/

qreal QTextItem::descent() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return ti->descent.toReal();

}

/*!

    \fn qreal QTextItem::ascent() const

    Corresponds to the \l{QFontMetrics::ascent()}{ascent} of the piece of text that is drawn.

*/

qreal QTextItem::ascent() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return ti->ascent.toReal();

}

/*!

    \fn qreal QTextItem::width() const

    Specifies the total width of the text to be drawn.

*/

qreal QTextItem::width() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return ti->width.toReal();

}

/*!

    \fn QTextItem::RenderFlags QTextItem::renderFlags() const

    Returns the render flags used.

*/

QTextItem::RenderFlags QTextItem::renderFlags() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return ti->flags;

}

/*!

    \fn QString QTextItem::text() const

    Returns the text that should be drawn.

*/

QString QTextItem::text() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return QString(ti->chars, ti->num_chars);

}

/*!

    \fn QFont QTextItem::font() const

    Returns the font that should be used to draw the text.

*/

QFont QTextItem::font() const

{

    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);

    return ti->f ? *ti->f : QApplication::font();

}

/*!

  \class QPaintEngine

  \ingroup painting

  \brief The QPaintEngine class provides an abstract definition of how

  QPainter draws to a given device on a given platform.

  Qt 4.0 provides several premade implementations of QPaintEngine for the

  different painter backends we support. We provide one paint engine for each

  window system and painting framework we support. This includes X11 on

  Unix/Linux and CoreGraphics on Mac OS X. In addition we provide QPaintEngine

  implementations for OpenGL (accessible through QGLWidget) and PostScript

  (accessible through QPSPrinter on X11). Additionally there is a raster-based

  paint engine that is a fallback for when an engine does not support a certain

  capability.

  If one wants to use QPainter to draw to a different backend,

  one must subclass QPaintEngine and reimplement all its virtual

  functions. The QPaintEngine implementation is then made available by

  subclassing QPaintDevice and reimplementing the virtual function

  QPaintDevice::paintEngine().

  QPaintEngine is created and owned by the QPaintDevice that created it.

  The big advantage of the QPaintEngine approach opposed to

  Qt 3's QPainter/QPaintDevice::cmd() approach is that it is now

  possible to adapt to multiple technologies on each platform and take

  advantage of each to the fullest.

  \sa QPainter, QPaintDevice::paintEngine(), {The Paint System}

*/

/*!

  \enum QPaintEngine::PaintEngineFeature

  This enum is used to describe the features or capabilities that the

  paint engine has. If a feature is not supported by the engine,

  QPainter will do a best effort to emulate that feature through other

  means and pass on an alpha blended QImage to the engine with the

  emulated results. Some features cannot be emulated: AlphaBlend and PorterDuff.

  \value AlphaBlend         The engine can alpha blend primitives.

  \value Antialiasing       The engine can use antialising to improve the appearance

                            of rendered primitives.

  \value BlendModes         The engine supports blending modes.

  \value BrushStroke        The engine supports drawing strokes that

                            contain brushes as fills, not just solid

                            colors (e.g. a dashed gradient line of

                            width 2).

  \value ConicalGradientFill The engine supports conical gradient fills.

  \value ConstantOpacity    The engine supports the feature provided by

                            QPainter::setOpacity().

  \value LinearGradientFill The engine supports linear gradient fills.

  \value MaskedBrush        The engine is capable of rendering brushes that has a

                            texture with an alpha channel or a mask.

  \value ObjectBoundingModeGradients The engine has native support for gradients

                            with coordinate mode QGradient::ObjectBoundingMode.

                            Otherwise, if QPaintEngine::PatternTransform is

                            supported, object bounding mode gradients are

                            converted to gradients with coordinate mode

                            QGradient::LogicalMode and a brush transform for

                            the coordinate mapping.

  \value PainterPaths       The engine has path support.

  \value PaintOutsidePaintEvent The engine is capable of painting outside of

                                paint events.

  \value PatternBrush       The engine is capable of rendering brushes with

                            the brush patterns specified in Qt::BrushStyle.

  \value PatternTransform   The engine has support for transforming brush

                            patterns.

  \value PerspectiveTransform The engine has support for performing perspective

                            transformations on primitives.

  \value PixmapTransform    The engine can transform pixmaps, including

                            rotation and shearing.

  \value PorterDuff         The engine supports Porter-Duff operations

  \value PrimitiveTransform The engine has support for transforming

                            drawing primitives.

  \value RadialGradientFill The engine supports radial gradient fills.

  \value RasterOpModes      The engine supports bitwise raster operations.

  \value AllFeatures        All of the above features. This enum value is usually

                            used as a bit mask.

*/

/*!

    \enum QPaintEngine::PolygonDrawMode

    \value OddEvenMode The polygon should be drawn using OddEven fill

    rule.

    \value WindingMode The polygon should be drawn using Winding fill rule.

    \value ConvexMode The polygon is a convex polygon and can be drawn

    using specialized algorithms where available.

    \value PolylineMode Only the outline of the polygon should be

    drawn.

*/

/*!

    \enum QPaintEngine::DirtyFlag

    \value DirtyPen The pen is dirty and needs to be updated.

    \value DirtyBrush The brush is dirty and needs to be updated.

    \value DirtyBrushOrigin The brush origin is dirty and needs to

    updated.

    \value DirtyFont The font is dirty and needs to be updated.

    \value DirtyBackground The background is dirty and needs to be

    updated.

    \value DirtyBackgroundMode The background mode is dirty and needs

    to be updated.

    \value DirtyTransform The transform is dirty and needs to be

    updated.

    \value DirtyClipRegion The clip region is dirty and needs to be

    updated.

    \value DirtyClipPath The clip path is dirty and needs to be

    updated.

    \value DirtyHints The render hints is dirty and needs to be

    updated.

    \value DirtyCompositionMode The composition mode is dirty and

    needs to be updated.

    \value DirtyClipEnabled Whether clipping is enabled or not is

    dirty and needs to be updated.

    \value DirtyOpacity The constant opacity has changed and needs to

                        be updated as part of the state change in

                        QPaintEngine::updateState().

    \value AllDirty Convenience enum used internally.

    These types are used by QPainter to trigger lazy updates of the

    various states in the QPaintEngine using

    QPaintEngine::updateState().

    A paint engine must update every dirty state.

*/

/*!

    \fn void QPaintEngine::syncState()

    \internal

    Updates all dirty states in this engine. This function should ONLY

    be used when drawing with native handles directly and immediate sync

    from QPainters state to the native state is required.

*/

void QPaintEngine::syncState()

{

    Q_ASSERT(state);

    updateState(*state);

    if (isExtended())

        static_cast<QPaintEngineEx *>(this)->sync();

}

static QPaintEngine *qt_polygon_recursion = 0;

struct QT_Point {

    int x;

    int y;

};

/*!

    \fn void QPaintEngine::drawPolygon(const QPointF *points, int pointCount,

    PolygonDrawMode mode)

    Reimplement this virtual function to draw the polygon defined

    by the \a pointCount first points in \a points, using mode \a

    mode.

    \note At least one of the drawPolygon() functions must be reimplemented.

*/

void QPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)

{

    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",

               "At least one drawPolygon function must be implemented");

    qt_polygon_recursion = this;

    Q_ASSERT(sizeof(QT_Point) == sizeof(QPoint));

    QVarLengthArray<QT_Point> p(pointCount);

    for (int i = 0; i < pointCount; ++i) {

        p[i].x = qRound(points[i].x());

        p[i].y = qRound(points[i].y());

    }

    drawPolygon((QPoint *)p.data(), pointCount, mode);

    qt_polygon_recursion = 0;

}

struct QT_PointF {

    qreal x;

    qreal y;

};

/*!

    \overload

    Reimplement this virtual function to draw the polygon defined by the

    \a pointCount first points in \a points, using mode \a mode.

    \note At least one of the drawPolygon() functions must be reimplemented.

*/

void QPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)

{

    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",

               "At least one drawPolygon function must be implemented");

    qt_polygon_recursion = this;

    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));

    QVarLengthArray<QT_PointF> p(pointCount);

    for (int i=0; i<pointCount; ++i) {

        p[i].x = points[i].x();

        p[i].y = points[i].y();

    }

    drawPolygon((QPointF *)p.data(), pointCount, mode);

    qt_polygon_recursion = 0;

}

/*!

    \enum QPaintEngine::Type

    \value X11

    \value Windows

    \value MacPrinter

    \value CoreGraphics Mac OS X's Quartz2D (CoreGraphics)

    \value QuickDraw Mac OS X's QuickDraw

    \value QWindowSystem Qt for Embedded Linux

    \value PostScript

    \value OpenGL

    \value Picture QPicture format

    \value SVG Scalable Vector Graphics XML format

    \value Raster

    \value Direct3D Windows only, Direct3D based engine

    \value Pdf Portable Document Format

    \value OpenVG

    \value User First user type ID

    \value MaxUser Last user type ID

    \value OpenGL2

    \value PaintBuffer

*/

/*!

    \fn bool QPaintEngine::isActive() const

    Returns true if the paint engine is actively drawing; otherwise

    returns false.

    \sa setActive()

*/

/*!

    \fn void QPaintEngine::setActive(bool state)

    Sets the active state of the paint engine to \a state.

    \sa isActive()

*/

/*!

    \fn bool QPaintEngine::begin(QPaintDevice *pdev)

    Reimplement this function to initialise your paint engine when

    painting is to start on the paint device \a pdev. Return true if

    the initialization was successful; otherwise return false.

    \sa end() isActive()

*/

/*!

    \fn bool QPaintEngine::end()

    Reimplement this function to finish painting on the current paint

    device. Return true if painting was finished successfully;

    otherwise return false.

    \sa begin() isActive()

*/

/*!

    Draws the first \a pointCount points in the buffer \a points

*/

void QPaintEngine::drawPoints(const QPointF *points, int pointCount)

{

    QPainter *p = painter();

    if (!p)

        return;

    qreal penWidth = p->pen().widthF();

    if (penWidth == 0)

        penWidth = 1;

    bool ellipses = p->pen().capStyle() == Qt::RoundCap;

    p->save();

    QTransform transform;

    if (p->pen().isCosmetic()) {

        transform = p->transform();

        p->setTransform(QTransform());

    }

    p->setBrush(p->pen().brush());

    p->setPen(Qt::NoPen);

    for (int i=0; i<pointCount; ++i) {

        QPointF pos = transform.map(points[i]);

        QRectF rect(pos.x() - penWidth / 2, pos.y() - penWidth / 2, penWidth, penWidth);

        if (ellipses)

            p->drawEllipse(rect);

        else

            p->drawRect(rect);

    }

    p->restore();

}

/*!

    Draws the first \a pointCount points in the buffer \a points

    The default implementation converts the first \a pointCount QPoints in \a points

    to QPointFs and calls the floating point version of drawPoints.

*/

void QPaintEngine::drawPoints(const QPoint *points, int pointCount)

{

    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));

    QT_PointF fp[256];

    while (pointCount) {

        int i = 0;

        while (i < pointCount && i < 256) {

            fp[i].x = points[i].x();

            fp[i].y = points[i].y();

            ++i;

        }

        drawPoints((QPointF *)(void *)fp, i);

        points += i;

        pointCount -= i;

    }

}

/*!

    \fn void QPaintEngine::drawEllipse(const QRectF &rect)

    Reimplement this function to draw the largest ellipse that can be

    contained within rectangle \a rect.

    The default implementation calls drawPolygon().

*/

void QPaintEngine::drawEllipse(const QRectF &rect)

{

    QPainterPath path;

    path.addEllipse(rect);

    if (hasFeature(PainterPaths)) {

        drawPath(path);

    } else {

        QPolygonF polygon = path.toFillPolygon();

        drawPolygon(polygon.data(), polygon.size(), ConvexMode);

    }

}

/*!

    The default implementation of this function calls the floating

    point version of this function

*/

void QPaintEngine::drawEllipse(const QRect &rect)

{

    drawEllipse(QRectF(rect));

}

/*!

    \fn void QPaintEngine::drawPixmap(const QRectF &r, const QPixmap

    &pm, const QRectF &sr)

    Reimplement this function to draw the part of the \a pm

    specified by the \a sr rectangle in the given \a r.