1
/****************************************************************************
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4
** Contact: Nokia Corporation (qt-info@nokia.com)
6
** This file is part of the documentation of the Qt Toolkit.
8
** $QT_BEGIN_LICENSE:LGPL$
10
** Licensees holding valid Qt Commercial licenses may use this file in
11
** accordance with the Qt Commercial License Agreement provided with the
12
** Software or, alternatively, in accordance with the terms contained in
13
** a written agreement between you and Nokia.
15
** GNU Lesser General Public License Usage
16
** Alternatively, this file may be used under the terms of the GNU Lesser
17
** General Public License version 2.1 as published by the Free Software
18
** Foundation and appearing in the file LICENSE.LGPL included in the
19
** packaging of this file. Please review the following information to
20
** ensure the GNU Lesser General Public License version 2.1 requirements
21
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23
** In addition, as a special exception, Nokia gives you certain
24
** additional rights. These rights are described in the Nokia Qt LGPL
25
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
28
** GNU General Public License Usage
29
** Alternatively, this file may be used under the terms of the GNU
30
** General Public License version 3.0 as published by the Free Software
31
** Foundation and appearing in the file LICENSE.GPL included in the
32
** packaging of this file. Please review the following information to
33
** ensure the GNU General Public License version 3.0 requirements will be
34
** met: http://www.gnu.org/copyleft/gpl.html.
36
** If you are unsure which license is appropriate for your use, please
37
** contact the sales department at http://www.qtsoftware.com/contact.
40
****************************************************************************/
43
\page graphicsview-porting.html
44
\title Porting to Graphics View
45
\contentspage {Porting Guides}{Contents}
46
\previouspage Porting .ui Files to Qt 4
47
\nextpage qt3to4 - The Qt 3 to 4 Porting Tool
50
\brief Hints and tips to assist with porting canvas applications to the
51
Graphics View framework.
53
\keyword QGraphicsView GraphicsView Porting Graphics Canvas
56
Graphics View provides a surface for managing and interacting with a large
57
number of custom-made 2D graphical items, and a view widget for
58
visualizing the items, with support for zooming and rotation. Graphics
59
View was introduced in Qt 4.2, replacing its predecessor, QCanvas. For
60
more on Graphics View, see \l{The Graphics View Framework}.
62
This document walks through the steps needed, class by class and function
63
by function, to port a QCanvas application to Graphics View.
67
Qt 4.2 provides two complete examples of Q3Canvas applications ported to
71
\o \l{Ported Canvas Example}, the canvas example from Qt 3.
72
\o \l{Ported Asteroids Example}, the Asteroids game from the Qt 3 demo.
75
\section1 Introduction
77
Conceptually, the Graphics View classes from Qt 4 and the Canvas
78
classes from Qt 3 provide similar functionality using a similar
79
design. Instead of "canvas", we use the term "scene". Otherwise, the
80
class names and functions are almost the same as in Qt 3. The easiest
81
classes to port will be QCanvas and QCanvasView. Experience shows that
82
most time is spent porting the item classes, depending on the
83
complexity of the QCanvasItem classes you have been using before.
85
This porting guide will assume you have already ported your
86
application to Qt 4, by making use of Q3Canvas. If you have not done
87
so already, as a first step, run the \l qt3to4 tool on your
88
project. This tool will automate the most tedious part of the porting
91
Some additional steps are usually required before your application
92
will compile and run. You can read more about the porting process in
95
\section1 Porting from Q3Canvas
97
QGraphicsScene is the closest equivalent to Q3Canvas. There
98
are some noticable differences in this new API: Whereas the
99
Q3Canvas classes use integer precision, QGraphicsScene is
100
entirely based on double coordinates, with graphical
101
primitives such as QPointF instead of QPoint, QRectF instead
102
of QRect, and QPolygonF and QPainterPath. The canvas area is
103
defined by a scene rectangle, allowing negative coordinates,
104
as opposed to Q3Canvas, which only defines a size (QSize), and
105
whose top-left corner is always (0, 0).
107
In addition, there is no explicit support for canvas tiles
108
anymore; see \l{Porting scenes with tiles} for more
109
information. The chunks-based indexing system has been
110
replaced with an implicitly maintained internal BSP tree.
112
\section2 Porting table
115
\header \o Q3Canvas \o QGraphicsScene
117
\row \o Q3Canvas::Q3Canvas() \o There is no QPixmap based
118
constructor, and the concept of tiles is gone. You can use
119
QGraphicsScene::backgroundBrush to set a brush pattern for
120
the background, or reimplement
121
QGraphicsScene::drawBackground() in a QGraphicsScene
122
subclass (see \l{Porting scenes with tiles}). In addition,
123
the QGraphicsScene geometry is provided as a full
124
QRectF. Instead of Q3Canvas(int width, int height), you can
125
use QGraphicsScene(int top, int left, int width, int
128
\row \o Q3Canvas::allItems() \o QGraphicsScene::items()
129
returns a list of all items on the scene.
131
\row \o Q3Canvas::backgroundColor() \o You can assign a color for the
132
background through the QGraphicsScene::backgroundBrush
133
or QGraphicsView::backgroundBrush properties.
135
\row \o Q3Canvas::backgroundPixmap() \o You can set a tiled
136
pixmap for the background through
137
QGraphicsScene::backgroundBrush or
138
QGraphicsView::backgroundBrush. For more control on the pixmap
139
positioning, you can reimplement
140
QGraphicsScene::drawBackground() or
141
QGraphicsView::drawBackground().
143
\row \o Q3Canvas::chunkSize() \o The closest equivalent to the
144
chunks size in Q3Canvas is the depth of QGraphicsScene's BSP
145
tree. QGraphicsScene assigns a depth automatically, and the
146
size of each scene segment depends on this depth, and
147
QGraphicsScene::sceneRect(). See
148
QGraphicsScene::itemIndexMethod.
150
\row \o Q3Canvas::collisions() \o QGraphicsScene provides
151
several means to detect item collisions. The
152
QGraphicsScene::items() overloads return items that collide
153
with a point, a rectangle, a polygon, or an arbitrary vector
154
path (QPainterPath). You can also call
155
QGraphicsScene::collidingItems() to determine collision with
158
\row \o Q3Canvas::drawArea() \o The QGraphicsScene::render()
159
function provides the original behavior
160
Q3Canvas::drawArea(). In addition, you can pass a source
161
rectangle for rendering only parts of the scene, and a
162
destination rectangle for rendering onto designated area of
163
the destination device. QGraphicsScene::render() can
164
optionally transform the source rectangle to fit into the
165
destination rectangle. See \l{Printing}
167
\row \o Q3Canvas::onCanvas() \o The is no equivalent to this
168
function in Graphics View. However, you can combine
169
QGraphicsScene::sceneRect() and QRectF::intersects():
170
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 0
172
\row \o Q3Canvas::rect() \o The equivalent,
173
QGraphicsScene::sceneRect(), returns a QRectF (double
174
precision coordinates). Its top-left corner can be an
175
arbitrary coordinate (Q3Canvas::rect().topLeft() is always (0,
178
\row \o Q3Canvas::resize() \o You can call
179
QGraphicsScene::setSceneRect(0, 0, width, height) instead.
181
\row \o Q3Canvas::retune() \o See
182
QGraphicsScene::itemIndexMethod. You can tune the indexing by
183
setting a suitable sceneRect(). The optimal depth of
184
QGraphicsScene's BSP tree is determined automatically.
186
\row \o Q3Canvas::setAdvancePeriod() \o There is no concept of
187
an advance period in the new API; instead, you can connect
188
QTimer::timeout() to the QGraphicsScene::advance() slot to
189
obtain similar functionality. This will cause all items'
190
QGraphicsItem::advance() function to be called. See also
191
QGraphicsItemAnimation.
193
\row \o Q3Canvas::setAllChanged() \o You can call
194
QGraphicsScene::update() with no arguments.
196
\row \o Q3Canvas::setChanged() \o QGraphicsScene::update()
197
will trigger a repaint of the whole scene, or parts of the
200
\row \o Q3Canvas::setDoubleBuffering() \o Q3Canvas' double
201
buffering enabled cacheing of the scene contents in device
202
(i.e., viewport) coordinates. This cache layer has been moved
203
to the view instead; you can cache QGraphicsScene's background
205
QGraphicsView::setCacheMode(). QGraphicsView::resetCachedContent()
206
will reset the areas of the cache that has changed.
208
\row \o Q3Canvas::tile() \o See \l{Porting scenes with tiles}.
210
\row \o Q3Canvas::setTiles() \o See \l{Porting scenes with tiles}.
212
\row \o Q3Canvas::setUnchanged() \o There is no equivalent in
213
Graphics View. This call can usually be removed with no side
216
\row \o Q3Canvas::setUpdatePeriod() \o There is no concept of an
217
update period in the new API; instead, you can connect
218
QTimer::timeout() to the QGraphicsScene::update() slot to obtain
219
similar functionality. See also QGraphicsItemAnimation.
221
\row \o Q3Canvas::size() \o
222
\tt{QGraphicsScene::sceneRect().size()} returns a QSizeF, with
223
double precision coordinates.
225
\row \o Q3Canvas::validChunk() \o To determine if an area is
226
inside the scene area or not, you can combine
227
QRectF::intersects() with QGraphicsScene::sceneRect().
229
\row \o Q3Canvas::resized() \o QGraphicsScene emits
230
\l{QGraphicsScene::sceneRectChanged()}{sceneRectChanged()}
231
whenever the scene rect changes.
233
\row \o Q3Canvas::drawBackground() \o You can reimplement
234
QGraphicsScene::drawBackground() to render the scene
235
background. You can also reimplement
236
QGraphicsView::drawBackground() to override this background if
237
you need different backgrounds for different views.
239
\row \o Q3Canvas::drawForeground() \o You can reimplement
240
QGraphicsScene::drawForeground() to render the scene
241
foreground. You can also reimplement
242
QGraphicsView::drawForeground() to override this foreground if
243
you need different foregrounds for different views.
247
\section2 Porting scenes with tiles
249
QGraphicsScene does not provide an API for tiles. However, you
250
can achieve similar behavior by drawing pixmaps in a reimplementation of
251
QGraphicsScene::drawBackground().
253
Q3Canvas' tile support is based on providing one pixmap
254
containing tiles of a fixed width and height, and then
255
accessing them (reading and replacing tiles) by index. The
256
tiles in the pixmap are arranged from the left to right, top
260
\row \i 0 \i 1 \i 2 \i 3
261
\row \i 4 \i 5 \i 6 \i 7
264
With Graphics View, this pixmap can be stored as a member of a
265
subclass of QGraphicsScene. The three main functions that make
266
out the public tile API can then be declared as new members of
267
this class. Here is one example of how to implement tile support:
269
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 1
271
Depending on how your scene uses tiles, you may be able to
272
simplify this approach. In this example, we will try to mimic the behavior
273
of the Q3Canvas functions.
275
We start by creating a subclass of QGraphicsScene ("TileScene").
276
In this class, we declare two of the tile
277
functions from Q3Canvas, and we then add two helper function that returns the
278
rectangle for a certain tile in our tile pixmap. We will use a
279
two-dimensional vector of ints to keep track of what tiles should
280
be used at what parts of the scene.
282
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 2
284
In setTiles(), we store the pixmap and tile properties as
285
members of the class. Then we resize the tiles vector
286
to match the width and height of our tile grid.
288
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 3
290
The setTile() function updates the tiles index, and then
291
updates the corresponding rect in the scene by calling
294
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 4
296
The first tileRect() function returns a QRect for the tile at
299
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 5
301
The second tileRect() function returns a QRect for a tile number.
302
With these functions in place, we can implement the drawBackground()
305
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 6
307
In drawBackground(), we redraw all tiles that have been
308
exposed by intersecting each tile rect with the exposed background
311
\section1 Porting from Q3CanvasView
313
The closest equivalent to Q3CanvasView in Graphics View is
314
called QGraphicsView. In most cases, this is the easiest
315
class to port. In addition to providing all of Q3CanvasView's
316
functionality, QGraphicsView includes some useful new features. You
317
can read more about this in QGraphicsView's documentation.
319
\section2 Porting table
322
\header \o Q3CanvasView \o QGraphicsView
324
\row \o Q3CanvasView::Q3CanvasView() \o QGraphicsView provides
325
the same constructors as Q3CanvasView, but without the name
326
and flags arguments. You can set the name by calling
327
\l{QWidget::setObjectName()}{setObjectName()}, and the flags by
328
calling \l{QWidget::setWindowFlags()}{setWindowFlags()}.
330
\row \o Q3CanvasView::canvas() \o QGraphicsView::scene()
331
returns the scene that is currently associated with the
332
view. QGraphicsScene also provides the opposite function,
333
QGraphicsScene::views(), which returns a list of views
336
\row \o Q3CanvasView::inverseWorldMatrix() \o You can call
337
QGraphicsView::matrix() and QMatrix::inverted().
338
QGraphicsView::mapToScene() and QGraphicsView::mapFromScene()
339
allow transforming of viewport shapes to scene shapes, and
342
\row \o Q3CanvasView::setCanvas() \o QGraphicsView::setScene().
344
\row \o Q3CanvasView::setWorldMatrix() \o
345
QGraphicsView::setMatrix(), QGraphicsView::rotate(),
346
QGraphicsView::scale(), QGraphicsView::shear() and
347
QGraphicsView::translate().
349
\row \o Q3CanvasView::worldMatrix() \o QGraphicsView::matrix()
351
\row \o Q3CanvasView::drawContents() \o The
352
QGraphicsView::drawBackground() function draws the background,
353
QGraphicsView::drawItems() draws the items, and
354
QGraphicsView::drawForeground() draws the foreground of the
355
scene in scene coordinates. You can also reimplement these
356
functions in QGraphicsScene.
360
\section2 Other differences
362
QGraphicsView can cache the visible contents of the scene,
363
similar to how Q3Canvas::setDoubleBuffering() could cache the
364
entire scene contents. You can call
365
QGraphicsView::setCacheMode() to configure cacheing, and
366
QGraphicsView::resetCachedContent() invalidates the cache.
368
For improved navigation support, you can set a resize or
369
transformation anchor through QGraphicsView::resizeAnchor and
370
QGraphicsView::transformationAnchor. This allows you to easily
371
rotate and zoom the view while keeping the center fixed, or
372
zooming towards the position under the mouse cursor. In
373
addition, if you set the QGraphicsView::dragMode of the view,
374
QGraphicsView will provide rubber band selection or
375
click-and-pull navigation using the
376
\l{Qt::OpenHandCursor}{OpenHandCursor} and
377
\l{Qt::ClosedHandCursor}{ClosedHandCursor} cursors.
379
\section1 Porting from Q3CanvasItem
381
The closest equivalent to Q3CanvasItem in Graphics View is
382
called QGraphicsItem. Deriving from this class is very common,
383
and because of that, porting from Q3CanvasItem often involves
384
more work than Q3Canvas and Q3CanvasView.
386
Q3CanvasItem has become easier to use, easier to subclass, and more
387
powerful with QGraphicsItem. The key difference from Q3CanvasItem lies
388
in event propagation and item groups, but you will also find several
389
convenient new features, such as support for tooltips, cursors, item
390
transformation and drag and drop. You can read all about QGraphicsItem
391
in its own class documentation.
393
This section starts with a table that shows how to port each function
394
from Q3CanvasItem to QGraphicsItem. Immediately after that, each of
395
Q3CanvasItem's standard subclasses have a section of their own.
398
\header \o Q3CanvasItem \o QGraphicsItem
400
\row \o Q3CanvasItem::advance() \o QGraphicsItem::advance() is
401
provided for compatibility. QGraphicsScene::advance() calls
402
QGraphicsItem::advance() for all items. See also QTimeLine and
403
QGraphicsItemAnimation.
405
\row \o Q3CanvasItem::animated() \o No equivalent; all items
406
are advanced by QGraphicsScene::advance().
408
\row \o Q3CanvasItem::boundingRectAdvanced() \o No
409
equivalent. You can translate QGraphicsItem::boundingRect()
410
instead (see QRectF::translate()).
412
\row \o Q3CanvasItem::canvas() \o QGraphicsItem::scene()
414
\row \o Q3CanvasItem::collidesWith() \o
415
QGraphicsItem::collidesWithItem() and
416
QGraphicsItem::collidesWithPath().
418
\row \o Q3CanvasItem::collisions() \o
419
QGraphicsItem::collidingItems() returns a list of all items
420
that collide with an item. You can specify whether you want
421
fast, rough estimate collision between bounding rectangles, or
422
the slower, more accurate shapes.
424
\row \o Q3CanvasItem::draw() \o QGraphicsItem::paint(). See
425
also QStyleOptionGraphicsItem, QGraphicsScene::drawItems() and
426
QGraphicsView::drawItems().
428
\row \o Q3CanvasItem::hide() \o QGraphicsItem::hide() or
429
QGraphicsItem::setVisible(). \l{QGraphicsItem}s are \e visible by
430
default; \l{Q3CanvasItem}s, however, are not.
432
\row \o Q3CanvasItem::isActive() \o No equivalent. To achieve
433
similar behavior, you can add this property in a custom
434
subclass of QGraphicsItem.
436
\row \o Q3CanvasItem::isVisible() \o
437
QGraphicsItem::isVisible(). \l{QGraphicsItem}s are \e visible by
438
default; \l{Q3CanvasItem}s, however, are not.
440
\row \o Q3CanvasItem::move() \o You can call
441
QGraphicsItem::setPos() to change the position of the item.
443
\row \o Q3CanvasItem::rtti() \o QGraphicsItem::type() and qgraphicsitem_cast().
445
\row \o Q3CanvasItem::setActive() \o No equivalent.
447
\row \o Q3CanvasItem::setAnimated() \o No equivalent; all
448
items are by default "animated" (i.e.,
449
QGraphicsScene::advance() advances all items on the scene).
451
\row \o Q3CanvasItem::setCanvas() \o You can call
452
QGraphicsScene::addItem(), or pass a pointer to the canvas to
453
QGraphicsItem's constructor.
455
\row \o Q3CanvasItem::setVelocity() \o No equivalent. You can
456
add x and y velocity as member data of your class, and call
457
QGraphicsItem::moveBy(x, y) from inside
458
QGraphicsItem::advance(). See also QTimeLine and
459
QGraphicsItemAnimation.
461
\row \o Q3CanvasItem::setVisible() \o
462
QGraphicsItem::setVisible(). \l{QGraphicsItem}s are \e visible by
463
default; \l{Q3CanvasItem}s, however, are not.
465
\row \o Q3CanvasItem::setX() \o QGraphicsItem::setPos()
466
\row \o Q3CanvasItem::setY() \o QGraphicsItem::setPos()
468
\row \o Q3CanvasItem::setXVelocity() \o No equivalent.
469
\row \o Q3CanvasItem::setYVelocity() \o No equivalent.
471
\row \o Q3CanvasItem::setZ() \o QGraphicsItem::setZValue()
473
\row \o Q3CanvasItem::show() \o QGraphicsItem::show() or
474
QGraphicsItem::setVisible(). \l{QGraphicsItem}s are \e visible by
475
default; \l{Q3CanvasItem}s, however, are not.
477
\row \o Q3CanvasItem::xVelocity() \o No equivalent.
478
\row \o Q3CanvasItem::yVelocity() \o No equivalent.
482
Note that some virtual functions that have passed on to
483
QGraphicsItem have lost their virtuality. An example is
484
Q3CanvasItem::moveBy(), which was often used to track movement of
485
items. In this case, the virtual QGraphicsItem::itemChange() has
486
taken over as a substitute.
488
\section2 Q3CanvasPolygonalItem
490
The closest equivalent to Q3CanvasPolygonalItem in
491
Graphics View is called QAbstractGraphicsShapeItem. Unlike
492
Q3CanvasPolygonalItem, it does not define area points
493
(Q3CanvasPolygonalItem::areaPoints()); instead, each
494
item's geometry is stored as a member of the subclasses.
496
The Q3CanvasPolygonalItem::drawShape() function is no longer
497
available; instead, you can set the brush and pen from inside
498
QGraphicsItem::paint().
501
\header \o Q3CanvasPolygonalItem \o QAbstractGraphicsShapeItem
503
\row \o Q3CanvasPolygonalItem::areaPoints() \o No equivalent; each
504
item's geometry is stored in the respective subclass.
506
\row \o Q3CanvasPolygonalItem::areaPointsAdvanced() \o No
507
equivalent; you can use QPolygonF::translate() or
508
QPainterPath::translate() instead.
510
\row \o Q3CanvasPolygonalItem::drawShape() \o
511
QGraphicsItem::paint(). You can set the pen and brush from inside
514
\row \o Q3CanvasPolygonalItem::invalidate() \o Call
515
QGraphicsItem::prepareGeometryChange() before changing the
518
\row \o Q3CanvasPolygonalItem::isValid() \o No equivalent;
519
items' geometry is always in a valid state.
521
\row \o Q3CanvasPolygonalItem::winding() \o This function is only
522
useful for polygon items and path items; see
523
QGraphicsPolygonItem::fillRule(), and QPainterPath::fillRule() for
528
\section2 Q3CanvasEllipse
530
The closest equivalent to Q3CanvasEllipse in Graphics View
531
is called QGraphicsEllipseItem. The most noticable
532
difference to QGraphicsEllipseItem is that the ellipse is
533
not longer drawn centered around its position; rather, it
534
is drawn using a bounding QRectF, just like
535
QPainter::drawEllipse().
537
For compatibility, you may want to shift the ellipse up and to the
538
left to keep the ellipse centered. Example:
540
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 7
542
Note: QGraphicsEllipseItem uses QAbstractGraphicsShapeItem::pen()
543
for outlines, whereas Q3CanvasEllipse did not use
544
Q3CanvasPolygonalItem::pen().
547
\header \o Q3CanvasEllipse \o QGraphicsEllipseItem
549
\row \o Q3CanvasEllipse::angleLength() \o QGraphicsEllipseItem::spanAngle()
551
\row \o Q3CanvasEllipse::angleStart() \o QGraphicsEllipseItem::startAngle()
553
\row \o Q3CanvasEllipse::setAngles() \o
554
QGraphicsEllipseItem::setStartAngle() and
555
QGraphicsEllipseItem::setSpanAngle()
557
\row \o Q3CanvasEllipse::setSize() \o QGraphicsEllipseItem::setRect()
561
\section2 Q3CanvasLine
563
The closest equivalent to Q3CanvasLine in Graphics View is
564
called QGraphicsLineItem.
567
\header \o Q3CanvasLine \o QGraphicsLineItem
569
\row \o Q3CanvasLine::endPoint() \o QGraphicsLineItem::line() and QLineF::p2()
571
\row \o Q3CanvasLine::setPoints() \o QGraphicsLineItem::setLine()
573
\row \o Q3CanvasLine::startPoint() \o QGraphicsLineItem::line()
578
\section2 Q3CanvasPolygon
580
The closest equivalent to Q3CanvasPolygon in Graphics View
581
is called QGraphicsPolygonItem.
584
\header \o Q3CanvasPolygon \o QGraphicsPolygonItem
586
\row \o Q3CanvasPolygon::areaPoints() \o
587
QGraphicsPolygonItem::polygon() and QGraphicsItem::mapToParent()
589
\row \o Q3CanvasPolygon::points() \o QGraphicsPolygonItem::polygon()
591
\row \o Q3CanvasPolygon::setPoints() \o QGraphicsPolygonItem::setPolygon()
595
\section2 Q3CanvasSpline
597
The closest equivalent to Q3CanvasSpline in Graphics View
598
is called QGraphicsPathItem. This item can be used to
599
describe any type of path supported by QPainter.
601
Q3CanvasSpline takes its control points as a Q3PointArray, but
602
QPainterPath operates on a sequence of calls to
603
QPainterPath::moveTo() and QPainterPath::cubicTo(). Here is how
604
you can convert a bezier curve Q3PointArray to a QPainterPath:
606
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 8
608
Note: QGraphicsPathItem uses QAbstractGraphicsShapeItem::pen() for
609
outlines, whereas Q3CanvasSpline did not use
610
Q3CanvasPolygonalItem::pen().
613
\header \o Q3CanvasSpline \o QGraphicsPathItem
615
\row \o Q3CanvasSpline::closed() \o No equivalent. You can call
616
QPainterPath::closeSubPath() to close a subpath explicitly.
620
\section2 Q3CanvasRectangle
622
The closest equivalent to Q3CanvasRectangle in Graphics
623
View is called QGraphicsRectItem.
626
\header \o Q3CanvasRectangle \o QGraphicsRectItem
628
\row \o Q3CanvasRectangle::height() \o QGraphicsRectItem::rect()
631
\row \o Q3CanvasRectangle::setSize() \o QGraphicsRectItem::setRect()
633
\row \o Q3CanvasRectangle::size() \o QGraphicsRectItem::rect() and QRectF::size()
635
\row \o Q3CanvasRectangle::width() \o QGraphicsRectItem::rect() and QRectF::width()
637
\row \o Q3CanvasRectangle::chunks() \o No equivalent.
641
\section2 Q3CanvasSprite
643
Q3CanvasSprite is the item class that differs the most from its
644
Q3Canvas predecessor. The closest resemblance of Q3CanvasSprite in
645
Graphics View is QGraphicsPixmapItem.
647
Q3CanvasSprite supports animated pixmaps; QGraphicsPixmapItem,
648
however, is a simple single-frame pixmap item. If all you need is
649
a pixmap item, porting is straight-forward. If you do need the
650
animation support, extra work is required; there is no direct
653
For the \l{Ported Asteroids Example}, a subclass of
654
QGraphicsPixmapItem is used to replace Q3CanvasSprite, storing a
655
list of pixmaps and a frame counter. The animation is advanced in
656
QGraphicsItem::advance().
658
\section3 Q3CanvasPixmap, Q3CanvasPixmapArray
660
These classes have been removed from the API. You can use
661
QPixmap instead of Q3CanvasPixmap, and QList instead of
664
Q3CanvasPixmapArray included convenience for loading a
665
sequence of pixmaps or masks using a path with a wildcard (see
666
Q3CanvasPixmapArray::readPixmaps() and
667
Q3CanvasPixmapArray::readCollisionMasks()). To achieve similar
668
functionality using Graphics View, you can load the images by
671
\snippet doc/src/snippets/code/doc_src_porting4-canvas.qdoc 9
673
\section2 Q3CanvasText
675
Q3CanvasText has been split into two classes in Graphics View:
676
QGraphicsSimpleTextItem and QGraphicsTextItem. For porting,
677
QGraphicsSimpleTextItem should be adequate. QGraphicsTextItem
678
provides advanced document structuring features similar to that of
679
QTextEdit, and it also allows interaction (e.g., editing and
683
\header \o Q3CanvasText \o QGraphicsSimpleTextItem
685
\row \o Q3CanvasText::color() \o QGraphicsSimpleTextItem::pen().
687
\row \o Q3CanvasText::setColor() \o QGraphicsSimpleTextItem::setPen().
689
\row \o Q3CanvasText::textFlags() \o Use QGraphicsTextItem instead.
694
\section2 Q3CanvasItemList
698
\section1 Other Resources
700
The \l{Porting to Qt 4.2's Graphics View} article in Qt Quarterly 21 covered the
701
process of porting the Qt 3 canvas example to Qt 4.
702
The result of this is the \l{Ported Canvas Example}{Ported Canvas} example.
added
removed
doc/src/porting4-canvas.qdoc
