Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages

RedHat 9 (Linux i386) - man page for qcanvas (redhat section 3qt)

QCanvas(3qt)									     QCanvas(3qt)

NAME
       QCanvas - 2D area that can contain QCanvasItem objects

SYNOPSIS
       #include <qcanvas.h>

       Inherits QObject.

   Public Members
       QCanvas ( QObject * parent = 0, const char * name = 0 )
       QCanvas ( int w, int h )
       QCanvas ( QPixmap p, int h, int v, int tilewidth, int tileheight )
       virtual ~QCanvas ()
       virtual void setTiles ( QPixmap p, int h, int v, int tilewidth, int tileheight )
       virtual void setBackgroundPixmap ( const QPixmap & p )
       QPixmap backgroundPixmap () const
       virtual void setBackgroundColor ( const QColor & c )
       QColor backgroundColor () const
       virtual void setTile ( int x, int y, int tilenum )
       int tile ( int x, int y ) const
       int tilesHorizontally () const
       int tilesVertically () const
       int tileWidth () const
       int tileHeight () const
       virtual void resize ( int w, int h )
       int width () const
       int height () const
       QSize size () const
       QRect rect () const
       bool onCanvas ( int x, int y ) const
       bool onCanvas ( const QPoint & p ) const
       bool validChunk ( int x, int y ) const
       bool validChunk ( const QPoint & p ) const
       int chunkSize () const
       virtual void retune ( int chunksze, int mxclusters = 100 )
       virtual void setAllChanged ()
       virtual void setChanged ( const QRect & area )
       virtual void setUnchanged ( const QRect & area )
       QCanvasItemList allItems ()
       QCanvasItemList collisions ( const QPoint & p ) const
       QCanvasItemList collisions ( const QRect & r ) const
       QCanvasItemList collisions ( const QPointArray & chunklist, const QCanvasItem * item, bool
	   exact ) const
       void drawArea ( const QRect & clip, QPainter * painter, bool dbuf = FALSE )
       virtual void setAdvancePeriod ( int ms )
       virtual void setUpdatePeriod ( int ms )
       virtual void setDoubleBuffering ( bool y )

   Public Slots
       virtual void advance ()
       virtual void update ()

   Signals
       void resized ()

   Protected Members
       virtual void drawBackground ( QPainter & painter, const QRect & clip )
       virtual void drawForeground ( QPainter & painter, const QRect & clip )

