source: trunk/doc/src/porting/qt4-arthur.qdoc

/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in a
** written agreement between you and Nokia.
**
** GNU Free Documentation License
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of this
** file.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \page qt4-arthur.html
    \title The Arthur Paint System

    \contentspage {What's New in Qt 4}{Home}
    \previouspage The Interview Framework
    \nextpage The Scribe Classes

    This document describes Qt 4's painting system, providing a
    comparison between the approaches used by Qt when rendering
    graphics in Qt 3 and Qt 4.

    \tableofcontents

    \section1 Architecture

    The Qt 4 Paint System is primarily based on the classes
    QPainter, QPaintDevice, and QPaintEngine. QPainter is the
    class used to perform drawing operations, such as drawLine()
    and drawRect(). QPaintDevice represents a device that can be
    painted on using a QPainter; both QWidget and QPixmap are
    QPaintDevices. QPaintEngine provides the interface that the
    painter uses to draw onto different types of devices.

    \section2 A Look Back at Qt 3

    In Qt 3, QPainter could be used to draw on widgets and pixmaps.
    (It could also be used to draw to printers on Windows and Mac OS
    X.) When other paint devices needed to be supported, such as
    QPrinter on X11, this was done by deriving from QPaintDevice and
    reimplementing the virtual function QPaintDevice::cmd(). A
    reimplemented paint device was treated as an external device.

    QPainter was capable of recognizing external devices and could
    serialize each paint operation to the reimplemented cmd()
    function. This allowed reimplementation of arbitrary devices, but
    the approach has some disadvantages which we have addressed in
    Qt 4. One of these is that an external device could not reuse any
    functionality implemented in QPainter since QPainter was tied to
    widget/pixmap painting on that platform. Supporting multiple
    device backends, such as OpenGL, was therefore inconvenient and
    not very efficient.

    This has led us to devise a more convenient and intuitive API for
    Qt 4.

    \section2 How Painting is Done in Qt 4

    In Qt 4 we have introduced the QPaintEngine abstract class.
    Implementations of this class provide the concrete functionality
    needed to draw to specific device types. The QPaintEngine class
    is only used internally by QPainter and QPaintDevice, and it is
    hidden from application programmers unless they reimplement their own
    device types for their own QPaintEngine subclasses. Qt currently
    provides paint engines for the following platforms and APIs:

    \list
    \o A pixel-based engine for the Windows platform that is
       also used to draw onto QImages on all platforms
    \o OpenGL on all platforms
    \o PostScript on Linux, Unix, and Mac OS X
    \o QuickDraw and CoreGraphics on Mac OS X
    \o X11 and the X Render Extension on Linux and Unix systems
    \omit
    \o QVFb, VNC, and LinuxFb for Qt for Embedded Linux
    \endomit
    \endlist

    To implement support for a new backend, you must derive from
    QPaintEngine and reimplement its virtual functions. You also need
    to derive from QPaintDevice and reimplement the virtual function
    QPaintDevice::paintEngine() to tell QPainter which paint engine
    should be used to draw on this particular device.

    The main benefit of this approach is that all painting follows the
    same painting pipeline. This means that adding support for new features
    and providing default implementations for unsupported ones has
    become much simpler.

    \section1 New Features in the Qt 4 Paint System

    \section2 Gradient Brushes

    With Qt 4 it is possible to fill shapes using gradient
    brushes. A gradient in this case is used to describe the transition
    from one color at a given point to different color at another point. A
    gradient can span from one color to another or over a
    number of colors by specifying multiple colors at positions in the
    gradient area. Qt 4 supports linear, radial, and conical gradients.

    Linear gradients are specified using two control points.
    Setting a linear gradient brush is done by creating a QLinearGradient
    object and setting it as a brush.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 0

    The code shown above produces a pattern as show in the following
    pixmap:

    \img diagonalGradient.png

    Radial gradients are specified using a center, a radius, and a
    focal point. Setting a radial brush is done by creating a QRadialGradient
    object and setting it as a brush.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 1

    The code shown above produces a pattern as shown in the following
    pixmap:

    \img radialGradient.png

    Conical gradients are specified using a center and a start
    angle. Setting a conical brush is done by creating a
    QConicalGradient object and setting it as a brush.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 2

    The code shown above produces a pattern as shown in the following
    pixmap:

    \img conicalGradient.png

    \section2 Alpha-Blended Drawing

    With Qt 4 we support alpha-blended outlining and filling. The
    alpha channel of a color is defined through QColor. The alpha
    channel specifies the transparency effect, 0 represents a fully
    transparent color, while 255 represents a fully opaque color. For
    example:

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 3

    The code shown above produces the following output:

    \img alphafill.png

    Alpha-blended drawing is supported on Windows, Mac OS X, and on
    X11 systems that have the X Render extension installed.


    \section2 QPainter and QGLWidget

    It is now possible to open a QPainter on a QGLWidget as if it
    were a normal QWidget. One huge benefit from this is that we
    utilize the high performance of OpenGL for most drawing
    operations, such as transformations and pixmap drawing.


    \section2 Anti-Aliased Edges

    On platforms where this is supported by the native drawing API, we
    provide the option of turning on anti-aliased edges when drawing
    graphics primitives.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 4

    This produces the following output:

    \img antialiased.png

    Anti-aliasing is supported when drawing to a QImage and on all
    systems, except on X11 when XRender is not present.


    \section2 Extensive Use of Native Graphics Operations

    Where this makes sense, Qt uses native graphics
    operations. The benefit we gain from this is that these operations
    can potentially be performed in hardware, giving significant
    speed improvements over many pure-software implementations.

    Among these are native transformations (Mac OS X and OpenGL),
    making painting with a world matrix much faster. Some pixmap
    operations have also been moved closer to the underlying
    hardware implementations.


    \section2 Painter Paths

    A painter path is an object composed of a number of graphical
    building blocks, such as rectangles, ellipses, lines, and curves.
    A painter path can be used for filling, outlining, and for clipping.
    The main advantage of painter paths over normal drawing operations
    is that it is possible to build up non-linear shapes which can be
    drawn later in one go.

    Building blocks can be joined in closed subpaths, such as a
    rectangle or an ellipse, or they can exist independently as unclosed
    subpaths, although an unclosed path will not be filled.

    Below is a code example on how a path can be used. The
    painter in this case has a pen width of 3 and a light blue brush. We
    first add a rectangle, which becomes a closed subpath.  We then add
    two bezier curves, and finally draw the entire path.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 5

    The code above produces the following output:

    \img pathexample.png


    \section2 Widget Double-Buffering

    In Qt 4, all widgets are double-buffered by default.

    In previous versions of Qt double-buffering was achieved by
    painting to an off-screen pixmap then copying the pixmap to the
    screen. For example:

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 6

    Since the double-buffering is handled by QWidget internally this
    now becomes:

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 7

    Double-buffering is turned on by default, but can be turned off for
    individual widgets by setting the widget attribute
    Qt::WA_PaintOnScreen.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 8

    \section2 Pen and Brush Transformation

    In Qt 3, pens and brushes weren't affected by the painter's
    transformation matrix. For example, if you drew a rectangle with a
    pen width of 1 using a scaled painter, the resulting line width
    would still be 1. This made it difficult to implement features
    such as zooming and high-resolution printing.

    In Qt 4, pens and brushes honor the painter's transformation
    matrix.

    Note that this feature is still in development and not yet
    supported on all platforms.

    \section2 Custom Filled Pens

    In Qt 4, it is possible to specify how an outline should be
    filled.  It can be a solid color or a QBrush, which makes it
    possible to specify both texture and gradient fills for both
    text and outlines.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 9

    The code above produces the following output:

    \img gradientText.png

    \section2 QImage as a Paint Device

    A great improvement of Qt 4 over previous versions it that it now
    provides a pixel-based raster paint engine which allows users to
    open a painter on a QImage. The QImage paint engine supports the
    full feature set of QPainter (paths, antialiasing, alphablending,
    etc.) and can be used on all platforms.

    One advantage of this is that it is possible to guarantee the
    pixel exactness of any drawing operation in a platform-independent
    way.

    Painting on an image is as simple as drawing on any other paint device.

    \snippet doc/src/snippets/code/doc_src_qt4-arthur.qdoc 10

    \section2 SVG Rendering Support

    \l{Scalable Vector Graphics} (SVG) is an language for describing both static
    and animated two-dimensional vector graphics. Qt includes support for the
    \l{SVG 1.2 Tiny Static Features}{static features} of \l{SVG 1.2 Tiny}, taking
    advantage of the improved paint system in Qt 4. SVG drawings can be rendered
    onto any QPaintDevice subclass, such as QWidget, QImage, and QGLWidget, to
    take advantage of specific advantages of each device. This approach gives
    developers the flexibility to experiment, in order to find the best solution
    for each application.

    \image svg-image.png

    Since SVG is an XML-based format, the QtXml module is required to read SVG
    files. For this reason, classes for SVG handling are provided separately in
    the QtSvg module.

    Displaying an SVG drawing in an application is as simple as displaying a
    bitmap image. QSvgWidget is a display widget that can be placed in an
    appropriate place in a user interface, and new content can be loaded as
    required. For example, a predetermined file can be loaded and displayed in
    a widget with little effort:

    \snippet doc/src/snippets/qsvgwidget/main.cpp 0

    For applications with more specialized requirements, the QSvgRenderer class
    provides more control over the way SVG drawings are rendered and animated.
*/