FCL/sf/mw/qt: comparison doc/src/porting/qt4-arthur.qdoc

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
+/****************************************************************************
+**
+** 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 documentation 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$
+**
+****************************************************************************/
+/*!
+\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.
+*/