Qt Paint System

根据Qt官方手册的整理。。。

Qt's paint system enables painting on screen and print devices using the same API, and is primarily based on the QPainter, QPaintDevice, and QPaintEngine classes.

QPainter is used to perform drawing operations, QPaintDevice is an abstraction of a two-dimensional space that can be painted on using a QPainter, and QPaintEngine provides the interface that the painter uses to draw onto different types of devices. The QPaintEngine class is used internally by QPainter and QPaintDevice, and is hidden from application programmers unless they create their own device type.

1、Paint Devices and Backends

The QPaintDevice class is the base class of objects that can be painted, i.e. QPainter can draw on any QPaintDevice subclass. QPaintDevice's drawing capabilities are currently implemented by the QWidget, QImage, QPixmap, QGLWidget, QGLPixelBuffer, QPicture and QPrinter subclasses.

Widget
The QWidget class is the base class of all user interface objects. The widget is the atom of the user interface: it receives mouse, keyboard and other events from the window system, and paints a representation of itself on the screen.
Image
The QImage class provides a hardware-independent image representation which is designed and optimized for I/O, and for direct pixel access and manipulation. QImage supports several image formats including monochrome, 8-bit, 32-bit and alpha-blended images.
One advantage of using QImage as a paint device is that it is possible to guarantee the pixel exactness of any drawing operation in a platform-independent way. Another benefit is that the painting can be performed in another thread than the current GUI thread.
Pixmap
The QPixmap class is an off-screen image representation which is designed and optimized for showing images on screen. Unlike QImage, the pixel data in a pixmap is internal and is managed by the underlying window system, i.e. pixels can only be accessed through QPainter functions or by converting the QPixmap to a QImage.
To optimize drawing with QPixmap, Qt provides the QPixmapCache class which can be used to store temporary pixmaps that are expensive to generate without using more storage space than the cache limit.
Qt also provides the QBitmap convenience class, inheriting QPixmap. QBitmap guarantees monochrome (1-bit depth) pixmaps, and is mainly used for creating custom QCursor and QBrush objects, constructing QRegion objects, and for setting masks for pixmaps and widgets.
OpenGL Widget
As mentioned previously, Qt provides the QtOpenGL module offering classes that makes it easy to use OpenGL in Qt applications. For example, the QGLWidget enables the OpenGL API for rendering.
But QGLWidget is also a QWidget subclass, and can be used by QPainter as any other paint device. One huge benefit from this is that it enables Qt to utilize the high performance of OpenGL for most drawing operations, such as transformations and pixmap drawing.
Pixel Buffer
The QtOpenGL module also provides the QGLPixelBuffer class which inherits QPaintDevice directly.
QGLPixelBuffer encapsulates an OpenGL pbuffer. Rendering into a pbuffer is normally done using full hardware acceleration which can be significantly faster than rendering into a QPixmap.
Framebuffer Object
The QtOpenGL module also provides the QGLFramebufferObject class which inherits QPaintDevice directly.
QGLFramebufferObject encapsulates an OpenGL framebuffer object. Framebuffer objects can also be used for off-screen rendering, and offer several advantages over pixel buffers for this purpose. These are described in the QGLFramebufferObject class documentation.
Picture
The QPicture class is a paint device that records and replays QPainter commands. A picture serializes painter commands to an IO device in a platform-independent format. QPicture is also resolution independent, i.e. a QPicture can be displayed on different devices (for example svg, pdf, ps, printer and screen) looking the same.
Qt provides the QPicture::load() and QPicture::save() functions as well as streaming operators for loading and saving pictures.
Printer
The QPrinter class is a paint device that paints on a printer. On Windows or Mac OS X, QPrinter uses the built-in printer drivers. On X11, QPrinter generates postscript and sends that to lpr, lp, or another print program. QPrinter can also print to any other QPrintEngine object.
The QPrintEngine class defines an interface for how QPrinter interacts with a given printing subsystem. The common case when creating your own print engine, is to derive from both QPaintEngine and QPrintEngine.
The output format is by default determined by the platform the printer is running on, but by explicitly setting the output format to QPrinter::PdfFormat, QPrinter will generate its output as a PDF file.
Custom Backends
Support for a new backend can be implemented by deriving from the QPaintDevice class and reimplementing the virtual QPaintDevice::paintEngine() function to tell QPainter which paint engine should be used to draw on this particular device. To actually be able to draw on the device, this paint engine must be a custom paint engine created by deriving from the QPaintEngine class.