DESCRIPTION
       The QCanvas class provides a 2D area that can contain QCanvasItem objects.

       The QCanvas class manages its 2D graphic area and all the canvas items the area contains.
       The canvas is displayed on screen with a QCanvasView widget. Multiple QCanvasView widgets
       may be associated with a canvas to provide multiple views of the same canvas.

       The canvas is optimized for large numbers of items. Qt provides a rich set of canvas item
       classes, e.g. QCanvasEllipse, QCanvasLine, QCanvasPolygon, QCanvasPolygonalItem,
       QCanvasRectangle, QCanvasSpline, QCanvasSprite and QCanvasText. You can subclass to create
       your own canvas items; QCanvasPolygonalItem is the most common base class used for this
       purpose.

       Items appear on the canvas after their show() function has been called (or
       setVisible(TRUE)), and after update() has been called. The canvas only shows items that
       are visible, and then only if update() is called. If you created the canvas without
       passing a width and height to the constructor you'll also need to call resize().

       Although a canvas may appear to be similar to a widget with child widgets, there are
       several notable differences:

       Canvas items are usually far faster to manipulate and redraw than child widgets, with the
       speed advantage becoming especially great when there are many canvas items and non-
       rectangular items. In most situations canvas items are also a lot more memory efficient
       than child widgets.

       It's easy to detect overlapping items (collision detection).

       The canvas can be larger than a widget. A million-by-million canvas is perfectly possible.
       At such a size a widget might be very inefficient, and some window systems might not
       support it at all, whereas QCanvas scales well. Even with a billion pixels and a million
       items, finding a particular canvas item, detecting collisions, etc., is still fast (though
       the memory consumption may be prohibitive at such an extreme).

       Two or more QCanvasView objects can view the same canvas.

       An arbitrary transformation matrix can be set on each QCanvasView which makes it easy to
       zoom, rotate or shear the viewed canvas.

       Widgets provide a lot more functionality, such as input (QKeyEvent, QMouseEvent etc.) and
       layout management (QGridLayout etc.).

       A canvas consists of a background, a number of canvas items organized by x, y and z
       coordinates, and a foreground. A canvas item's z coordinate may be treated as a layer
       number -- canvas items with a higher z coordinate appear in front of canvas items with a
       lower z coordinate.

       The background is white by default, but can be set to a different color using
       setBackgroundColor(), or to a repeated pixmap using setBackgroundPixmap() or to a mosaic
       of smaller pixmaps using setTiles(). Individual tiles can be set with setTile(). There are
       corresponding get functions, e.g. backgroundColor() and backgroundPixmap().

       Note that QCanvas does not inherit from QWidget, even though it has some functions which
       provide the same functionality as those in QWidget. One of these is setBackgroundPixmap();
       some others are resize(), size(), width() and height(). QCanvasView is the widget used to
       display a canvas on the screen.

       Canvas items are added to a canvas by constructing them and passing the canvas to the
       canvas item's constructor. An item can be moved to a different canvas using
       QCanvasItem::setCanvas().

       Canvas items are movable (and in the case of QCanvasSprites, animated) objects that
       inherit QCanvasItem. Each canvas item has a position on the canvas (x, y coordinates) and
       a height (z coordinate), all of which are held as floating-point numbers. Moving canvas
       items also have x and y velocities. It's possible for a canvas item to be outside the
       canvas (for example QCanvasItem::x() is greater than width()). When a canvas item is off
       the canvas, onCanvas() returns FALSE and the canvas disregards the item. (Canvas items off
       the canvas do not slow down any of the common operations on the canvas.)

       Canvas items can be moved with QCanvasItem::move(). The advance() function moves all
       QCanvasItem::animated() canvas items and setAdvancePeriod() makes QCanvas move them
       automatically on a periodic basis. In the context of the QCanvas classes, to `animate' a
       canvas item is to set it in motion, i.e. using QCanvasItem::setVelocity(). Animation of a
       canvas item itself, i.e. items which change over time, is enabled by calling
       QCanvasSprite::setFrameAnimation(), or more generally by subclassing and reimplementing
       QCanvasItem::advance(). To detect collisions use one of the QCanvasItem::collisions()
       functions.

       The changed parts of the canvas are redrawn (if they are visible in a canvas view)
       whenever update() is called. You can either call update() manually after having changed
       the contents of the canvas, or force periodic updates using setUpdatePeriod(). If you have
       moving objects on the canvas, you need to call advance() every time the objects should
       move one step further. Periodic calls to advance() can be forced using setAdvancePeriod().
       The advance() function will call QCanvasItem::advance() on every item that is animated and
       trigger an update of the affected areas afterwards. (A canvas item that is `animated' is
       simply a canvas item that is in motion.)

       QCanvas organizes its canvas items into chunks; these are areas on the canvas that are
       used to speed up most operations. Many operations start by eliminating most chunks (i.e.
       those which haven't changed) and then process only the canvas items that are in the few
       interesting (i.e. changed) chunks. A valid chunk, validChunk(), is one which is on the
       canvas.

       The chunk size is a key factor to QCanvas's speed: if there are too many chunks, the speed
       benefit of grouping canvas items into chunks is reduced. If the chunks are too large, it
       takes too long to process each one. The QCanvas constructor picks a hopefully suitable
       size, but you can call retune() to change it at any time. The chunkSize() function returns
       the current chunk size.

       The canvas items always make sure they're in the right chunks; all you need to make sure
       of is that the canvas uses the right chunk size. A good rule of thumb is that the size
       should be a bit smaller than the average canvas item size. If you have moving objects, the
       chunk size should be a bit smaller than the average size of the moving items.

       The foreground is normally nothing, but if you reimplement drawForeground(), you can draw
       things in front of all canvas items.

       Areas can be set as changed with setChanged() and set unchanged with setUnchanged(). The
       entire canvas can be set as changed with setAllChanged(). A list of all the items on the
       canvas is returned by allItems().

       An area can be copied (painted) to a QPainter with drawArea().

       If the canvas is resized it emits the resized() signal.

       The examples/canvas application and the 2D graphics page of the examples/demo application
       demonstrate many of QCanvas's facilities.

       See also QCanvasView, QCanvasItem, Abstract Widget Classes, Graphics Classes, and Image
       Processing Classes.

MEMBER FUNCTION DOCUMENTATION
QCanvas::QCanvas ( QObject * parent = 0, const char * name = 0 )
       Create a QCanvas with no size. parent and name are passed to the QObject superclass.

       Warning: You must call resize() at some time after creation to be able to use the canvas.

QCanvas::QCanvas ( int w, int h )
       Constructs a QCanvas that is w pixels wide and h pixels high.

QCanvas::QCanvas ( QPixmap p, int h, int v, int tilewidth, int tileheight )
       Constructs a QCanvas which will be composed of h tiles horizontally and v tiles
       vertically. Each tile will be an image tilewidth by tileheight pixels taken from pixmap p.

       The pixmap p is a list of tiles, arranged left to right, (and in the case of pixmaps that
       have multiple rows of tiles, top to bottom), with tile 0 in the top-left corner, tile 1
       next to the right, and so on, e.g.

       <center>.nf

       </center>

       The QCanvas is initially sized to show exactly the given number of tiles horizontally and
       vertically. If it is resized to be larger, the entire matrix of tiles will be repeated as
       much as necessary to cover the area. If it is smaller, tiles to the right and bottom will
       not be visible.

       See also setTiles().

QCanvas::~QCanvas () [virtual]
       Destroys the canvas and all the canvas's canvas items.

void QCanvas::advance () [virtual slot]
       Moves all QCanvasItem::animated() canvas items on the canvas and refreshes all changes to
       all views of the canvas. (An `animated' item is an item that is in motion; see
       setVelocity().)

       The advance takes place in two phases. In phase 0, the QCanvasItem::advance() function of
       each QCanvasItem::animated() canvas item is called with paramater 0. Then all these canvas
       items are called again, with parameter 1. In phase 0, the canvas items should not change
       position, merely examine other items on the canvas for which special processing is
       required, such as collisions between items. In phase 1, all canvas items should change
       positions, ignoring any other items on the canvas. This two-phase approach allows for
       considerations of "fairness", although no QCanvasItem subclasses supplied with Qt do
       anything interesting in phase 0.

       The canvas can be configured to call this function periodically with setAdvancePeriod().

       See also update().

QCanvasItemList QCanvas::allItems ()
       Returns a list of all items in the canvas.

QColor QCanvas::backgroundColor () const
       Returns the color set by setBackgroundColor(). By default, this is white.

       This function is not a reimplementation of QWidget::backgroundColor() (QCanvas is not a
       subclass of QWidget), but all QCanvasViews that are viewing the canvas will set their
       backgrounds to this color.

       See also setBackgroundColor() and backgroundPixmap().

QPixmap QCanvas::backgroundPixmap () const
       Returns the pixmap set by setBackgroundPixmap(). By default, this is a null pixmap.

       See also setBackgroundPixmap() and backgroundColor().

int QCanvas::chunkSize () const
       Returns the chunk size of the canvas.

       See also retune().

QCanvasItemList QCanvas::collisions ( const QPoint & p ) const
       Returns a list of canvas items that collide with the point p. The list is ordered by z
       coordinates, from highest z coordinate (front-most item) to lowest z coordinate (rear-most
       item).

QCanvasItemList QCanvas::collisions ( const QRect & r ) const
       This is an overloaded member function, provided for convenience. It behaves essentially
       like the above function.

       Returns a list of items which collide with the rectangle r. The list is ordered by z
       coordinates, from highest z coordinate (front-most item) to lowest z coordinate (rear-most
       item).

QCanvasItemList QCanvas::collisions ( const QPointArray & chunklist, const QCanvasItem * item,
       bool exact ) const
       This is an overloaded member function, provided for convenience. It behaves essentially
       like the above function.

       Returns a list of canvas items which intersect with the chunks listed in chunklist,
       excluding item. If exact is TRUE, only those which actually QCanvasItem::collidesWith()
       item are returned; otherwise canvas items are included just for being in the chunks.

       This is a utility function mainly used to implement the simpler QCanvasItem::collisions()
       function.

void QCanvas::drawArea ( const QRect & clip, QPainter * painter, bool dbuf = FALSE )
       Paints all canvas items that are in the area clip to painter, using double-buffering if
       dbuf is TRUE.

       e.g. to print the canvas to a printer:

	 QPrinter pr;
	 if ( pr.setup() ) {
	   QPainter p(&pr);
	   canvas.drawArea( canvas.rect(), &p );
	 }

       Example: canvas/canvas.cpp.

void QCanvas::drawBackground ( QPainter & painter, const QRect & clip ) [virtual protected]
       This virtual function is called for all updates of the canvas. It renders any background
       graphics using the painter painter, in the area clip. If the canvas has a background
       pixmap or a tiled background, that graphic is used, otherwise the canvas is cleared using
       the background color.

       If the graphics for an area change, you must explicitly call setChanged(const QRect&) for
       the result to be visible when update() is next called.

       See also setBackgroundColor(), setBackgroundPixmap(), and setTiles().

void QCanvas::drawForeground ( QPainter & painter, const QRect & clip ) [virtual protected]
       This virtual function is called for all updates of the canvas. It renders any foreground
       graphics using the painter painter, in the area clip.

       If the graphics for an area change, you must explicitly call setChanged(const QRect&) for
       the result to be visible when update() is next called.

       The default is to draw nothing.

int QCanvas::height () const
       Returns the height of the canvas, in pixels.

       Example: canvas/canvas.cpp.

bool QCanvas::onCanvas ( int x, int y ) const
       Returns TRUE if the pixel position (x, y) is on the canvas; otherwise returns FALSE.

       See also validChunk().

bool QCanvas::onCanvas ( const QPoint & p ) const
       This is an overloaded member function, provided for convenience. It behaves essentially
       like the above function.

       Returns TRUE if the pixel position p is on the canvas; otherwise returns FALSE.

       See also validChunk().

QRect QCanvas::rect () const
       Returns a rectangle the size of the canvas.

void QCanvas::resize ( int w, int h ) [virtual]
       Changes the size of the canvas to have a width of w and a height of h. This is a slow
       operation.

       Examples:

void QCanvas::resized () [signal]
       This signal is emitted whenever the canvas is resized. Each QCanvasView connects to this
       signal to keep the scrollview size correct.

void QCanvas::retune ( int chunksze, int mxclusters = 100 ) [virtual]
       Change the efficiency tuning parameters to mxclusters clusters, each of size chunksze.
       This is a slow operation if there are many objects on the canvas.

       The canvas is divided into chunks which are rectangular areas of the canvas chunksze wide
       by chunksze high. Use a chunk size which is about the average size of the canvas items. If
       you choose a chunk size which is too small it will increase the amount of calculation
       required when drawing since each change will affect many chunks. If you choose a chunk
       size which is too large the amount of drawing required will increase because for each
       change, a lot of drawing will be required since there will be many (unchanged) canvas
       items which are in the same chunk as the changed canvas items.

       Internally, a canvas uses a low-resolution "chunk matrix" to keep track of all the items
       in the canvas. A 64x64 chunk matrix is the default for a 1024x1024 pixel canvas, where
       each chunk collects canvas items in a 16x16 pixel square. This default is also affected by
       setTiles(). You can tune this default with this function. For example if you have a very
       large canvas and want to trade off speed for memory then you might set the chunk size to
       32 or 64.

       The mxclusters argument is the number of rectangular groups of chunks that will be
       separately drawn. If the canvas has a large number of small, dispersed items, this should
       be about that number. Our testing suggests that a large number of clusters is almost
       always best.

void QCanvas::setAdvancePeriod ( int ms ) [virtual]
       Sets the canvas to call advance() every ms milliseconds. Any previous setting by
       setAdvancePeriod() or setUpdatePeriod() is overridden.

       If ms is less than 0 advancing will be stopped.

       Example: canvas/main.cpp.

void QCanvas::setAllChanged () [virtual]
       Marks the whole canvas as changed. All views of the canvas will be entirely redrawn when
       update() is called next.

void QCanvas::setBackgroundColor ( const QColor & c ) [virtual]
       Sets the solid background to be the color c.

       See also backgroundColor(), setBackgroundPixmap(), and setTiles().

void QCanvas::setBackgroundPixmap ( const QPixmap & p ) [virtual]
       Sets the solid background to be the pixmap p repeated as necessary to cover the entire
       canvas.

       See also backgroundPixmap(), setBackgroundColor(), and setTiles().

void QCanvas::setChanged ( const QRect & area ) [virtual]
       Marks area as changed. This area will be redrawn in all views that are showing it when
       update() is called next.

void QCanvas::setDoubleBuffering ( bool y ) [virtual]
       If y is TRUE (the default) double-buffering is switched on; otherwise double-buffering is
       switched off.

       Turning off double-buffering causes the redrawn areas to flicker a bit and also gives a
       (usually small) performance improvement.

       Example: canvas/canvas.cpp.

void QCanvas::setTile ( int x, int y, int tilenum ) [virtual]
       Sets the tile at (x, y) to use tile number tilenum, which is an index into the tile
       pixmaps. The canvas will update appropriately when update() is next called.

       The images are taken from the pixmap set by setTiles() and are arranged left to right,
       (and in the case of pixmaps that have multiple rows of tiles, top to bottom), with tile 0
       in the top-left corner, tile 1 next to the right, and so on, e.g.

       <center>.nf

       </center>

       See also tile() and setTiles().

void QCanvas::setTiles ( QPixmap p, int h, int v, int tilewidth, int tileheight ) [virtual]
       Sets the QCanvas to be composed of h tiles horizontally and v tiles vertically. Each tile
       will be an image tilewidth by tileheight pixels from pixmap p.

       The pixmap p is a list of tiles, arranged left to right, (and in the case of pixmaps that
       have multiple rows of tiles, top to bottom), with tile 0 in the top-left corner, tile 1
       next to the right, and so on, e.g.

       <center>.nf

       </center>

       If the canvas is larger than the matrix of tiles, the entire matrix is repeated as
       necessary to cover the whole canvas. If it is smaller, tiles to the right and bottom are
       not visible.

       The width and height of p must be a multiple of tilewidth and tileheight. If they are not
       the function will do nothing.

void QCanvas::setUnchanged ( const QRect & area ) [virtual]
       Marks area as unchanged. The area will not be redrawn in the views for the next update(),
       unless it is marked or changed again before the next call to update().

void QCanvas::setUpdatePeriod ( int ms ) [virtual]
       Sets the canvas to call update() every ms milliseconds. Any previous setting by
       setAdvancePeriod() or setUpdatePeriod() is overridden.

       If ms is less than 0 automatic updating will be stopped.

QSize QCanvas::size () const
       Returns the size of the canvas, in pixels.

int QCanvas::tile ( int x, int y ) const
       Returns the tile at position (x, y). Initially, all tiles are 0.

       The parameters must be within range, i.e. 0 < x < tilesHorizontally() and 0 < y <
       tilesVertically().

       See also setTile().

int QCanvas::tileHeight () const
       Returns the height of each tile.

int QCanvas::tileWidth () const
       Returns the width of each tile.

int QCanvas::tilesHorizontally () const
       Returns the number of tiles horizontally.

int QCanvas::tilesVertically () const
       Returns the number of tiles vertically.

void QCanvas::update () [virtual slot]
       Repaints changed areas in all views of the canvas.

       See also advance().

bool QCanvas::validChunk ( int x, int y ) const
       Returns TRUE if the chunk position (x, y) is on the canvas; otherwise returns FALSE.

       See also onCanvas().

bool QCanvas::validChunk ( const QPoint & p ) const
       This is an overloaded member function, provided for convenience. It behaves essentially
       like the above function.

       Returns TRUE if the chunk position p is on the canvas; otherwise returns FALSE.

       See also onCanvas().

int QCanvas::width () const
       Returns the width of the canvas, in pixels.

       Example: canvas/canvas.cpp.

SEE ALSO
       http://doc.trolltech.com/qcanvas.html http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2001 Trolltech AS, http://www.trolltech.com.  See the license file included
       in the distribution for a complete license statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is located at
       $QTDIR/doc/html and can be read using Qt Assistant or with a web browser. This man page is
       provided as a convenience for those users who prefer man pages, although this format is
       not officially supported by Trolltech.

       If you find errors in this manual page, please report them to qt-bugs@trolltech.com.
       Please include the name of the manual page (qcanvas.3qt) and the Qt version (3.1.1).

Trolltech AS				 9 December 2002			     QCanvas(3qt)


All times are GMT -4. The time now is 11:43 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
UNIX.COM Login
Username:
Password:  
Show Password