2、Drawing and Filling

Drawing

QPainter provides highly optimized functions to do most of the drawing GUI programs require. It can draw everything from simple graphical primitives (represented by the QPoint, QLine, QRect, QRegion and QPolygon classes) to complex shapes like vector paths. In Qt vector paths are represented by the QPainterPath class. QPainterPath provides a container for painting operations, enabling graphical shapes to be constructed and reused.

     QPainterPath
A painter path is an object composed of lines and curves. For example, a rectangle is composed by lines and an ellipse is composed by curves.
The main advantage of painter paths over normal drawing operations is that complex shapes only need to be created once; then they can be drawn many times using only calls to the QPainter::drawPath() function.
A QPainterPath object can be used for filling, outlining, and clipping. To generate fillable outlines for a given painter path, use the QPainterPathStroker class.

Lines and outlines are drawn using the QPen class. A pen is defined by its style (i.e. its line-type), width, brush, how the endpoints are drawn (cap-style) and how joins between two connected lines are drawn (join-style). The pen's brush is a QBrush object used to fill strokes generated with the pen, i.e. the QBrush class defines the fill pattern.

QPainter can also draw aligned text and pixmaps.

When drawing text, the font is specified using the QFont class. Qt will use the font with the specified attributes, or if no matching font exists, Qt will use the closest matching installed font. The attributes of the font that is actually used can be retrieved using the QFontInfo class. In addition, the QFontMetrics class provides the font measurements, and the QFontDatabase class provides information about the fonts available in the underlying window system.

Normally, QPainter draws in a "natural" coordinate system, but it is able to perform view and world transformations using the QTransform class. For more information, see Coordinate System, which also describes the rendering process, i.e. the relation between the logical representation and the rendered pixels, and the benefits of anti-aliased painting.

Anti-Aliased Painting
When drawing, the pixel rendering is controlled by the QPainter::Antialiasing render hint. The QPainter::RenderHint enum is used to specify flags to QPainter that may or may not be respected by any given engine.
The QPainter::Antialiasing value indicates that the engine should antialias edges of primitives if possible, i.e. smoothing the edges by using different color intensities.

Filling

Shapes are filled using the QBrush class. A brush is defined by its color and its style (i.e. its fill pattern).

Any color in Qt is represented by the QColor class which supports the RGB, HSV and CMYK color models. QColor also support alpha-blended outlining and filling (specifying the transparency effect), and the class is platform and device independent (the colors are mapped to hardware using the QColormap class). For more information, see the QColor class documentation.

When creating a new widget, it is recommend to use the colors in the widget's palette rather than hard-coding specific colors. All widgets in Qt contain a palette and use their palette to draw themselves. A widget's palette is represented by the QPalette class which contains color groups for each widget state.

The available fill patterns are described by the Qt::BrushStyle enum. These include basic patterns spanning from uniform color to very sparse pattern, various line combinations, gradient fills and textures. Qt provides the QGradient class to define custom gradient fills, while texture patterns are specified using the QPixmap class.

QGradient
The QGradient class is used in combination with QBrush to specify gradient fills.

Qt currently supports three types of gradient fills: Linear gradients interpolate colors between start and end points, radial gradients interpolate colors between a focal point and end points on a circle surrounding it, and conical gradients interpolate colors around a center point.

3、Coordinate System

The coordinate system is controlled by the QPainter class. Together with the QPaintDevice and QPaintEngine classes, QPainter form the basis of Qt's painting system, Arthur. QPainter is used to perform drawing operations, QPaintDevice is an abstraction of a two-dimensional space that can be painted on using a QPainter, and QPaintEngine provides the interface that the painter uses to draw onto different types of devices.

The QPaintDevice class is the base class of objects that can be painted: Its drawing capabilities are inherited by the QWidget, QPixmap, QPicture, QImage, and QPrinter classes. The default coordinate system of a paint device has its origin at the top-left corner. The x values increase to the right and the y values increase downwards. The default unit is one pixel on pixel-based devices and one point (1/72 of an inch) on printers.

The mapping of the logical QPainter coordinates to the physical QPaintDevice coordinates are handled by QPainter's transformation matrix, viewport and "window". The logical and physical coordinate systems coincide by default. QPainter also supports coordinate transformations (e.g. rotation and scaling).

4、Reading and Writing Image Files

The most common way to read images is through QImage and QPixmap's constructors, or by calling the QImage::load() and QPixmap::load() functions. In addition, Qt provides the QImageReader class which gives more control over the process. Depending on the underlying support in the image format, the functions provided by the class can save memory and speed up loading of images.

Likewise, Qt provides the QImageWriter class which supports setting format specific options, such as the gamma level, compression level and quality, prior to storing the image. If you do not need such options, you can use QImage::save() or QPixmap::save() instead.

QMovie
QMovie is a convenience class for displaying animations, using the QImageReader class internally. Once created, the QMovie class provides various functions for both running and controlling the given animation.

The QImageReader and QImageWriter classes rely on the QImageIOHandler class which is the common image I/O interface for all image formats in Qt. QImageIOHandler objects are used internally by QImageReader and QImageWriter to add support for different image formats to Qt.

A list of the supported file formats are available through the QImageReader::supportedImageFormats() and QImageWriter::supportedImageFormats() functions. Qt supports several file formats by default, and in addition new formats can be added as plugins. The currently supported formats are listed in the QImageReader and QImageWriter class documentation.

Qt's plugin mechanism can also be used to write a custom image format handler. This is done by deriving from the QImageIOHandler class, and creating a QImageIOPlugin object which is a factory for creating QImageIOHandler objects. When the plugin is installed, QImageReader and QImageWriter will automatically load the plugin and start using it.

Rendering SVG files

SVG Rendering
Scalable Vector Graphics (SVG) is a language for describing two-dimensional graphics and graphical applications in XML. SVG 1.1 is a W3C Recommendation and forms the core of the current SVG developments in Qt. SVG 1.2 is the specification currently being developed by the SVG Working Group, and it is available in draft form. The Mobile SVG Profiles (SVG Basic and SVG Tiny) are aimed at resource-limited devices and are part of the 3GPP platform for third generation mobile phones. You can read more about SVG at About SVG.
Qt supports the static features of SVG 1.2 Tiny. ECMA scripts and DOM manipulation are currently not supported.
SVG drawings can be rendered onto any QPaintDevice subclass. This approach gives developers the flexibility to experiment, in order to find the best solution for each application.
The easiest way to render SVG files is to construct a QSvgWidget and load an SVG file using one of the QSvgWidget::load() functions.
QSvgRenderer is the class responsible for rendering SVG files for QSvgWidget, and it can be used directly to provide SVG support for custom widgets. To load an SVG file, construct a QSvgRenderer with a file name or the contents of a file, or call QSvgRenderer::load() on an existing renderer. If the SVG file has been loaded successfully the QSvgRenderer::isValid() will return true.
Once you have loaded the SVG file successfully, you can render it with the QSvgRenderer::render() function. Note that this scheme allows you to render SVG files on all paint devices supported by Qt, including QWidget, QGLWidget, and QImage. See the SVG Viewer example for more details.

5、Styling

Qt's built-in widgets use the QStyle class to perform nearly all of their drawing. QStyle is an abstract base class that encapsulates the look and feel of a GUI, and can be used to make the widgets look exactly like the equivalent native widgets or to give the widgets a custom look.

Qt provides a set of QStyle subclasses that emulate the native look of the different platforms supported by Qt (QWindowsStyle, QMacStyle, QMotifStyle, etc.). These styles are built into the QtGui library, other styles can be made available using Qt's plugin mechansim.

Most functions for drawing style elements take four arguments:

an enum value specifying which graphical element to draw
a QStyleOption object specifying how and where to render that element
a QPainter object that should be used to draw the element
a QWidget object on which the drawing is performed (optional)

The style gets all the information it needs to render the graphical element from the QStyleOption class. The widget is passed as the last argument in case the style needs it to perform special effects (such as animated default buttons on Mac OS X), but it isn't mandatory. In fact, QStyle can be used to draw on any paint device (not just widgets), in which case the widget argument is a zero pointer.

The paint system also provides the QStylePainter class inheriting from QPainter. QStylePainter is a convenience class for drawing QStyle elements inside a widget, and extends QPainter with a set of high-level drawing functions implemented on top of QStyle's API. The advantage of using QStylePainter is that the parameter lists get considerably shorter.

6、Printing with Qt

Qt provides extensive cross-platform support for printing. Using the printing systems on each platform, Qt applications can print to attached printers and across networks to remote printers. Qt's printing system also enables PostScript and PDF files to be generated, providing the foundation for basic report generation facilities.

Classes Supporting Printing

The following classes support the selecting and setting up of printers and printing output.

QAbstractPrintDialog     Base implementation for print dialogs used to configure printers
QPageSetupDialog        Configuration dialog for the page-related options on a printer
QPrintDialo                      Dialog for specifying the printer's configuration
QPrintEngine                   Defines an interface for how QPrinter interacts with a given printing subsystem
QPrintPreviewDialog     Dialog for previewing and configuring page layouts for printer output
QPrintPreviewWidget    Widget for previewing page layouts for printer output
QPrinter                           Paint device that paints on a printer
QPrinterInfo                    Gives access to information about existing printers

7、Classes for Painting

These classes provide support for painting onto a paint device.

QBitmap                             Monochrome (1-bit depth) pixmaps
QBrush                               Defines the fill pattern of shapes drawn by QPainter
QColor                                Colors based on RGB, HSV or CMYK values
QColormap                        Maps device independent QColors to device dependent pixel values
QConicalGradient            Used in combination with QBrush to specify a conical gradient brush
QDirectPainter                  Direct access to the underlying hardware in Qt for Embedded Linux
QFont                                  Specifies a font used for drawing text
QFontMetrics                     Font metrics information
QFontMetricsF                   Font metrics information
QGenericMatrix                 Template class that represents a NxM transformation matrix with N columns and M rows
QGradient                          Used in combination with QBrush to specify gradient fills
QIcon                                  Scalable icons in different modes and states
QIconEngine                     Abstract base class for QIcon renderers
QIconEngineV2                Abstract base class for QIcon renderers
QImage                              Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device
QImageReader                Format independent interface for reading images from files or other devices
QImageWriter                   Format independent interface for writing images to files or other devices
QLine                                 Two-dimensional vector using integer precision
QLineF                               Two-dimensional vector using floating point precision
QLinearGradient              Used in combination with QBrush to specify a linear gradient brush
QMargins                           Defines the four margins of a rectangle
QMovie                               Convenience class for playing movies with QImageReader
QPaintDevice                    The base class of objects that can be painted
QPaintEngine                    Abstract definition of how QPainter draws to a given device on a given platform
QPainter                             Performs low-level painting on widgets and other paint devices
QPainterPath                     Container for painting operations, enabling graphical shapes to be constructed and reused
QPainterPathStroker        Used to generate fillable outlines for a given painter path
QPalette                             Contains color groups for each widget state
QPen                                  Defines how a QPainter should draw lines and outlines of shapes
QPicture                             Paint device that records and replays QPainter commands
QPixmap                            Off-screen image representation that can be used as a paint device
QPixmapCache                Application-wide cache for pixmaps
QPlatformFontDatabase           Makes it possible to customize how fonts are discovered and how they are rendered
QPlatformWindowFormat          Specifies the display format of an OpenGL rendering context and if possible attributes of the corresponding QPlatformWindow
QPoint                               Defines a point in the plane using integer precision
QPointF                             Defines a point in the plane using floating point precision
QPolygon                          Vector of points using integer precision
QPolygonF                        Vector of points using floating point precision
QRadialGradient             Used in combination with QBrush to specify a radial gradient brush
QRect                                Defines a rectangle in the plane using integer precision
QRectF                              Defines a rectangle in the plane using floating point precision
QRegion                           Specifies a clip region for a painter
QSize                                 Defines the size of a two-dimensional object using integer point precision
QSizeF                               Defines the size of a two-dimensional object using floating point precision
QStylePainter                   Convenience class for drawing QStyle elements inside a widget
QSupportedWritingSystems               Used when registering fonts with the internal Qt fontdatabase
QSvgGenerator                                      Paint device that is used to create SVG drawings
QSvgRenderer                                       Used to draw the contents of SVG files onto paint devices
QSvgWidget                                           Widget that is used to display the contents of Scalable Vector Graphics (SVG) files
QSymbianGraphicsSystemHelper
QTransform                                           Specifies 2D transformations of a coordinate system
QVector2D                                             Represents a vector or vertex in 2D space