You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5416 lines
139 KiB
5416 lines
139 KiB
/**********************************************************************
|
|
**
|
|
** Implementation of TQCanvas and associated classes
|
|
**
|
|
** Created : 991211
|
|
**
|
|
** Copyright (C) 1999-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the canvas module of the TQt GUI Toolkit.
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
** Alternatively you may (at your option) use any later version
|
|
** of the GNU General Public License if such license has been
|
|
** publicly approved by Trolltech ASA (or its successors, if any)
|
|
** and the KDE Free TQt Foundation.
|
|
**
|
|
** Please review the following information to ensure GNU General
|
|
** Public Licensing requirements will be met:
|
|
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
|
|
** If you are unsure which license is appropriate for your use, please
|
|
** review the following information:
|
|
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
|
|
** or contact the sales department at sales@trolltech.com.
|
|
**
|
|
** This file may be used under the terms of the Q Public License as
|
|
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
|
|
** included in the packaging of this file. Licensees holding valid TQt
|
|
** Commercial licenses may use this file in accordance with the TQt
|
|
** Commercial License Agreement provided with the Software.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "ntqcanvas.h"
|
|
#ifndef QT_NO_CANVAS
|
|
#include "ntqapplication.h"
|
|
#include "ntqbitmap.h"
|
|
#include "ntqimage.h"
|
|
#include "ntqptrdict.h"
|
|
#include "ntqpainter.h"
|
|
#include "ntqpolygonscanner.h"
|
|
#include "ntqtimer.h"
|
|
#include "ntqtl.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
class TQCanvasData {
|
|
public:
|
|
TQCanvasData() :
|
|
itemDict(1013), animDict(503)
|
|
{
|
|
}
|
|
|
|
TQPtrList<TQCanvasView> viewList;
|
|
TQPtrDict<void> itemDict;
|
|
TQPtrDict<void> animDict;
|
|
};
|
|
|
|
class TQCanvasViewData {
|
|
public:
|
|
TQCanvasViewData() : repaint_from_moving( FALSE ) {}
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
TQWMatrix xform;
|
|
TQWMatrix ixform;
|
|
#endif
|
|
bool repaint_from_moving;
|
|
};
|
|
|
|
// clusterizer
|
|
|
|
class TQCanvasClusterizer {
|
|
public:
|
|
TQCanvasClusterizer(int maxclusters);
|
|
~TQCanvasClusterizer();
|
|
|
|
void add(int x, int y); // 1x1 rectangle (point)
|
|
void add(int x, int y, int w, int h);
|
|
void add(const TQRect& rect);
|
|
|
|
void clear();
|
|
int clusters() { return count; }
|
|
const TQRect& operator[](int i);
|
|
|
|
private:
|
|
TQRect* cluster;
|
|
int count;
|
|
const int maxcl;
|
|
};
|
|
|
|
static
|
|
void include(TQRect& r, const TQRect& rect)
|
|
{
|
|
if (rect.left()<r.left()) {
|
|
r.setLeft(rect.left());
|
|
}
|
|
if (rect.right()>r.right()) {
|
|
r.setRight(rect.right());
|
|
}
|
|
if (rect.top()<r.top()) {
|
|
r.setTop(rect.top());
|
|
}
|
|
if (rect.bottom()>r.bottom()) {
|
|
r.setBottom(rect.bottom());
|
|
}
|
|
}
|
|
|
|
/*
|
|
A TQCanvasClusterizer groups rectangles (TQRects) into non-overlapping rectangles
|
|
by a merging heuristic.
|
|
*/
|
|
TQCanvasClusterizer::TQCanvasClusterizer(int maxclusters) :
|
|
cluster(new TQRect[maxclusters]),
|
|
count(0),
|
|
maxcl(maxclusters)
|
|
{ }
|
|
|
|
TQCanvasClusterizer::~TQCanvasClusterizer()
|
|
{
|
|
delete [] cluster;
|
|
}
|
|
|
|
void TQCanvasClusterizer::clear()
|
|
{
|
|
count=0;
|
|
}
|
|
|
|
void TQCanvasClusterizer::add(int x, int y)
|
|
{
|
|
add(TQRect(x,y,1,1));
|
|
}
|
|
|
|
void TQCanvasClusterizer::add(int x, int y, int w, int h)
|
|
{
|
|
add(TQRect(x,y,w,h));
|
|
}
|
|
|
|
void TQCanvasClusterizer::add(const TQRect& rect)
|
|
{
|
|
TQRect biggerrect(rect.x()-1,rect.y()-1,rect.width()+2,rect.height()+2);
|
|
|
|
//assert(rect.width()>0 && rect.height()>0);
|
|
|
|
int cursor;
|
|
|
|
for (cursor=0; cursor<count; cursor++) {
|
|
if (cluster[cursor].contains(rect)) {
|
|
// Wholly contained already.
|
|
return;
|
|
}
|
|
}
|
|
|
|
int lowestcost=9999999;
|
|
int cheapest=-1;
|
|
cursor = 0;
|
|
while( cursor<count ) {
|
|
if (cluster[cursor].intersects(biggerrect)) {
|
|
TQRect larger=cluster[cursor];
|
|
include(larger,rect);
|
|
int cost = larger.width()*larger.height() -
|
|
cluster[cursor].width()*cluster[cursor].height();
|
|
|
|
if (cost < lowestcost) {
|
|
bool bad=FALSE;
|
|
for (int c=0; c<count && !bad; c++) {
|
|
bad=cluster[c].intersects(larger) && c!=cursor;
|
|
}
|
|
if (!bad) {
|
|
cheapest=cursor;
|
|
lowestcost=cost;
|
|
}
|
|
}
|
|
}
|
|
cursor++;
|
|
}
|
|
|
|
if (cheapest>=0) {
|
|
include(cluster[cheapest],rect);
|
|
return;
|
|
}
|
|
|
|
if (count < maxcl) {
|
|
cluster[count++]=rect;
|
|
return;
|
|
}
|
|
|
|
// Do cheapest of:
|
|
// add to closest cluster
|
|
// do cheapest cluster merge, add to new cluster
|
|
|
|
lowestcost=9999999;
|
|
cheapest=-1;
|
|
cursor=0;
|
|
while( cursor<count ) {
|
|
TQRect larger=cluster[cursor];
|
|
include(larger,rect);
|
|
int cost=larger.width()*larger.height()
|
|
- cluster[cursor].width()*cluster[cursor].height();
|
|
if (cost < lowestcost) {
|
|
bool bad=FALSE;
|
|
for (int c=0; c<count && !bad; c++) {
|
|
bad=cluster[c].intersects(larger) && c!=cursor;
|
|
}
|
|
if (!bad) {
|
|
cheapest=cursor;
|
|
lowestcost=cost;
|
|
}
|
|
}
|
|
cursor++;
|
|
}
|
|
|
|
// ###
|
|
// could make an heuristic guess as to whether we need to bother
|
|
// looking for a cheap merge.
|
|
|
|
int cheapestmerge1 = -1;
|
|
int cheapestmerge2 = -1;
|
|
|
|
int merge1 = 0;
|
|
while( merge1 < count ) {
|
|
int merge2=0;
|
|
while( merge2 < count ) {
|
|
if( merge1!=merge2) {
|
|
TQRect larger=cluster[merge1];
|
|
include(larger,cluster[merge2]);
|
|
int cost=larger.width()*larger.height()
|
|
- cluster[merge1].width()*cluster[merge1].height()
|
|
- cluster[merge2].width()*cluster[merge2].height();
|
|
if (cost < lowestcost) {
|
|
bool bad=FALSE;
|
|
for (int c=0; c<count && !bad; c++) {
|
|
bad=cluster[c].intersects(larger) && c!=cursor;
|
|
}
|
|
if (!bad) {
|
|
cheapestmerge1=merge1;
|
|
cheapestmerge2=merge2;
|
|
lowestcost=cost;
|
|
}
|
|
}
|
|
}
|
|
merge2++;
|
|
}
|
|
merge1++;
|
|
}
|
|
|
|
if (cheapestmerge1>=0) {
|
|
include(cluster[cheapestmerge1],cluster[cheapestmerge2]);
|
|
cluster[cheapestmerge2]=cluster[count--];
|
|
} else {
|
|
// if (!cheapest) debugRectangles(rect);
|
|
include(cluster[cheapest],rect);
|
|
}
|
|
|
|
// NB: clusters do not intersect (or intersection will
|
|
// overwrite). This is a result of the above algorithm,
|
|
// given the assumption that (x,y) are ordered topleft
|
|
// to bottomright.
|
|
|
|
// ###
|
|
//
|
|
// add explicit x/y ordering to that comment, move it to the top
|
|
// and rephrase it as pre-/post-conditions.
|
|
}
|
|
|
|
const TQRect& TQCanvasClusterizer::operator[](int i)
|
|
{
|
|
return cluster[i];
|
|
}
|
|
|
|
// end of clusterizer
|
|
|
|
|
|
|
|
class TQM_EXPORT_CANVAS TQCanvasItemPtr {
|
|
public:
|
|
TQCanvasItemPtr() : ptr(0) { }
|
|
TQCanvasItemPtr( TQCanvasItem* p ) : ptr(p) { }
|
|
|
|
bool operator<=(const TQCanvasItemPtr& that) const
|
|
{
|
|
// Order same-z objects by identity.
|
|
if (that.ptr->z()==ptr->z())
|
|
return that.ptr <= ptr;
|
|
return that.ptr->z() <= ptr->z();
|
|
}
|
|
bool operator<(const TQCanvasItemPtr& that) const
|
|
{
|
|
// Order same-z objects by identity.
|
|
if (that.ptr->z()==ptr->z())
|
|
return that.ptr < ptr;
|
|
return that.ptr->z() < ptr->z();
|
|
}
|
|
bool operator>(const TQCanvasItemPtr& that) const
|
|
{
|
|
// Order same-z objects by identity.
|
|
if (that.ptr->z()==ptr->z())
|
|
return that.ptr > ptr;
|
|
return that.ptr->z() > ptr->z();
|
|
}
|
|
bool operator==(const TQCanvasItemPtr& that) const
|
|
{
|
|
return that.ptr == ptr;
|
|
}
|
|
operator TQCanvasItem*() const { return ptr; }
|
|
|
|
private:
|
|
TQCanvasItem* ptr;
|
|
};
|
|
|
|
|
|
/*!
|
|
\class TQCanvasItemList
|
|
\brief The TQCanvasItemList class is a list of TQCanvasItems.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
TQCanvasItemList is a TQValueList of pointers to \l{TQCanvasItem}s.
|
|
This class is used by some methods in TQCanvas that need to return
|
|
a list of canvas items.
|
|
|
|
The \l TQValueList documentation describes how to use this list.
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
void TQCanvasItemList::sort()
|
|
{
|
|
qHeapSort(*((TQValueList<TQCanvasItemPtr>*)this));
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
void TQCanvasItemList::drawUnique( TQPainter& painter )
|
|
{
|
|
TQCanvasItem* prev=0;
|
|
for (Iterator it=fromLast(); it!=end(); --it) {
|
|
TQCanvasItem *g=*it;
|
|
if (g!=prev) {
|
|
g->draw(painter);
|
|
prev=g;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the concatenation of this list and list \a l.
|
|
*/
|
|
TQCanvasItemList TQCanvasItemList::operator+(const TQCanvasItemList &l) const
|
|
{
|
|
TQCanvasItemList l2(*this);
|
|
for(const_iterator it = l.begin(); it != l.end(); ++it)
|
|
l2.append(*it);
|
|
return l2;
|
|
}
|
|
|
|
class TQCanvasChunk {
|
|
public:
|
|
TQCanvasChunk() : changed(TRUE) { }
|
|
// Other code assumes lists are not deleted. Assignment is also
|
|
// done on ChunkRecs. So don't add that sort of thing here.
|
|
|
|
void sort()
|
|
{
|
|
list.sort();
|
|
}
|
|
|
|
const TQCanvasItemList* listPtr() const
|
|
{
|
|
return &list;
|
|
}
|
|
|
|
void add(TQCanvasItem* item)
|
|
{
|
|
list.prepend(item);
|
|
changed = TRUE;
|
|
}
|
|
|
|
void remove(TQCanvasItem* item)
|
|
{
|
|
list.remove(item);
|
|
changed = TRUE;
|
|
}
|
|
|
|
void change()
|
|
{
|
|
changed = TRUE;
|
|
}
|
|
|
|
bool hasChanged() const
|
|
{
|
|
return changed;
|
|
}
|
|
|
|
bool takeChange()
|
|
{
|
|
bool y = changed;
|
|
changed = FALSE;
|
|
return y;
|
|
}
|
|
|
|
private:
|
|
TQCanvasItemList list;
|
|
bool changed;
|
|
};
|
|
|
|
|
|
static int gcd(int a, int b)
|
|
{
|
|
int r;
|
|
while ( (r = a%b) ) {
|
|
a=b;
|
|
b=r;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
static int scm(int a, int b)
|
|
{
|
|
int g = gcd(a,b);
|
|
return a/g*b;
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
\class TQCanvas ntqcanvas.h
|
|
\brief The TQCanvas class provides a 2D area that can contain TQCanvasItem objects.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\ingroup abstractwidgets
|
|
\ingroup graphics
|
|
\ingroup images
|
|
\mainclass
|
|
\module canvas
|
|
|
|
The TQCanvas class manages its 2D graphic area and all the canvas
|
|
items the area contains. The canvas has no visual appearance of
|
|
its own. Instead, it is displayed on screen using a TQCanvasView.
|
|
Multiple TQCanvasView widgets may be associated with a canvas to
|
|
provide multiple views of the same canvas.
|
|
|
|
The canvas is optimized for large numbers of items, particularly
|
|
where only a small percentage of the items change at any
|
|
one time. If the entire display changes very frequently, you should
|
|
consider using your own custom TQScrollView subclass.
|
|
|
|
TQt provides a rich
|
|
set of canvas item classes, e.g. TQCanvasEllipse, TQCanvasLine,
|
|
TQCanvasPolygon, TQCanvasPolygonalItem, TQCanvasRectangle, TQCanvasSpline,
|
|
TQCanvasSprite and TQCanvasText. You can subclass to create your own
|
|
canvas items; TQCanvasPolygonalItem is the most common base class used
|
|
for this purpose.
|
|
|
|
Items appear on the canvas after their \link TQCanvasItem::show()
|
|
show()\endlink function has been called (or \link
|
|
TQCanvasItem::setVisible() setVisible(TRUE)\endlink), and \e after
|
|
update() has been called. The canvas only shows items that are
|
|
\link TQCanvasItem::setVisible() visible\endlink, and then only if
|
|
\l update() is called. (By default the canvas is white and so are
|
|
canvas items, so if nothing appears try changing colors.)
|
|
|
|
If you created the canvas without passing a width and height to
|
|
the constructor you must also call resize().
|
|
|
|
Although a canvas may appear to be similar to a widget with child
|
|
widgets, there are several notable differences:
|
|
|
|
\list
|
|
\i Canvas items are usually much faster to manipulate and redraw than
|
|
child widgets, with the speed advantage becoming especially great when
|
|
there are \e many canvas items and non-rectangular items. In most
|
|
situations canvas items are also a lot more memory efficient than child
|
|
widgets.
|
|
|
|
\i It's easy to detect overlapping items (collision detection).
|
|
|
|
\i 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 TQCanvas 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 extremes).
|
|
|
|
\i Two or more TQCanvasView objects can view the same canvas.
|
|
|
|
\i An arbitrary transformation matrix can be set on each TQCanvasView
|
|
which makes it easy to zoom, rotate or shear the viewed canvas.
|
|
|
|
\i Widgets provide a lot more functionality, such as input (TQKeyEvent,
|
|
TQMouseEvent etc.) and layout management (TQGridLayout etc.).
|
|
|
|
\endlist
|
|
|
|
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
|
|
can 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 TQCanvas does not inherit from TQWidget, even though it has some
|
|
functions which provide the same functionality as those in TQWidget. One
|
|
of these is setBackgroundPixmap(); some others are resize(), size(),
|
|
width() and height(). \l TQCanvasView 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 TQCanvasItem::setCanvas().
|
|
|
|
Canvas items are movable (and in the case of TQCanvasSprites, animated)
|
|
objects that inherit TQCanvasItem. 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 TQCanvasItem::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 TQCanvasItem::move(). The advance()
|
|
function moves all TQCanvasItem::animated() canvas items and
|
|
setAdvancePeriod() makes TQCanvas move them automatically on a periodic
|
|
basis. In the context of the TQCanvas classes, to `animate' a canvas item
|
|
is to set it in motion, i.e. using TQCanvasItem::setVelocity(). Animation
|
|
of a canvas item itself, i.e. items which change over time, is enabled
|
|
by calling TQCanvasSprite::setFrameAnimation(), or more generally by
|
|
subclassing and reimplementing TQCanvasItem::advance(). To detect collisions
|
|
use one of the TQCanvasItem::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 must 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
|
|
TQCanvasItem::advance() on every item that is \link
|
|
TQCanvasItem::animated() animated\endlink and trigger an update of the
|
|
affected areas afterwards. (A canvas item that is `animated' is simply
|
|
a canvas item that is in motion.)
|
|
|
|
TQCanvas organizes its canvas items into \e 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 TQCanvas'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 TQCanvas constructor tries to pick a 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 the 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 TQPainter 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 TQCanvas's facilities.
|
|
|
|
\sa TQCanvasView TQCanvasItem
|
|
*/
|
|
void TQCanvas::init(int w, int h, int chunksze, int mxclusters)
|
|
{
|
|
d = new TQCanvasData;
|
|
awidth=w;
|
|
aheight=h;
|
|
chunksize=chunksze;
|
|
maxclusters=mxclusters;
|
|
chwidth=(w+chunksize-1)/chunksize;
|
|
chheight=(h+chunksize-1)/chunksize;
|
|
chunks=new TQCanvasChunk[chwidth*chheight];
|
|
update_timer = 0;
|
|
bgcolor = white;
|
|
grid = 0;
|
|
htiles = 0;
|
|
vtiles = 0;
|
|
dblbuf = TRUE;
|
|
debug_redraw_areas = FALSE;
|
|
}
|
|
|
|
/*!
|
|
Create a TQCanvas with no size. \a parent and \a name are passed to
|
|
the TQObject superclass.
|
|
|
|
\warning You \e must call resize() at some time after creation to
|
|
be able to use the canvas.
|
|
*/
|
|
TQCanvas::TQCanvas( TQObject* parent, const char* name )
|
|
: TQObject( parent, name )
|
|
{
|
|
init(0,0);
|
|
}
|
|
|
|
/*!
|
|
Constructs a TQCanvas that is \a w pixels wide and \a h pixels high.
|
|
*/
|
|
TQCanvas::TQCanvas(int w, int h)
|
|
{
|
|
init(w,h);
|
|
}
|
|
|
|
/*!
|
|
Constructs a TQCanvas which will be composed of \a h tiles
|
|
horizontally and \a v tiles vertically. Each tile will be an image
|
|
\a tilewidth by \a tileheight pixels taken from pixmap \a p.
|
|
|
|
The pixmap \a 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.
|
|
|
|
\table
|
|
\row \i 0 \i 1 \i 2 \i 3
|
|
\row \i 4 \i 5 \i 6 \i 7
|
|
\endtable
|
|
|
|
The TQCanvas 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 often as necessary
|
|
to cover the area. If it is smaller, tiles to the right and bottom
|
|
will not be visible.
|
|
|
|
\sa setTiles()
|
|
*/
|
|
TQCanvas::TQCanvas( TQPixmap p,
|
|
int h, int v, int tilewidth, int tileheight )
|
|
{
|
|
init(h*tilewidth, v*tileheight, scm(tilewidth,tileheight) );
|
|
setTiles( p, h, v, tilewidth, tileheight );
|
|
}
|
|
|
|
void qt_unview(TQCanvas* c)
|
|
{
|
|
for (TQCanvasView* view=c->d->viewList.first(); view != 0; view=c->d->viewList.next()) {
|
|
view->viewing = 0;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Destroys the canvas and all the canvas's canvas items.
|
|
*/
|
|
TQCanvas::~TQCanvas()
|
|
{
|
|
qt_unview(this);
|
|
TQCanvasItemList all = allItems();
|
|
for (TQCanvasItemList::Iterator it=all.begin(); it!=all.end(); ++it)
|
|
delete *it;
|
|
delete [] chunks;
|
|
delete [] grid;
|
|
delete d;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Returns the chunk at a chunk position \a i, \a j.
|
|
*/
|
|
TQCanvasChunk& TQCanvas::chunk(int i, int j) const
|
|
{
|
|
return chunks[i+chwidth*j];
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Returns the chunk at a pixel position \a x, \a y.
|
|
*/
|
|
TQCanvasChunk& TQCanvas::chunkContaining(int x, int y) const
|
|
{
|
|
return chunk(x/chunksize,y/chunksize);
|
|
}
|
|
|
|
/*!
|
|
Returns a list of all the items in the canvas.
|
|
*/
|
|
TQCanvasItemList TQCanvas::allItems()
|
|
{
|
|
TQCanvasItemList list;
|
|
for (TQPtrDictIterator<void> it=d->itemDict; it.currentKey(); ++it) {
|
|
list.prepend((TQCanvasItem*)it.currentKey());
|
|
}
|
|
return list;
|
|
}
|
|
|
|
|
|
/*!
|
|
Changes the size of the canvas to have a width of \a w and a
|
|
height of \a h. This is a slow operation.
|
|
*/
|
|
void TQCanvas::resize(int w, int h)
|
|
{
|
|
if (awidth==w && aheight==h)
|
|
return;
|
|
|
|
TQCanvasItem* item;
|
|
TQPtrList<TQCanvasItem> hidden;
|
|
for (TQPtrDictIterator<void> it=d->itemDict; it.currentKey(); ++it) {
|
|
if (((TQCanvasItem*)it.currentKey())->isVisible()) {
|
|
((TQCanvasItem*)it.currentKey())->hide();
|
|
hidden.append(((TQCanvasItem*)it.currentKey()));
|
|
}
|
|
}
|
|
|
|
int nchwidth=(w+chunksize-1)/chunksize;
|
|
int nchheight=(h+chunksize-1)/chunksize;
|
|
|
|
TQCanvasChunk* newchunks = new TQCanvasChunk[nchwidth*nchheight];
|
|
|
|
// Commit the new values.
|
|
//
|
|
awidth=w;
|
|
aheight=h;
|
|
chwidth=nchwidth;
|
|
chheight=nchheight;
|
|
delete [] chunks;
|
|
chunks=newchunks;
|
|
|
|
for (item=hidden.first(); item != 0; item=hidden.next()) {
|
|
item->show();
|
|
}
|
|
|
|
setAllChanged();
|
|
|
|
emit resized();
|
|
}
|
|
|
|
/*!
|
|
\fn void TQCanvas::resized()
|
|
|
|
This signal is emitted whenever the canvas is resized. Each
|
|
TQCanvasView connects to this signal to keep the scrollview's size
|
|
correct.
|
|
*/
|
|
|
|
/*!
|
|
Change the efficiency tuning parameters to \a mxclusters clusters,
|
|
each of size \a chunksze. This is a slow operation if there are
|
|
many objects on the canvas.
|
|
|
|
The canvas is divided into chunks which are rectangular areas \a
|
|
chunksze wide by \a 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 using 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 \a 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 TQCanvas::retune(int chunksze, int mxclusters)
|
|
{
|
|
maxclusters=mxclusters;
|
|
|
|
if ( chunksize!=chunksze ) {
|
|
TQPtrList<TQCanvasItem> hidden;
|
|
for (TQPtrDictIterator<void> it=d->itemDict; it.currentKey(); ++it) {
|
|
if (((TQCanvasItem*)it.currentKey())->isVisible()) {
|
|
((TQCanvasItem*)it.currentKey())->hide();
|
|
hidden.append(((TQCanvasItem*)it.currentKey()));
|
|
}
|
|
}
|
|
|
|
chunksize=chunksze;
|
|
|
|
int nchwidth=(awidth+chunksize-1)/chunksize;
|
|
int nchheight=(aheight+chunksize-1)/chunksize;
|
|
|
|
TQCanvasChunk* newchunks = new TQCanvasChunk[nchwidth*nchheight];
|
|
|
|
// Commit the new values.
|
|
//
|
|
chwidth=nchwidth;
|
|
chheight=nchheight;
|
|
delete [] chunks;
|
|
chunks=newchunks;
|
|
|
|
for (TQCanvasItem* item=hidden.first(); item != 0; item=hidden.next()) {
|
|
item->show();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn int TQCanvas::width() const
|
|
|
|
Returns the width of the canvas, in pixels.
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::height() const
|
|
|
|
Returns the height of the canvas, in pixels.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQSize TQCanvas::size() const
|
|
|
|
Returns the size of the canvas, in pixels.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQRect TQCanvas::rect() const
|
|
|
|
Returns a rectangle the size of the canvas.
|
|
*/
|
|
|
|
|
|
/*!
|
|
\fn bool TQCanvas::onCanvas( int x, int y ) const
|
|
|
|
Returns TRUE if the pixel position (\a x, \a y) is on the canvas;
|
|
otherwise returns FALSE.
|
|
|
|
\sa validChunk()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvas::onCanvas( const TQPoint& p ) const
|
|
\overload
|
|
|
|
Returns TRUE if the pixel position \a p is on the canvas;
|
|
otherwise returns FALSE.
|
|
|
|
\sa validChunk()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvas::validChunk( int x, int y ) const
|
|
|
|
Returns TRUE if the chunk position (\a x, \a y) is on the canvas;
|
|
otherwise returns FALSE.
|
|
|
|
\sa onCanvas()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvas::validChunk( const TQPoint& p ) const
|
|
\overload
|
|
|
|
Returns TRUE if the chunk position \a p is on the canvas; otherwise
|
|
returns FALSE.
|
|
|
|
\sa onCanvas()
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::chunkSize() const
|
|
|
|
Returns the chunk size of the canvas.
|
|
|
|
\sa retune()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvas::sameChunk(int x1, int y1, int x2, int y2) const
|
|
\internal
|
|
Tells if the points ( \a x1, \a y1 ) and ( \a x2, \a y2 ) are within the same chunk.
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
This method adds an the item \a item to the list of TQCanvasItem objects
|
|
in the TQCanvas. The TQCanvasItem class calls this.
|
|
*/
|
|
void TQCanvas::addItem(TQCanvasItem* item)
|
|
{
|
|
d->itemDict.insert((void*)item,(void*)1);
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method adds the item \a item to the list of TQCanvasItem objects
|
|
to be moved. The TQCanvasItem class calls this.
|
|
*/
|
|
void TQCanvas::addAnimation(TQCanvasItem* item)
|
|
{
|
|
d->animDict.insert((void*)item,(void*)1);
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method adds the item \a item to the list of TQCanvasItem objects
|
|
which are no longer to be moved. The TQCanvasItem class calls this.
|
|
*/
|
|
void TQCanvas::removeAnimation(TQCanvasItem* item)
|
|
{
|
|
d->animDict.remove((void*)item);
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method removes the item \a item from the list of TQCanvasItem objects
|
|
in this TQCanvas. The TQCanvasItem class calls this.
|
|
*/
|
|
void TQCanvas::removeItem(TQCanvasItem* item)
|
|
{
|
|
d->itemDict.remove((void*)item);
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method adds the view \a view to the list of TQCanvasView objects
|
|
viewing this TQCanvas. The TQCanvasView class calls this.
|
|
*/
|
|
void TQCanvas::addView(TQCanvasView* view)
|
|
{
|
|
d->viewList.append(view);
|
|
if ( htiles>1 || vtiles>1 || pm.isNull() )
|
|
view->viewport()->setBackgroundColor(backgroundColor());
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method removes the view \a view from the list of TQCanvasView objects
|
|
viewing this TQCanvas. The TQCanvasView class calls this.
|
|
*/
|
|
void TQCanvas::removeView(TQCanvasView* view)
|
|
{
|
|
d->viewList.removeRef(view);
|
|
}
|
|
|
|
/*!
|
|
Sets the canvas to call advance() every \a ms milliseconds. Any
|
|
previous setting by setAdvancePeriod() or setUpdatePeriod() is
|
|
overridden.
|
|
|
|
If \a ms is less than 0 advancing will be stopped.
|
|
*/
|
|
void TQCanvas::setAdvancePeriod(int ms)
|
|
{
|
|
if ( ms<0 ) {
|
|
if ( update_timer )
|
|
update_timer->stop();
|
|
} else {
|
|
if ( update_timer )
|
|
delete update_timer;
|
|
update_timer = new TQTimer(this);
|
|
connect(update_timer,SIGNAL(timeout()),this,SLOT(advance()));
|
|
update_timer->start(ms);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Sets the canvas to call update() every \a ms milliseconds. Any
|
|
previous setting by setAdvancePeriod() or setUpdatePeriod() is
|
|
overridden.
|
|
|
|
If \a ms is less than 0 automatic updating will be stopped.
|
|
*/
|
|
void TQCanvas::setUpdatePeriod(int ms)
|
|
{
|
|
if ( ms<0 ) {
|
|
if ( update_timer )
|
|
update_timer->stop();
|
|
} else {
|
|
if ( update_timer )
|
|
delete update_timer;
|
|
update_timer = new TQTimer(this);
|
|
connect(update_timer,SIGNAL(timeout()),this,SLOT(update()));
|
|
update_timer->start(ms);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Moves all TQCanvasItem::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
|
|
TQCanvasItem::advance() function of each TQCanvasItem::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 TQCanvasItem subclasses supplied with TQt do anything
|
|
interesting in phase 0.
|
|
|
|
The canvas can be configured to call this function periodically
|
|
with setAdvancePeriod().
|
|
|
|
\sa update()
|
|
*/
|
|
void TQCanvas::advance()
|
|
{
|
|
TQPtrDictIterator<void> it=d->animDict;
|
|
while ( it.current() ) {
|
|
TQCanvasItem* i = (TQCanvasItem*)(void*)it.currentKey();
|
|
++it;
|
|
if ( i )
|
|
i->advance(0);
|
|
}
|
|
// we expect the dict contains the exact same items as in the
|
|
// first pass.
|
|
it.toFirst();
|
|
while ( it.current() ) {
|
|
TQCanvasItem* i = (TQCanvasItem*)(void*)it.currentKey();
|
|
++it;
|
|
if ( i )
|
|
i->advance(1);
|
|
}
|
|
update();
|
|
}
|
|
|
|
// Don't call this unless you know what you're doing.
|
|
// p is in the content's co-ordinate example.
|
|
/*!
|
|
\internal
|
|
*/
|
|
void TQCanvas::drawViewArea( TQCanvasView* view, TQPainter* p, const TQRect& vr, bool dbuf )
|
|
{
|
|
TQPoint tl = view->contentsToViewport(TQPoint(0,0));
|
|
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
TQWMatrix wm = view->worldMatrix();
|
|
TQWMatrix iwm = wm.invert();
|
|
// ivr = covers all chunks in vr
|
|
TQRect ivr = iwm.map(vr);
|
|
ivr.addCoords(-1, -1, 1, 1);
|
|
TQWMatrix twm;
|
|
twm.translate(tl.x(),tl.y());
|
|
#else
|
|
TQRect ivr = vr;
|
|
#endif
|
|
|
|
TQRect all(0,0,width(),height());
|
|
|
|
if ( !all.contains(ivr) ) {
|
|
// Need to clip with edge of canvas.
|
|
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
// For translation-only transformation, it is safe to include the right
|
|
// and bottom edges, but otherwise, these must be excluded since they
|
|
// are not precisely defined (different bresenham paths).
|
|
TQPointArray a;
|
|
if ( wm.m12()==0.0 && wm.m21()==0.0 && wm.m11() == 1.0 && wm.m22() == 1.0 )
|
|
a = TQPointArray( TQRect(all.x(),all.y(),all.width()+1,all.height()+1) );
|
|
else
|
|
a = TQPointArray( all );
|
|
|
|
a = (wm*twm).map(a);
|
|
#else
|
|
TQPointArray a( TQRect(all.x(),all.y(),all.width()+1,all.height()+1) );
|
|
#endif
|
|
if ( view->viewport()->backgroundMode() == NoBackground ) {
|
|
TQRect cvr = vr; cvr.moveBy(tl.x(),tl.y());
|
|
p->setClipRegion(TQRegion(cvr)-TQRegion(a));
|
|
p->fillRect(vr,view->viewport()->palette()
|
|
.brush(TQPalette::Active,TQColorGroup::Background));
|
|
}
|
|
p->setClipRegion(a);
|
|
}
|
|
|
|
if ( dbuf ) {
|
|
offscr = TQPixmap(vr.size().expandedTo(TQSize(1, 1)));
|
|
#ifdef Q_WS_X11
|
|
offscr.x11SetScreen(p->device()->x11Screen());
|
|
#endif
|
|
TQPainter dbp(&offscr);
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
twm.translate(-vr.x(),-vr.y());
|
|
twm.translate(-tl.x(),-tl.y());
|
|
dbp.setWorldMatrix( wm*twm, TRUE );
|
|
#else
|
|
dbp.translate(-vr.x()-tl.x(),-vr.y()-tl.y());
|
|
#endif
|
|
dbp.setClipRect(0,0,vr.width(), vr.height());
|
|
drawCanvasArea(ivr,&dbp,FALSE);
|
|
dbp.end();
|
|
p->drawPixmap(vr.x(), vr.y(), offscr, 0, 0, vr.width(), vr.height());
|
|
} else {
|
|
TQRect r = vr; r.moveBy(tl.x(),tl.y()); // move to untransformed co-ords
|
|
if ( !all.contains(ivr) ) {
|
|
TQRegion inside = p->clipRegion() & r;
|
|
//TQRegion outside = p->clipRegion() - r;
|
|
//p->setClipRegion(outside);
|
|
//p->fillRect(outside.boundingRect(),red);
|
|
p->setClipRegion(inside);
|
|
} else {
|
|
p->setClipRect(r);
|
|
}
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
p->setWorldMatrix( wm*twm );
|
|
#else
|
|
#endif
|
|
p->setBrushOrigin(tl.x(), tl.y());
|
|
drawCanvasArea(ivr,p,FALSE);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Repaints changed areas in all views of the canvas.
|
|
|
|
\sa advance()
|
|
*/
|
|
void TQCanvas::update()
|
|
{
|
|
TQCanvasClusterizer clusterizer(d->viewList.count());
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
TQPtrList<TQRect> doneareas;
|
|
doneareas.setAutoDelete(TRUE);
|
|
#endif
|
|
|
|
TQPtrListIterator<TQCanvasView> it(d->viewList);
|
|
TQCanvasView* view;
|
|
while( (view=it.current()) != 0 ) {
|
|
++it;
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
TQWMatrix wm = view->worldMatrix();
|
|
#endif
|
|
TQRect area(view->contentsX(),view->contentsY(),
|
|
view->visibleWidth(),view->visibleHeight());
|
|
if (area.width()>0 && area.height()>0) {
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
if ( !wm.isIdentity() ) {
|
|
// r = Visible area of the canvas where there are changes
|
|
TQRect r = changeBounds(view->inverseWorldMatrix().map(area));
|
|
if ( !r.isEmpty() ) {
|
|
TQPainter p(view->viewport());
|
|
// Translate to the coordinate system of drawViewArea().
|
|
TQPoint tl = view->contentsToViewport(TQPoint(0,0));
|
|
p.translate(tl.x(),tl.y());
|
|
drawViewArea( view, &p, wm.map(r), dblbuf );
|
|
doneareas.append(new TQRect(r));
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
clusterizer.add(area);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i=0; i<clusterizer.clusters(); i++)
|
|
drawChanges(clusterizer[i]);
|
|
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
for ( TQRect* r=doneareas.first(); r != 0; r=doneareas.next() )
|
|
setUnchanged(*r);
|
|
#endif
|
|
}
|
|
|
|
|
|
// ### warwick - setAllChanged() is not a set function. please rename
|
|
// it. ditto setChanged(). markChanged(), perhaps?
|
|
// ### unfortunately this function is virtual, which makes renaming more difficult. Lars
|
|
|
|
/*!
|
|
Marks the whole canvas as changed.
|
|
All views of the canvas will be entirely redrawn when
|
|
update() is called next.
|
|
*/
|
|
void TQCanvas::setAllChanged()
|
|
{
|
|
setChanged(TQRect(0,0,width(),height()));
|
|
}
|
|
|
|
/*!
|
|
Marks \a area as changed. This \a area will be redrawn in all
|
|
views that are showing it when update() is called next.
|
|
*/
|
|
void TQCanvas::setChanged(const TQRect& area)
|
|
{
|
|
TQRect thearea = area.intersect(TQRect(0,0,width(),height()));
|
|
|
|
int mx = (thearea.x()+thearea.width()+chunksize)/chunksize;
|
|
int my = (thearea.y()+thearea.height()+chunksize)/chunksize;
|
|
if (mx>chwidth)
|
|
mx=chwidth;
|
|
if (my>chheight)
|
|
my=chheight;
|
|
|
|
int x=thearea.x()/chunksize;
|
|
while( x<mx) {
|
|
int y = thearea.y()/chunksize;
|
|
while( y<my ) {
|
|
chunk(x,y).change();
|
|
y++;
|
|
}
|
|
x++;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Marks \a area as \e unchanged. The area will \e not be redrawn in
|
|
the views for the next update(), unless it is marked or changed
|
|
again before the next call to update().
|
|
*/
|
|
void TQCanvas::setUnchanged(const TQRect& area)
|
|
{
|
|
TQRect thearea = area.intersect(TQRect(0,0,width(),height()));
|
|
|
|
int mx = (thearea.x()+thearea.width()+chunksize)/chunksize;
|
|
int my = (thearea.y()+thearea.height()+chunksize)/chunksize;
|
|
if (mx>chwidth)
|
|
mx=chwidth;
|
|
if (my>chheight)
|
|
my=chheight;
|
|
|
|
int x=thearea.x()/chunksize;
|
|
while( x<mx) {
|
|
int y = thearea.y()/chunksize;
|
|
while( y<my ) {
|
|
chunk(x,y).takeChange();
|
|
y++;
|
|
}
|
|
x++;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
TQRect TQCanvas::changeBounds(const TQRect& inarea)
|
|
{
|
|
TQRect area=inarea.intersect(TQRect(0,0,width(),height()));
|
|
|
|
int mx = (area.x()+area.width()+chunksize)/chunksize;
|
|
int my = (area.y()+area.height()+chunksize)/chunksize;
|
|
if (mx > chwidth)
|
|
mx=chwidth;
|
|
if (my > chheight)
|
|
my=chheight;
|
|
|
|
TQRect result;
|
|
|
|
int x=area.x()/chunksize;
|
|
while( x<mx ) {
|
|
int y=area.y()/chunksize;
|
|
while( y<my ) {
|
|
TQCanvasChunk& ch=chunk(x,y);
|
|
if ( ch.hasChanged() )
|
|
result |= TQRect(x,y,1,1);
|
|
y++;
|
|
}
|
|
x++;
|
|
}
|
|
|
|
if ( !result.isEmpty() ) {
|
|
result.rLeft() *= chunksize;
|
|
result.rTop() *= chunksize;
|
|
result.rRight() *= chunksize;
|
|
result.rBottom() *= chunksize;
|
|
result.rRight() += chunksize;
|
|
result.rBottom() += chunksize;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Redraws the area \a inarea of the TQCanvas.
|
|
*/
|
|
void TQCanvas::drawChanges(const TQRect& inarea)
|
|
{
|
|
TQRect area=inarea.intersect(TQRect(0,0,width(),height()));
|
|
|
|
TQCanvasClusterizer clusters(maxclusters);
|
|
|
|
int mx = (area.x()+area.width()+chunksize)/chunksize;
|
|
int my = (area.y()+area.height()+chunksize)/chunksize;
|
|
if (mx > chwidth)
|
|
mx=chwidth;
|
|
if (my > chheight)
|
|
my=chheight;
|
|
|
|
int x=area.x()/chunksize;
|
|
while( x<mx ) {
|
|
int y=area.y()/chunksize;
|
|
while( y<my ) {
|
|
TQCanvasChunk& ch=chunk(x,y);
|
|
if ( ch.hasChanged() )
|
|
clusters.add(x,y);
|
|
y++;
|
|
}
|
|
x++;
|
|
}
|
|
|
|
for (int i=0; i<clusters.clusters(); i++) {
|
|
TQRect elarea=clusters[i];
|
|
elarea.setRect(
|
|
elarea.left()*chunksize,
|
|
elarea.top()*chunksize,
|
|
elarea.width()*chunksize,
|
|
elarea.height()*chunksize
|
|
);
|
|
drawCanvasArea(elarea);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Paints all canvas items that are in the area \a clip to \a
|
|
painter, using double-buffering if \a dbuf is TRUE.
|
|
|
|
e.g. to print the canvas to a printer:
|
|
\code
|
|
TQPrinter pr;
|
|
if ( pr.setup() ) {
|
|
TQPainter p(&pr);
|
|
canvas.drawArea( canvas.rect(), &p );
|
|
}
|
|
\endcode
|
|
*/
|
|
void TQCanvas::drawArea(const TQRect& clip, TQPainter* painter, bool dbuf)
|
|
{
|
|
if ( painter )
|
|
drawCanvasArea( clip, painter, dbuf );
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
void TQCanvas::drawCanvasArea(const TQRect& inarea, TQPainter* p, bool double_buffer)
|
|
{
|
|
TQRect area=inarea.intersect(TQRect(0,0,width(),height()));
|
|
|
|
if ( !dblbuf )
|
|
double_buffer = FALSE;
|
|
|
|
if (!d->viewList.first() && !p) return; // Nothing to do.
|
|
|
|
int lx=area.x()/chunksize;
|
|
int ly=area.y()/chunksize;
|
|
int mx=area.right()/chunksize;
|
|
int my=area.bottom()/chunksize;
|
|
if (mx>=chwidth)
|
|
mx=chwidth-1;
|
|
if (my>=chheight)
|
|
my=chheight-1;
|
|
|
|
TQCanvasItemList allvisible;
|
|
|
|
// Stores the region within area that need to be drawn. It is relative
|
|
// to area.topLeft() (so as to keep within bounds of 16-bit XRegions)
|
|
TQRegion rgn;
|
|
|
|
for (int x=lx; x<=mx; x++) {
|
|
for (int y=ly; y<=my; y++) {
|
|
// Only reset change if all views updating, and
|
|
// wholy within area. (conservative: ignore entire boundary)
|
|
//
|
|
// Disable this to help debugging.
|
|
//
|
|
if (!p) {
|
|
if ( chunk(x,y).takeChange() ) {
|
|
// ### should at least make bands
|
|
rgn |= TQRegion(x*chunksize-area.x(),y*chunksize-area.y(),
|
|
chunksize,chunksize);
|
|
allvisible += *chunk(x,y).listPtr();
|
|
}
|
|
} else {
|
|
allvisible += *chunk(x,y).listPtr();
|
|
}
|
|
}
|
|
}
|
|
allvisible.sort();
|
|
|
|
if ( double_buffer ) {
|
|
offscr = TQPixmap(area.size().expandedTo(TQSize(1, 1)));
|
|
#ifdef Q_WS_X11
|
|
if (p)
|
|
offscr.x11SetScreen(p->device()->x11Screen());
|
|
#endif
|
|
}
|
|
|
|
if ( double_buffer && !offscr.isNull() ) {
|
|
TQPainter painter;
|
|
painter.begin(&offscr);
|
|
painter.translate(-area.x(),-area.y());
|
|
painter.setBrushOrigin(-area.x(),-area.y());
|
|
if ( p ) {
|
|
painter.setClipRect(TQRect(0,0,area.width(),area.height()));
|
|
} else {
|
|
painter.setClipRegion(rgn);
|
|
}
|
|
drawBackground(painter,area);
|
|
allvisible.drawUnique(painter);
|
|
drawForeground(painter,area);
|
|
painter.end();
|
|
if ( p ) {
|
|
p->drawPixmap( area.x(), area.y(), offscr,
|
|
0, 0, area.width(), area.height() );
|
|
return;
|
|
}
|
|
} else if ( p ) {
|
|
drawBackground(*p,area);
|
|
allvisible.drawUnique(*p);
|
|
drawForeground(*p,area);
|
|
return;
|
|
}
|
|
|
|
TQPoint trtr; // keeps track of total translation of rgn
|
|
|
|
trtr -= area.topLeft();
|
|
|
|
for (TQCanvasView* view=d->viewList.first(); view; view=d->viewList.next()) {
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
if ( !view->worldMatrix().isIdentity() )
|
|
continue; // Cannot paint those here (see callers).
|
|
#endif
|
|
TQPainter painter(view->viewport());
|
|
TQPoint tr = view->contentsToViewport(area.topLeft());
|
|
TQPoint nrtr = view->contentsToViewport(TQPoint(0,0)); // new translation
|
|
TQPoint rtr = nrtr - trtr; // extra translation of rgn
|
|
trtr += rtr; // add to total
|
|
if (double_buffer) {
|
|
rgn.translate(rtr.x(),rtr.y());
|
|
painter.setClipRegion(rgn);
|
|
painter.drawPixmap(tr,offscr, TQRect(TQPoint(0,0),area.size()));
|
|
} else {
|
|
painter.translate(nrtr.x(),nrtr.y());
|
|
rgn.translate(rtr.x(),rtr.y());
|
|
painter.setClipRegion(rgn);
|
|
drawBackground(painter,area);
|
|
allvisible.drawUnique(painter);
|
|
drawForeground(painter,area);
|
|
painter.translate(-nrtr.x(),-nrtr.y());
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method to informs the TQCanvas that a given chunk is
|
|
`dirty' and needs to be redrawn in the next Update.
|
|
|
|
(\a x,\a y) is a chunk location.
|
|
|
|
The sprite classes call this. Any new derived class of TQCanvasItem
|
|
must do so too. SetChangedChunkContaining can be used instead.
|
|
*/
|
|
void TQCanvas::setChangedChunk(int x, int y)
|
|
{
|
|
if (validChunk(x,y)) {
|
|
TQCanvasChunk& ch=chunk(x,y);
|
|
ch.change();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method to informs the TQCanvas that the chunk containing a given
|
|
pixel is `dirty' and needs to be redrawn in the next Update.
|
|
|
|
(\a x,\a y) is a pixel location.
|
|
|
|
The item classes call this. Any new derived class of TQCanvasItem must
|
|
do so too. SetChangedChunk can be used instead.
|
|
*/
|
|
void TQCanvas::setChangedChunkContaining(int x, int y)
|
|
{
|
|
if (x>=0 && x<width() && y>=0 && y<height()) {
|
|
TQCanvasChunk& chunk=chunkContaining(x,y);
|
|
chunk.change();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method adds the TQCanvasItem \a g to the list of those which need to be
|
|
drawn if the given chunk at location ( \a x, \a y ) is redrawn. Like
|
|
SetChangedChunk and SetChangedChunkContaining, this method marks the
|
|
chunk as `dirty'.
|
|
*/
|
|
void TQCanvas::addItemToChunk(TQCanvasItem* g, int x, int y)
|
|
{
|
|
if (validChunk(x,y)) {
|
|
chunk(x,y).add(g);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method removes the TQCanvasItem \a g from the list of those which need to
|
|
be drawn if the given chunk at location ( \a x, \a y ) is redrawn. Like
|
|
SetChangedChunk and SetChangedChunkContaining, this method marks the chunk
|
|
as `dirty'.
|
|
*/
|
|
void TQCanvas::removeItemFromChunk(TQCanvasItem* g, int x, int y)
|
|
{
|
|
if (validChunk(x,y)) {
|
|
chunk(x,y).remove(g);
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
This method adds the TQCanvasItem \a g to the list of those which need to be
|
|
drawn if the chunk containing the given pixel ( \a x, \a y ) is redrawn. Like
|
|
SetChangedChunk and SetChangedChunkContaining, this method marks the
|
|
chunk as `dirty'.
|
|
*/
|
|
void TQCanvas::addItemToChunkContaining(TQCanvasItem* g, int x, int y)
|
|
{
|
|
if (x>=0 && x<width() && y>=0 && y<height()) {
|
|
chunkContaining(x,y).add(g);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
This method removes the TQCanvasItem \a g from the list of those which need to
|
|
be drawn if the chunk containing the given pixel ( \a x, \a y ) is redrawn.
|
|
Like SetChangedChunk and SetChangedChunkContaining, this method
|
|
marks the chunk as `dirty'.
|
|
*/
|
|
void TQCanvas::removeItemFromChunkContaining(TQCanvasItem* g, int x, int y)
|
|
{
|
|
if (x>=0 && x<width() && y>=0 && y<height()) {
|
|
chunkContaining(x,y).remove(g);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the color set by setBackgroundColor(). By default, this is
|
|
white.
|
|
|
|
This function is not a reimplementation of
|
|
TQWidget::backgroundColor() (TQCanvas is not a subclass of TQWidget),
|
|
but all TQCanvasViews that are viewing the canvas will set their
|
|
backgrounds to this color.
|
|
|
|
\sa setBackgroundColor(), backgroundPixmap()
|
|
*/
|
|
TQColor TQCanvas::backgroundColor() const
|
|
{
|
|
return bgcolor;
|
|
}
|
|
|
|
/*!
|
|
Sets the solid background to be the color \a c.
|
|
|
|
\sa backgroundColor(), setBackgroundPixmap(), setTiles()
|
|
*/
|
|
void TQCanvas::setBackgroundColor( const TQColor& c )
|
|
{
|
|
if ( bgcolor != c ) {
|
|
bgcolor = c;
|
|
TQCanvasView* view=d->viewList.first();
|
|
while ( view != 0 ) {
|
|
/* XXX this doesn't look right. Shouldn't this
|
|
be more like setBackgroundPixmap? : Ian */
|
|
view->viewport()->setEraseColor( bgcolor );
|
|
view=d->viewList.next();
|
|
}
|
|
setAllChanged();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the pixmap set by setBackgroundPixmap(). By default,
|
|
this is a null pixmap.
|
|
|
|
\sa setBackgroundPixmap(), backgroundColor()
|
|
*/
|
|
TQPixmap TQCanvas::backgroundPixmap() const
|
|
{
|
|
return pm;
|
|
}
|
|
|
|
/*!
|
|
Sets the solid background to be the pixmap \a p repeated as
|
|
necessary to cover the entire canvas.
|
|
|
|
\sa backgroundPixmap(), setBackgroundColor(), setTiles()
|
|
*/
|
|
void TQCanvas::setBackgroundPixmap( const TQPixmap& p )
|
|
{
|
|
setTiles(p, 1, 1, p.width(), p.height());
|
|
TQCanvasView* view = d->viewList.first();
|
|
while ( view != 0 ) {
|
|
view->updateContents();
|
|
view = d->viewList.next();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
This virtual function is called for all updates of the canvas. It
|
|
renders any background graphics using the painter \a painter, in
|
|
the area \a 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 TQRect&) for the result to be visible when
|
|
update() is next called.
|
|
|
|
\sa setBackgroundColor(), setBackgroundPixmap(), setTiles()
|
|
*/
|
|
void TQCanvas::drawBackground(TQPainter& painter, const TQRect& clip)
|
|
{
|
|
if ( pm.isNull() ) {
|
|
painter.fillRect(clip,bgcolor);
|
|
} else if ( !grid ) {
|
|
for (int x=clip.x()/pm.width();
|
|
x<(clip.x()+clip.width()+pm.width()-1)/pm.width(); x++)
|
|
{
|
|
for (int y=clip.y()/pm.height();
|
|
y<(clip.y()+clip.height()+pm.height()-1)/pm.height(); y++)
|
|
{
|
|
painter.drawPixmap(x*pm.width(), y*pm.height(),pm);
|
|
}
|
|
}
|
|
} else {
|
|
const int x1 = clip.left()/tilew;
|
|
int x2 = clip.right()/tilew;
|
|
const int y1 = clip.top()/tileh;
|
|
int y2 = clip.bottom()/tileh;
|
|
|
|
const int roww = pm.width()/tilew;
|
|
|
|
for (int j=y1; j<=y2; j++) {
|
|
int jj = j%tilesVertically();
|
|
for (int i=x1; i<=x2; i++) {
|
|
int t = tile(i%tilesHorizontally(), jj);
|
|
int tx = t % roww;
|
|
int ty = t / roww;
|
|
painter.drawPixmap( i*tilew, j*tileh, pm,
|
|
tx*tilew, ty*tileh, tilew, tileh );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
This virtual function is called for all updates of the canvas. It
|
|
renders any foreground graphics using the painter \a painter, in
|
|
the area \a clip.
|
|
|
|
If the graphics for an area change, you must explicitly call
|
|
setChanged(const TQRect&) for the result to be visible when
|
|
update() is next called.
|
|
|
|
The default is to draw nothing.
|
|
*/
|
|
void TQCanvas::drawForeground(TQPainter& painter, const TQRect& clip)
|
|
{
|
|
if ( debug_redraw_areas ) {
|
|
painter.setPen(red);
|
|
painter.setBrush(NoBrush);
|
|
painter.drawRect(clip);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
If \a 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
|
|
little and also gives a (usually small) performance improvement.
|
|
*/
|
|
void TQCanvas::setDoubleBuffering(bool y)
|
|
{
|
|
dblbuf = y;
|
|
}
|
|
|
|
|
|
/*!
|
|
Sets the TQCanvas to be composed of \a h tiles horizontally and \a
|
|
v tiles vertically. Each tile will be an image \a tilewidth by \a
|
|
tileheight pixels from pixmap \a p.
|
|
|
|
The pixmap \a 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.
|
|
|
|
\table
|
|
\row \i 0 \i 1 \i 2 \i 3
|
|
\row \i 4 \i 5 \i 6 \i 7
|
|
\endtable
|
|
|
|
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 \a p must be a multiple of \a tilewidth
|
|
and \a tileheight. If they are not the function will do nothing.
|
|
|
|
If you want to unset any tiling set, then just pass in a null
|
|
pixmap and 0 for \a h, \a v, \a tilewidth, and
|
|
\a tileheight.
|
|
*/
|
|
void TQCanvas::setTiles( TQPixmap p,
|
|
int h, int v, int tilewidth, int tileheight )
|
|
{
|
|
if ( !p.isNull() && (!tilewidth || !tileheight ||
|
|
p.width() % tilewidth != 0 || p.height() % tileheight != 0 ) )
|
|
return;
|
|
|
|
htiles = h;
|
|
vtiles = v;
|
|
delete[] grid;
|
|
pm = p;
|
|
if ( h && v && !p.isNull() ) {
|
|
grid = new ushort[h*v];
|
|
memset( grid, 0, h*v*sizeof(ushort) );
|
|
tilew = tilewidth;
|
|
tileh = tileheight;
|
|
} else {
|
|
grid = 0;
|
|
}
|
|
if ( h + v > 10 ) {
|
|
int s = scm(tilewidth,tileheight);
|
|
retune( s < 128 ? s : TQMAX(tilewidth,tileheight) );
|
|
}
|
|
setAllChanged();
|
|
}
|
|
|
|
/*!
|
|
\fn int TQCanvas::tile( int x, int y ) const
|
|
|
|
Returns the tile at position (\a x, \a y). Initially, all tiles
|
|
are 0.
|
|
|
|
The parameters must be within range, i.e.
|
|
0 \< \a x \< tilesHorizontally() and
|
|
0 \< \a y \< tilesVertically().
|
|
|
|
\sa setTile()
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::tilesHorizontally() const
|
|
|
|
Returns the number of tiles horizontally.
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::tilesVertically() const
|
|
|
|
Returns the number of tiles vertically.
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::tileWidth() const
|
|
|
|
Returns the width of each tile.
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvas::tileHeight() const
|
|
|
|
Returns the height of each tile.
|
|
*/
|
|
|
|
|
|
/*!
|
|
Sets the tile at (\a x, \a y) to use tile number \a 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.
|
|
|
|
\table
|
|
\row \i 0 \i 1 \i 2 \i 3
|
|
\row \i 4 \i 5 \i 6 \i 7
|
|
\endtable
|
|
|
|
\sa tile() setTiles()
|
|
*/
|
|
void TQCanvas::setTile( int x, int y, int tilenum )
|
|
{
|
|
ushort& t = grid[x+y*htiles];
|
|
if ( t != tilenum ) {
|
|
t = tilenum;
|
|
if ( tilew == tileh && tilew == chunksize )
|
|
setChangedChunk( x, y ); // common case
|
|
else
|
|
setChanged( TQRect(x*tilew,y*tileh,tilew,tileh) );
|
|
}
|
|
}
|
|
|
|
|
|
// lesser-used data in canvas item, plus room for extension.
|
|
// Be careful adding to this - check all usages.
|
|
class TQCanvasItemExtra {
|
|
TQCanvasItemExtra() : vx(0.0), vy(0.0) { }
|
|
double vx,vy;
|
|
friend class TQCanvasItem;
|
|
};
|
|
|
|
|
|
/*!
|
|
\class TQCanvasItem ntqcanvas.h
|
|
\brief The TQCanvasItem class provides an abstract graphic object on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A variety of TQCanvasItem subclasses provide immediately usable
|
|
behaviour. This class is a pure abstract superclass providing the
|
|
behaviour that is shared among all the concrete canvas item classes.
|
|
TQCanvasItem is not intended for direct subclassing. It is much easier
|
|
to subclass one of its subclasses, e.g. TQCanvasPolygonalItem (the
|
|
commonest base class), TQCanvasRectangle, TQCanvasSprite, TQCanvasEllipse
|
|
or TQCanvasText.
|
|
|
|
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 setCanvas().
|
|
|
|
Items appear on the canvas after their \link show() show()\endlink
|
|
function has been called (or \link setVisible()
|
|
setVisible(TRUE)\endlink), and \e after update() has been called. The
|
|
canvas only shows items that are \link setVisible() visible\endlink,
|
|
and then only if \l update() is called. If you created the canvas
|
|
without passing a width and height to the constructor you'll also need
|
|
to call \link TQCanvas::resize() resize()\endlink. Since the canvas
|
|
background defaults to white and canvas items default to white,
|
|
you may need to change colors to see your items.
|
|
|
|
A TQCanvasItem object can be moved in the x(), y() and z() dimensions
|
|
using functions such as move(), moveBy(), setX(), setY() and setZ(). A
|
|
canvas item can be set in motion, `animated', using setAnimated() and
|
|
given a velocity in the x and y directions with setXVelocity() and
|
|
setYVelocity() -- the same effect can be achieved by calling
|
|
setVelocity(). Use the collidesWith() function to see if the canvas item
|
|
will collide on the \e next advance(1) and use collisions() to see what
|
|
collisions have occurred.
|
|
|
|
Use TQCanvasSprite or your own subclass of TQCanvasSprite to create canvas
|
|
items which are animated, i.e. which change over time.
|
|
|
|
The size of a canvas item is given by boundingRect(). Use
|
|
boundingRectAdvanced() to see what the size of the canvas item will be
|
|
\e after the next advance(1) call.
|
|
|
|
The rtti() function is used for identifying subclasses of TQCanvasItem.
|
|
The canvas() function returns a pointer to the canvas which contains the
|
|
canvas item.
|
|
|
|
TQCanvasItem provides the show() and isVisible() functions like those in
|
|
TQWidget.
|
|
|
|
TQCanvasItem also provides the setEnabled(), setActive() and
|
|
setSelected() functions; these functions set the relevant boolean and
|
|
cause a repaint but the boolean values they set are not used in
|
|
TQCanvasItem itself. You can make use of these booleans in your subclasses.
|
|
|
|
By default, canvas items have no velocity, no size, and are not in
|
|
motion. The subclasses provided in TQt do not change these defaults
|
|
except where noted.
|
|
|
|
*/
|
|
|
|
/*!
|
|
\enum TQCanvasItem::RttiValues
|
|
|
|
This enum is used to name the different types of canvas item.
|
|
|
|
\value Rtti_Item Canvas item abstract base class
|
|
\value Rtti_Ellipse
|
|
\value Rtti_Line
|
|
\value Rtti_Polygon
|
|
\value Rtti_PolygonalItem
|
|
\value Rtti_Rectangle
|
|
\value Rtti_Spline
|
|
\value Rtti_Sprite
|
|
\value Rtti_Text
|
|
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::update()
|
|
|
|
Call this function to repaint the canvas's changed chunks.
|
|
*/
|
|
|
|
/*!
|
|
Constructs a TQCanvasItem on canvas \a canvas.
|
|
|
|
\sa setCanvas()
|
|
*/
|
|
TQCanvasItem::TQCanvasItem(TQCanvas* canvas) :
|
|
cnv(canvas),
|
|
myx(0),myy(0),myz(0)
|
|
{
|
|
ani=0;
|
|
vis=0;
|
|
val=0;
|
|
sel=0;
|
|
ena=0;
|
|
act=0;
|
|
|
|
ext = 0;
|
|
if (cnv) cnv->addItem(this);
|
|
}
|
|
|
|
/*!
|
|
Destroys the TQCanvasItem and removes it from its canvas.
|
|
*/
|
|
TQCanvasItem::~TQCanvasItem()
|
|
{
|
|
if (cnv) {
|
|
cnv->removeItem(this);
|
|
cnv->removeAnimation(this);
|
|
}
|
|
delete ext;
|
|
}
|
|
|
|
TQCanvasItemExtra& TQCanvasItem::extra()
|
|
{
|
|
if ( !ext )
|
|
ext = new TQCanvasItemExtra;
|
|
return *ext;
|
|
}
|
|
|
|
/*!
|
|
\fn double TQCanvasItem::x() const
|
|
|
|
Returns the horizontal position of the canvas item. Note that
|
|
subclasses often have an origin other than the top-left corner.
|
|
*/
|
|
|
|
/*!
|
|
\fn double TQCanvasItem::y() const
|
|
|
|
Returns the vertical position of the canvas item. Note that
|
|
subclasses often have an origin other than the top-left corner.
|
|
*/
|
|
|
|
/*!
|
|
\fn double TQCanvasItem::z() const
|
|
|
|
Returns the z index of the canvas item, which is used for visual
|
|
order: higher-z items obscure (are in front of) lower-z items.
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::setX(double x)
|
|
|
|
Moves the canvas item so that its x-position is \a x.
|
|
|
|
\sa x(), move()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::setY(double y)
|
|
|
|
Moves the canvas item so that its y-position is \a y.
|
|
|
|
\sa y(), move()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::setZ(double z)
|
|
|
|
Sets the z index of the canvas item to \a z. Higher-z items
|
|
obscure (are in front of) lower-z items.
|
|
|
|
\sa z(), move()
|
|
*/
|
|
|
|
|
|
/*!
|
|
Moves the canvas item relative to its current position by (\a dx,
|
|
\a dy).
|
|
*/
|
|
void TQCanvasItem::moveBy( double dx, double dy )
|
|
{
|
|
if ( dx || dy ) {
|
|
removeFromChunks();
|
|
myx += dx;
|
|
myy += dy;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Moves the canvas item to the absolute position (\a x, \a y).
|
|
*/
|
|
void TQCanvasItem::move( double x, double y )
|
|
{
|
|
moveBy( x-myx, y-myy );
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns TRUE if the canvas item is in motion; otherwise returns
|
|
FALSE.
|
|
|
|
\sa setVelocity(), setAnimated()
|
|
*/
|
|
bool TQCanvasItem::animated() const
|
|
{
|
|
return (bool)ani;
|
|
}
|
|
|
|
/*!
|
|
Sets the canvas item to be in motion if \a y is TRUE, or not if \a
|
|
y is FALSE. The speed and direction of the motion is set with
|
|
setVelocity(), or with setXVelocity() and setYVelocity().
|
|
|
|
\sa advance(), TQCanvas::advance()
|
|
*/
|
|
void TQCanvasItem::setAnimated(bool y)
|
|
{
|
|
if ( y != (bool)ani ) {
|
|
ani = (uint)y;
|
|
if ( y ) {
|
|
cnv->addAnimation(this);
|
|
} else {
|
|
cnv->removeAnimation(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::setXVelocity( double vx )
|
|
|
|
Sets the horizontal component of the canvas item's velocity to \a vx.
|
|
|
|
\sa setYVelocity() setVelocity()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::setYVelocity( double vy )
|
|
|
|
Sets the vertical component of the canvas item's velocity to \a vy.
|
|
|
|
\sa setXVelocity() setVelocity()
|
|
*/
|
|
|
|
/*!
|
|
Sets the canvas item to be in motion, moving by \a vx and \a vy
|
|
pixels in the horizontal and vertical directions respectively.
|
|
|
|
\sa advance() setXVelocity() setYVelocity()
|
|
*/
|
|
void TQCanvasItem::setVelocity( double vx, double vy)
|
|
{
|
|
if ( ext || vx!=0.0 || vy!=0.0 ) {
|
|
if ( !ani )
|
|
setAnimated(TRUE);
|
|
extra().vx = vx;
|
|
extra().vy = vy;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the horizontal velocity component of the canvas item.
|
|
*/
|
|
double TQCanvasItem::xVelocity() const
|
|
{
|
|
return ext ? ext->vx : 0;
|
|
}
|
|
|
|
/*!
|
|
Returns the vertical velocity component of the canvas item.
|
|
*/
|
|
double TQCanvasItem::yVelocity() const
|
|
{
|
|
return ext ? ext->vy : 0;
|
|
}
|
|
|
|
/*!
|
|
The default implementation moves the canvas item, if it is
|
|
animated(), by the preset velocity if \a phase is 1, and does
|
|
nothing if \a phase is 0.
|
|
|
|
Note that if you reimplement this function, the reimplementation
|
|
must not change the canvas in any way, for example it must not add
|
|
or remove items.
|
|
|
|
\sa TQCanvas::advance() setVelocity()
|
|
*/
|
|
void TQCanvasItem::advance(int phase)
|
|
{
|
|
if ( ext && phase==1 )
|
|
moveBy(ext->vx,ext->vy);
|
|
}
|
|
|
|
/*!
|
|
\fn void TQCanvasItem::draw(TQPainter& painter)
|
|
|
|
This abstract virtual function draws the canvas item using \a painter.
|
|
|
|
\warning When you reimplement this function, make sure that you
|
|
leave the painter in the same state as you found it. For example,
|
|
if you start by calling TQPainter::translate(50, 50), end your
|
|
code by calling TQPainter::translate(-50, -50). Be also aware that
|
|
the painter might already have some transformations set (i.e.,
|
|
don't call TQPainter::resetXForm() when you're done).
|
|
*/
|
|
|
|
/*!
|
|
Sets the TQCanvas upon which the canvas item is to be drawn to \a c.
|
|
|
|
\sa canvas()
|
|
*/
|
|
void TQCanvasItem::setCanvas(TQCanvas* c)
|
|
{
|
|
bool v=isVisible();
|
|
setVisible(FALSE);
|
|
if (cnv) {
|
|
if (ext)
|
|
cnv->removeAnimation(this);
|
|
cnv->removeItem(this);
|
|
}
|
|
cnv=c;
|
|
if (cnv) {
|
|
cnv->addItem(this);
|
|
if ( ext )
|
|
cnv->addAnimation(this);
|
|
}
|
|
setVisible(v);
|
|
}
|
|
|
|
/*!
|
|
\fn TQCanvas* TQCanvasItem::canvas() const
|
|
|
|
Returns the canvas containing the canvas item.
|
|
*/
|
|
|
|
/*! Shorthand for setVisible(TRUE). */
|
|
void TQCanvasItem::show()
|
|
{
|
|
setVisible(TRUE);
|
|
}
|
|
|
|
/*! Shorthand for setVisible(FALSE). */
|
|
void TQCanvasItem::hide()
|
|
{
|
|
setVisible(FALSE);
|
|
}
|
|
|
|
/*!
|
|
Makes the canvas item visible if \a yes is TRUE, or invisible if
|
|
\a yes is FALSE. The change takes effect when TQCanvas::update() is
|
|
next called.
|
|
*/
|
|
void TQCanvasItem::setVisible(bool yes)
|
|
{
|
|
if ((bool)vis!=yes) {
|
|
if (yes) {
|
|
vis=(uint)yes;
|
|
addToChunks();
|
|
} else {
|
|
removeFromChunks();
|
|
vis=(uint)yes;
|
|
}
|
|
}
|
|
}
|
|
/*!
|
|
\obsolete
|
|
\fn bool TQCanvasItem::visible() const
|
|
Use isVisible() instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvasItem::isVisible() const
|
|
|
|
Returns TRUE if the canvas item is visible; otherwise returns
|
|
FALSE.
|
|
|
|
Note that in this context TRUE does \e not mean that the canvas
|
|
item is currently in a view, merely that if a view is showing the
|
|
area where the canvas item is positioned, and the item is not
|
|
obscured by items with higher z values, and the view is not
|
|
obscured by overlaying windows, it would be visible.
|
|
|
|
\sa setVisible(), z()
|
|
*/
|
|
|
|
/*!
|
|
\obsolete
|
|
\fn bool TQCanvasItem::selected() const
|
|
Use isSelected() instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvasItem::isSelected() const
|
|
|
|
Returns TRUE if the canvas item is selected; otherwise returns FALSE.
|
|
*/
|
|
|
|
/*!
|
|
Sets the selected flag of the item to \a yes. If this changes the
|
|
item's selected state the item will be redrawn when
|
|
TQCanvas::update() is next called.
|
|
|
|
The TQCanvas, TQCanvasItem and the TQt-supplied TQCanvasItem
|
|
subclasses do not make use of this value. The setSelected()
|
|
function is supplied because many applications need it, but it is
|
|
up to you how you use the isSelected() value.
|
|
*/
|
|
void TQCanvasItem::setSelected(bool yes)
|
|
{
|
|
if ((bool)sel!=yes) {
|
|
sel=(uint)yes;
|
|
changeChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\obsolete
|
|
\fn bool TQCanvasItem::enabled() const
|
|
Use isEnabled() instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvasItem::isEnabled() const
|
|
|
|
Returns TRUE if the TQCanvasItem is enabled; otherwise returns FALSE.
|
|
*/
|
|
|
|
/*!
|
|
Sets the enabled flag of the item to \a yes. If this changes the
|
|
item's enabled state the item will be redrawn when
|
|
TQCanvas::update() is next called.
|
|
|
|
The TQCanvas, TQCanvasItem and the TQt-supplied TQCanvasItem
|
|
subclasses do not make use of this value. The setEnabled()
|
|
function is supplied because many applications need it, but it is
|
|
up to you how you use the isEnabled() value.
|
|
*/
|
|
void TQCanvasItem::setEnabled(bool yes)
|
|
{
|
|
if (ena!=(uint)yes) {
|
|
ena=(uint)yes;
|
|
changeChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\obsolete
|
|
\fn bool TQCanvasItem::active() const
|
|
Use isActive() instead.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQCanvasItem::isActive() const
|
|
|
|
Returns TRUE if the TQCanvasItem is active; otherwise returns FALSE.
|
|
*/
|
|
|
|
/*!
|
|
Sets the active flag of the item to \a yes. If this changes the
|
|
item's active state the item will be redrawn when
|
|
TQCanvas::update() is next called.
|
|
|
|
The TQCanvas, TQCanvasItem and the TQt-supplied TQCanvasItem
|
|
subclasses do not make use of this value. The setActive() function
|
|
is supplied because many applications need it, but it is up to you
|
|
how you use the isActive() value.
|
|
*/
|
|
void TQCanvasItem::setActive(bool yes)
|
|
{
|
|
if (act!=(uint)yes) {
|
|
act=(uint)yes;
|
|
changeChunks();
|
|
}
|
|
}
|
|
|
|
bool qt_testCollision(const TQCanvasSprite* s1, const TQCanvasSprite* s2)
|
|
{
|
|
const TQImage* s2image = s2->imageAdvanced()->collision_mask;
|
|
TQRect s2area = s2->boundingRectAdvanced();
|
|
|
|
TQRect cyourarea(s2area.x(),s2area.y(),
|
|
s2area.width(),s2area.height());
|
|
|
|
TQImage* s1image=s1->imageAdvanced()->collision_mask;
|
|
|
|
TQRect s1area = s1->boundingRectAdvanced();
|
|
|
|
TQRect ourarea = s1area.intersect(cyourarea);
|
|
|
|
if ( ourarea.isEmpty() )
|
|
return FALSE;
|
|
|
|
int x2=ourarea.x()-cyourarea.x();
|
|
int y2=ourarea.y()-cyourarea.y();
|
|
int x1=ourarea.x()-s1area.x();
|
|
int y1=ourarea.y()-s1area.y();
|
|
int w=ourarea.width();
|
|
int h=ourarea.height();
|
|
|
|
if ( !s2image ) {
|
|
if ( !s1image )
|
|
return w>0 && h>0;
|
|
// swap everything around
|
|
int t;
|
|
t=x1; x1=x2; x2=t;
|
|
t=y1; x1=y2; y2=t;
|
|
s2image = s1image;
|
|
s1image = 0;
|
|
}
|
|
|
|
// s2image != 0
|
|
|
|
// A non-linear search may be more efficient.
|
|
// Perhaps spiralling out from the center, or a simpler
|
|
// vertical expansion from the centreline.
|
|
|
|
// We assume that sprite masks don't have
|
|
// different bit orders.
|
|
//
|
|
// Q_ASSERT(s1image->bitOrder()==s2image->bitOrder());
|
|
|
|
if (s1image) {
|
|
if (s1image->bitOrder() == TQImage::LittleEndian) {
|
|
for (int j=0; j<h; j++) {
|
|
uchar* ml = s1image->scanLine(y1+j);
|
|
uchar* yl = s2image->scanLine(y2+j);
|
|
for (int i=0; i<w; i++) {
|
|
if (*(yl + ((x2+i) >> 3)) & (1 << ((x2+i) & 7))
|
|
&& *(ml + ((x1+i) >> 3)) & (1 << ((x1+i) & 7)))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int j=0; j<h; j++) {
|
|
uchar* ml = s1image->scanLine(y1+j);
|
|
uchar* yl = s2image->scanLine(y2+j);
|
|
for (int i=0; i<w; i++) {
|
|
if (*(yl + ((x2+i) >> 3)) & (1 << (7-((x2+i) & 7)))
|
|
&& *(ml + ((x1+i) >> 3)) & (1 << (7-((x1+i) & 7))))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (s2image->bitOrder() == TQImage::LittleEndian) {
|
|
for (int j=0; j<h; j++) {
|
|
uchar* yl = s2image->scanLine(y2+j);
|
|
for (int i=0; i<w; i++) {
|
|
if (*(yl + ((x2+i) >> 3)) & (1 << ((x2+i) & 7)))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int j=0; j<h; j++) {
|
|
uchar* yl = s2image->scanLine(y2+j);
|
|
for (int i=0; i<w; i++) {
|
|
if (*(yl + ((x2+i) >> 3)) & (1 << (7-((x2+i) & 7))))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static bool collision_double_dispatch( const TQCanvasSprite* s1,
|
|
const TQCanvasPolygonalItem* p1,
|
|
const TQCanvasRectangle* r1,
|
|
const TQCanvasEllipse* e1,
|
|
const TQCanvasText* t1,
|
|
const TQCanvasSprite* s2,
|
|
const TQCanvasPolygonalItem* p2,
|
|
const TQCanvasRectangle* r2,
|
|
const TQCanvasEllipse* e2,
|
|
const TQCanvasText* t2 )
|
|
{
|
|
const TQCanvasItem* i1 = s1 ?
|
|
(const TQCanvasItem*)s1 : p1 ?
|
|
(const TQCanvasItem*)p1 : r1 ?
|
|
(const TQCanvasItem*)r1 : e1 ?
|
|
(const TQCanvasItem*)e1 : (const TQCanvasItem*)t1;
|
|
const TQCanvasItem* i2 = s2 ?
|
|
(const TQCanvasItem*)s2 : p2 ?
|
|
(const TQCanvasItem*)p2 : r2 ?
|
|
(const TQCanvasItem*)r2 : e2 ?
|
|
(const TQCanvasItem*)e2 : (const TQCanvasItem*)t2;
|
|
|
|
if ( s1 && s2 ) {
|
|
// a
|
|
return qt_testCollision(s1,s2);
|
|
} else if ( (r1 || t1 || s1) && (r2 || t2 || s2) ) {
|
|
// b
|
|
TQRect rc1 = i1->boundingRectAdvanced();
|
|
TQRect rc2 = i2->boundingRectAdvanced();
|
|
return rc1.intersects(rc2);
|
|
} else if ( e1 && e2
|
|
&& e1->angleLength()>=360*16 && e2->angleLength()>=360*16
|
|
&& e1->width()==e1->height()
|
|
&& e2->width()==e2->height() ) {
|
|
// c
|
|
double xd = (e1->x()+e1->xVelocity())-(e2->x()+e1->xVelocity());
|
|
double yd = (e1->y()+e1->yVelocity())-(e2->y()+e1->yVelocity());
|
|
double rd = (e1->width()+e2->width())/2;
|
|
return xd*xd+yd*yd <= rd*rd;
|
|
} else if ( p1 && (p2 || s2 || t2) ) {
|
|
// d
|
|
TQPointArray pa1 = p1->areaPointsAdvanced();
|
|
TQPointArray pa2 = p2 ? p2->areaPointsAdvanced()
|
|
: TQPointArray(i2->boundingRectAdvanced());
|
|
bool col= !(TQRegion(pa1) & TQRegion(pa2,TRUE)).isEmpty();
|
|
|
|
return col;
|
|
} else {
|
|
return collision_double_dispatch(s2,p2,r2,e2,t2,
|
|
s1,p1,r1,e1,t1);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn bool TQCanvasItem::collidesWith( const TQCanvasItem* other ) const
|
|
|
|
Returns TRUE if the canvas item will collide with the \a other
|
|
item \e after they have moved by their current velocities;
|
|
otherwise returns FALSE.
|
|
|
|
\sa collisions()
|
|
*/
|
|
|
|
|
|
/*!
|
|
\class TQCanvasSprite ntqcanvas.h
|
|
\brief The TQCanvasSprite class provides an animated canvas item on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A canvas sprite is an object which can contain any number of images
|
|
(referred to as frames), only one of which is current, i.e.
|
|
displayed, at any one time. The images can be passed in the
|
|
constructor or set or changed later with setSequence(). If you
|
|
subclass TQCanvasSprite you can change the frame that is displayed
|
|
periodically, e.g. whenever TQCanvasItem::advance(1) is called to
|
|
create the effect of animation.
|
|
|
|
The current frame can be set with setFrame() or with move(). The
|
|
number of frames available is given by frameCount(). The bounding
|
|
rectangle of the current frame is returned by boundingRect().
|
|
|
|
The current frame's image can be retrieved with image(); use
|
|
imageAdvanced() to retrieve the image for the frame that will be
|
|
shown after advance(1) is called. Use the image() overload passing
|
|
it an integer index to retrieve a particular image from the list of
|
|
frames.
|
|
|
|
Use width() and height() to retrieve the dimensions of the current
|
|
frame.
|
|
|
|
Use leftEdge() and rightEdge() to retrieve the current frame's
|
|
left-hand and right-hand x-coordinates respectively. Use
|
|
bottomEdge() and topEdge() to retrieve the current frame's bottom
|
|
and top y-coordinates respectively. These functions have an overload
|
|
which will accept an integer frame number to retrieve the
|
|
coordinates of a particular frame.
|
|
|
|
TQCanvasSprite draws very quickly, at the expense of memory.
|
|
|
|
The current frame's image can be drawn on a painter with draw().
|
|
|
|
Like any other canvas item, canvas sprites can be moved with
|
|
move() which sets the x and y coordinates and the frame number, as
|
|
well as with TQCanvasItem::move() and TQCanvasItem::moveBy(), or by
|
|
setting coordinates with TQCanvasItem::setX(), TQCanvasItem::setY()
|
|
and TQCanvasItem::setZ().
|
|
|
|
*/
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQCanvasSprite::collidesWith( const TQCanvasItem* i ) const
|
|
{
|
|
return i->collidesWith(this,0,0,0,0);
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the canvas item collides with any of the given
|
|
items; otherwise returns FALSE. The parameters, \a s, \a p, \a r,
|
|
\a e and \a t, are all the same object, this is just a type
|
|
resolution trick.
|
|
*/
|
|
bool TQCanvasSprite::collidesWith( const TQCanvasSprite* s,
|
|
const TQCanvasPolygonalItem* p,
|
|
const TQCanvasRectangle* r,
|
|
const TQCanvasEllipse* e,
|
|
const TQCanvasText* t ) const
|
|
{
|
|
return collision_double_dispatch(s,p,r,e,t,this,0,0,0,0);
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQCanvasPolygonalItem::collidesWith( const TQCanvasItem* i ) const
|
|
{
|
|
return i->collidesWith(0,this,0,0,0);
|
|
}
|
|
|
|
bool TQCanvasPolygonalItem::collidesWith( const TQCanvasSprite* s,
|
|
const TQCanvasPolygonalItem* p,
|
|
const TQCanvasRectangle* r,
|
|
const TQCanvasEllipse* e,
|
|
const TQCanvasText* t ) const
|
|
{
|
|
return collision_double_dispatch(s,p,r,e,t,0,this,0,0,0);
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQCanvasRectangle::collidesWith( const TQCanvasItem* i ) const
|
|
{
|
|
return i->collidesWith(0,this,this,0,0);
|
|
}
|
|
|
|
bool TQCanvasRectangle::collidesWith( const TQCanvasSprite* s,
|
|
const TQCanvasPolygonalItem* p,
|
|
const TQCanvasRectangle* r,
|
|
const TQCanvasEllipse* e,
|
|
const TQCanvasText* t ) const
|
|
{
|
|
return collision_double_dispatch(s,p,r,e,t,0,this,this,0,0);
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQCanvasEllipse::collidesWith( const TQCanvasItem* i ) const
|
|
{
|
|
return i->collidesWith(0,this,0,this,0);
|
|
}
|
|
|
|
bool TQCanvasEllipse::collidesWith( const TQCanvasSprite* s,
|
|
const TQCanvasPolygonalItem* p,
|
|
const TQCanvasRectangle* r,
|
|
const TQCanvasEllipse* e,
|
|
const TQCanvasText* t ) const
|
|
{
|
|
return collision_double_dispatch(s,p,r,e,t,0,this,0,this,0);
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
bool TQCanvasText::collidesWith( const TQCanvasItem* i ) const
|
|
{
|
|
return i->collidesWith(0,0,0,0,this);
|
|
}
|
|
|
|
bool TQCanvasText::collidesWith( const TQCanvasSprite* s,
|
|
const TQCanvasPolygonalItem* p,
|
|
const TQCanvasRectangle* r,
|
|
const TQCanvasEllipse* e,
|
|
const TQCanvasText* t ) const
|
|
{
|
|
return collision_double_dispatch(s,p,r,e,t,0,0,0,0,this);
|
|
}
|
|
|
|
/*!
|
|
Returns the list of canvas items that this canvas item has
|
|
collided with.
|
|
|
|
A collision is generally defined as occurring when the pixels of
|
|
one item draw on the pixels of another item, but not all
|
|
subclasses are so precise. Also, since pixel-wise collision
|
|
detection can be slow, this function works in either exact or
|
|
inexact mode, according to the \a exact parameter.
|
|
|
|
If \a exact is TRUE, the canvas items returned have been
|
|
accurately tested for collision with the canvas item.
|
|
|
|
If \a exact is FALSE, the canvas items returned are \e near the
|
|
canvas item. You can test the canvas items returned using
|
|
collidesWith() if any are interesting collision candidates. By
|
|
using this approach, you can ignore some canvas items for which
|
|
collisions are not relevant.
|
|
|
|
The returned list is a list of TQCanvasItems, but often you will
|
|
need to cast the items to their subclass types. The safe way to do
|
|
this is to use rtti() before casting. This provides some of the
|
|
functionality of the standard C++ dynamic cast operation even on
|
|
compilers where dynamic casts are not available.
|
|
|
|
Note that a canvas item may be `on' a canvas, e.g. it was created
|
|
with the canvas as parameter, even though its coordinates place it
|
|
beyond the edge of the canvas's area. Collision detection only
|
|
works for canvas items which are wholly or partly within the
|
|
canvas's area.
|
|
|
|
Note that if items have a velocity (see \l setVelocity()), then
|
|
collision testing is done based on where the item \e will be when
|
|
it moves, not its current location. For example, a "ball" item
|
|
doesn't need to actually embed into a "wall" item before a
|
|
collision is detected. For items without velocity, plain
|
|
intersection is used.
|
|
*/
|
|
TQCanvasItemList TQCanvasItem::collisions(bool exact) const
|
|
{
|
|
return canvas()->collisions(chunks(),this,exact);
|
|
}
|
|
|
|
/*!
|
|
Returns a list of canvas items that collide with the point \a p.
|
|
The list is ordered by z coordinates, from highest z coordinate
|
|
(front-most item) to lowest z coordinate (rear-most item).
|
|
*/
|
|
TQCanvasItemList TQCanvas::collisions(const TQPoint& p) const
|
|
{
|
|
return collisions(TQRect(p,TQSize(1,1)));
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns a list of items which collide with the rectangle \a r. The
|
|
list is ordered by z coordinates, from highest z coordinate
|
|
(front-most item) to lowest z coordinate (rear-most item).
|
|
*/
|
|
TQCanvasItemList TQCanvas::collisions(const TQRect& r) const
|
|
{
|
|
TQCanvasRectangle i(r,(TQCanvas*)this);
|
|
i.setPen(NoPen);
|
|
i.show(); // doesn't actually show, since we destroy it
|
|
TQCanvasItemList l = i.collisions(TRUE);
|
|
l.sort();
|
|
return l;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns a list of canvas items which intersect with the chunks
|
|
listed in \a chunklist, excluding \a item. If \a exact is TRUE,
|
|
only those which actually \link TQCanvasItem::collidesWith()
|
|
collide with\endlink \a 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
|
|
TQCanvasItem::collisions() function.
|
|
*/
|
|
TQCanvasItemList TQCanvas::collisions(const TQPointArray& chunklist,
|
|
const TQCanvasItem* item, bool exact) const
|
|
{
|
|
TQPtrDict<void> seen;
|
|
TQCanvasItemList result;
|
|
for (int i=0; i<(int)chunklist.count(); i++) {
|
|
int x = chunklist[i].x();
|
|
int y = chunklist[i].y();
|
|
if ( validChunk(x,y) ) {
|
|
const TQCanvasItemList* l = chunk(x,y).listPtr();
|
|
for (TQCanvasItemList::ConstIterator it=l->begin(); it!=l->end(); ++it) {
|
|
TQCanvasItem *g=*it;
|
|
if ( g != item ) {
|
|
if ( !seen.find(g) ) {
|
|
seen.replace(g,(void*)1);
|
|
if ( !exact || item->collidesWith(g) )
|
|
result.append(g);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Adds the item to all the chunks it covers.
|
|
*/
|
|
void TQCanvasItem::addToChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
TQPointArray pa = chunks();
|
|
for (int i=0; i<(int)pa.count(); i++)
|
|
canvas()->addItemToChunk(this,pa[i].x(),pa[i].y());
|
|
val=(uint)TRUE;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Removes the item from all the chunks it covers.
|
|
*/
|
|
void TQCanvasItem::removeFromChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
TQPointArray pa = chunks();
|
|
for (int i=0; i<(int)pa.count(); i++)
|
|
canvas()->removeItemFromChunk(this,pa[i].x(),pa[i].y());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Sets all the chunks covered by the item to be refreshed with TQCanvas::update()
|
|
is next called.
|
|
*/
|
|
void TQCanvasItem::changeChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
if (!val)
|
|
addToChunks();
|
|
TQPointArray pa = chunks();
|
|
for (int i=0; i<(int)pa.count(); i++)
|
|
canvas()->setChangedChunk(pa[i].x(),pa[i].y());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn TQRect TQCanvasItem::boundingRect() const
|
|
|
|
Returns the bounding rectangle in pixels that the canvas item covers.
|
|
|
|
\sa boundingRectAdvanced()
|
|
*/
|
|
|
|
/*!
|
|
Returns the bounding rectangle of pixels that the canvas item \e
|
|
will cover after advance(1) is called.
|
|
|
|
\sa boundingRect()
|
|
*/
|
|
TQRect TQCanvasItem::boundingRectAdvanced() const
|
|
{
|
|
int dx = int(x()+xVelocity())-int(x());
|
|
int dy = int(y()+yVelocity())-int(y());
|
|
TQRect r = boundingRect();
|
|
r.moveBy(dx,dy);
|
|
return r;
|
|
}
|
|
|
|
/*!
|
|
\class TQCanvasPixmap ntqcanvas.h
|
|
\brief The TQCanvasPixmap class provides pixmaps for TQCanvasSprites.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
If you want to show a single pixmap on a TQCanvas use a
|
|
TQCanvasSprite with just one pixmap.
|
|
|
|
When pixmaps are inserted into a TQCanvasPixmapArray they are held
|
|
as TQCanvasPixmaps. \l{TQCanvasSprite}s are used to show pixmaps on
|
|
\l{TQCanvas}es and hold their pixmaps in a TQCanvasPixmapArray. If
|
|
you retrieve a frame (pixmap) from a TQCanvasSprite it will be
|
|
returned as a TQCanvasPixmap.
|
|
|
|
The pixmap is a TQPixmap and can only be set in the constructor.
|
|
There are three different constructors, one taking a TQPixmap, one
|
|
a TQImage and one a file name that refers to a file in any
|
|
supported file format (see TQImageIO).
|
|
|
|
TQCanvasPixmap can have a hotspot which is defined in terms of an (x,
|
|
y) offset. When you create a TQCanvasPixmap from a PNG file or from
|
|
a TQImage that has a TQImage::offset(), the offset() is initialized
|
|
appropriately, otherwise the constructor leaves it at (0, 0). You
|
|
can set it later using setOffset(). When the TQCanvasPixmap is used
|
|
in a TQCanvasSprite, the offset position is the point at
|
|
TQCanvasItem::x() and TQCanvasItem::y(), not the top-left corner of
|
|
the pixmap.
|
|
|
|
Note that for TQCanvasPixmap objects created by a TQCanvasSprite, the
|
|
position of each TQCanvasPixmap object is set so that the hotspot
|
|
stays in the same position.
|
|
|
|
\sa TQCanvasPixmapArray TQCanvasItem TQCanvasSprite
|
|
*/
|
|
|
|
#ifndef QT_NO_IMAGEIO
|
|
|
|
/*!
|
|
Constructs a TQCanvasPixmap that uses the image stored in \a
|
|
datafilename.
|
|
*/
|
|
TQCanvasPixmap::TQCanvasPixmap(const TQString& datafilename)
|
|
{
|
|
TQImage image(datafilename);
|
|
init(image);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*!
|
|
Constructs a TQCanvasPixmap from the image \a image.
|
|
*/
|
|
TQCanvasPixmap::TQCanvasPixmap(const TQImage& image)
|
|
{
|
|
init(image);
|
|
}
|
|
/*!
|
|
Constructs a TQCanvasPixmap from the pixmap \a pm using the offset
|
|
\a offset.
|
|
*/
|
|
TQCanvasPixmap::TQCanvasPixmap(const TQPixmap& pm, const TQPoint& offset)
|
|
{
|
|
init(pm,offset.x(),offset.y());
|
|
}
|
|
|
|
void TQCanvasPixmap::init(const TQImage& image)
|
|
{
|
|
convertFromImage(image);
|
|
hotx = image.offset().x();
|
|
hoty = image.offset().y();
|
|
#ifndef QT_NO_IMAGE_DITHER_TO_1
|
|
if( image.hasAlphaBuffer() ) {
|
|
TQImage i = image.createAlphaMask();
|
|
collision_mask = new TQImage(i);
|
|
} else
|
|
#endif
|
|
collision_mask = 0;
|
|
}
|
|
|
|
void TQCanvasPixmap::init(const TQPixmap& pixmap, int hx, int hy)
|
|
{
|
|
(TQPixmap&)*this = pixmap;
|
|
hotx = hx;
|
|
hoty = hy;
|
|
if( pixmap.mask() ) {
|
|
TQImage i = mask()->convertToImage();
|
|
collision_mask = new TQImage(i);
|
|
} else
|
|
collision_mask = 0;
|
|
}
|
|
|
|
/*!
|
|
Destroys the pixmap.
|
|
*/
|
|
TQCanvasPixmap::~TQCanvasPixmap()
|
|
{
|
|
delete collision_mask;
|
|
}
|
|
|
|
/*!
|
|
\fn int TQCanvasPixmap::offsetX() const
|
|
|
|
Returns the x-offset of the pixmap's hotspot.
|
|
|
|
\sa setOffset()
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvasPixmap::offsetY() const
|
|
|
|
Returns the y-offset of the pixmap's hotspot.
|
|
|
|
\sa setOffset()
|
|
*/
|
|
|
|
/*!
|
|
\fn void TQCanvasPixmap::setOffset(int x, int y)
|
|
|
|
Sets the offset of the pixmap's hotspot to (\a x, \a y).
|
|
|
|
\warning Do not call this function if any TQCanvasSprites are
|
|
currently showing this pixmap.
|
|
*/
|
|
|
|
/*!
|
|
\class TQCanvasPixmapArray ntqcanvas.h
|
|
\brief The TQCanvasPixmapArray class provides an array of TQCanvasPixmaps.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
|
|
This class is used by TQCanvasSprite to hold an array of pixmaps.
|
|
It is used to implement animated sprites, i.e. images that change
|
|
over time, with each pixmap in the array holding one frame.
|
|
|
|
Depending on the constructor you use you can load multiple pixmaps
|
|
into the array either from a directory (specifying a wildcard
|
|
pattern for the files), or from a list of TQPixmaps. You can also
|
|
read in a set of pixmaps after construction using readPixmaps().
|
|
|
|
Individual pixmaps can be set with setImage() and retrieved with
|
|
image(). The number of pixmaps in the array is returned by
|
|
count().
|
|
|
|
TQCanvasSprite uses an image's mask for collision detection. You
|
|
can change this by reading in a separate set of image masks using
|
|
readCollisionMasks().
|
|
|
|
*/
|
|
|
|
/*!
|
|
Constructs an invalid array (i.e. isValid() will return FALSE).
|
|
You must call readPixmaps() before being able to use this
|
|
TQCanvasPixmapArray.
|
|
*/
|
|
TQCanvasPixmapArray::TQCanvasPixmapArray()
|
|
: framecount( 0 ), img( 0 )
|
|
{
|
|
}
|
|
|
|
#ifndef QT_NO_IMAGEIO
|
|
/*!
|
|
Constructs a TQCanvasPixmapArray from files.
|
|
|
|
The \a fc parameter sets the number of frames to be loaded for
|
|
this image.
|
|
|
|
If \a fc is not 0, \a datafilenamepattern should contain "%1",
|
|
e.g. "foo%1.png". The actual filenames are formed by replacing the
|
|
%1 with four-digit integers from 0 to (fc - 1), e.g. foo0000.png,
|
|
foo0001.png, foo0002.png, etc.
|
|
|
|
If \a fc is 0, \a datafilenamepattern is asssumed to be a
|
|
filename, and the image contained in this file will be loaded as
|
|
the first (and only) frame.
|
|
|
|
If \a datafilenamepattern does not exist, is not readable, isn't
|
|
an image, or some other error occurs, the array ends up empty and
|
|
isValid() returns FALSE.
|
|
*/
|
|
|
|
TQCanvasPixmapArray::TQCanvasPixmapArray( const TQString& datafilenamepattern,
|
|
int fc )
|
|
: framecount( 0 ), img( 0 )
|
|
{
|
|
readPixmaps(datafilenamepattern,fc);
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
\obsolete
|
|
Use TQCanvasPixmapArray::TQCanvasPixmapArray( TQValueList<TQPixmap>, TQPointArray )
|
|
instead.
|
|
|
|
Constructs a TQCanvasPixmapArray from the list of TQPixmaps \a
|
|
list. The \a hotspots list has to be of the same size as \a list.
|
|
*/
|
|
TQCanvasPixmapArray::TQCanvasPixmapArray(TQPtrList<TQPixmap> list, TQPtrList<TQPoint> hotspots) :
|
|
framecount(list.count()),
|
|
img(new TQCanvasPixmap*[list.count()])
|
|
{
|
|
if (list.count() != hotspots.count()) {
|
|
tqWarning("TQCanvasPixmapArray: lists have different lengths");
|
|
reset();
|
|
img = 0;
|
|
} else {
|
|
list.first();
|
|
hotspots.first();
|
|
for (int i=0; i<framecount; i++) {
|
|
img[i]=new TQCanvasPixmap(*list.current(), *hotspots.current());
|
|
list.next();
|
|
hotspots.next();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Constructs a TQCanvasPixmapArray from the list of TQPixmaps in the
|
|
\a list. Each pixmap will get a hotspot according to the \a
|
|
hotspots array. If no hotspots are specified, each one is set to
|
|
be at position (0, 0).
|
|
|
|
If an error occurs, isValid() will return FALSE.
|
|
*/
|
|
TQCanvasPixmapArray::TQCanvasPixmapArray(TQValueList<TQPixmap> list, TQPointArray hotspots) :
|
|
framecount((int)list.size()),
|
|
img(new TQCanvasPixmap*[list.size()])
|
|
{
|
|
bool have_hotspots = ( hotspots.size() != 0 );
|
|
if (have_hotspots && list.count() != hotspots.count()) {
|
|
tqWarning("TQCanvasPixmapArray: lists have different lengths");
|
|
reset();
|
|
img = 0;
|
|
} else {
|
|
TQValueList<TQPixmap>::iterator it;
|
|
it = list.begin();
|
|
for (int i=0; i<framecount; i++) {
|
|
TQPoint hs = have_hotspots ? hotspots[i] : TQPoint( 0, 0 );
|
|
img[i]=new TQCanvasPixmap( *it, hs );
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Destroys the pixmap array and all the pixmaps it contains.
|
|
*/
|
|
TQCanvasPixmapArray::~TQCanvasPixmapArray()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void TQCanvasPixmapArray::reset()
|
|
{
|
|
for (int i=0; i<framecount; i++)
|
|
delete img[i];
|
|
delete [] img;
|
|
img = 0;
|
|
framecount = 0;
|
|
}
|
|
|
|
#ifndef QT_NO_IMAGEIO
|
|
/*!
|
|
Reads one or more pixmaps into the pixmap array.
|
|
|
|
If \a fc is not 0, \a filenamepattern should contain "%1", e.g.
|
|
"foo%1.png". The actual filenames are formed by replacing the %1
|
|
with four-digit integers from 0 to (fc - 1), e.g. foo0000.png,
|
|
foo0001.png, foo0002.png, etc.
|
|
|
|
If \a fc is 0, \a filenamepattern is asssumed to be a filename,
|
|
and the image contained in this file will be loaded as the first
|
|
(and only) frame.
|
|
|
|
If \a filenamepattern does not exist, is not readable, isn't an
|
|
image, or some other error occurs, this function will return
|
|
FALSE, and isValid() will return FALSE; otherwise this function
|
|
will return TRUE.
|
|
|
|
\sa isValid()
|
|
*/
|
|
bool TQCanvasPixmapArray::readPixmaps( const TQString& filenamepattern,
|
|
int fc)
|
|
{
|
|
return readPixmaps(filenamepattern,fc,FALSE);
|
|
}
|
|
|
|
/*!
|
|
Reads new collision masks for the array.
|
|
|
|
By default, TQCanvasSprite uses the image mask of a sprite to
|
|
detect collisions. Use this function to set your own collision
|
|
image masks.
|
|
|
|
If count() is 1 \a filename must specify a real filename to read
|
|
the mask from. If count() is greater than 1, the \a filename must
|
|
contain a "%1" that will get replaced by the number of the mask to
|
|
be loaded, just like TQCanvasPixmapArray::readPixmaps().
|
|
|
|
All collision masks must be 1-bit images or this function call
|
|
will fail.
|
|
|
|
If the file isn't readable, contains the wrong number of images,
|
|
or there is some other error, this function will return FALSE, and
|
|
the array will be flagged as invalid; otherwise this function
|
|
returns TRUE.
|
|
|
|
\sa isValid()
|
|
*/
|
|
bool TQCanvasPixmapArray::readCollisionMasks(const TQString& filename)
|
|
{
|
|
return readPixmaps(filename,framecount,TRUE);
|
|
}
|
|
|
|
|
|
bool TQCanvasPixmapArray::readPixmaps( const TQString& datafilenamepattern,
|
|
int fc, bool maskonly)
|
|
{
|
|
if ( !maskonly ) {
|
|
reset();
|
|
framecount = fc;
|
|
if ( !framecount )
|
|
framecount=1;
|
|
img = new TQCanvasPixmap*[framecount];
|
|
}
|
|
if (!img)
|
|
return FALSE;
|
|
bool ok = TRUE;
|
|
bool arg = fc > 1;
|
|
if ( !arg )
|
|
framecount=1;
|
|
for (int i=0; i<framecount; i++) {
|
|
TQString r;
|
|
r.sprintf("%04d",i);
|
|
if ( maskonly ) {
|
|
if (!img[i]->collision_mask)
|
|
img[i]->collision_mask = new TQImage();
|
|
img[i]->collision_mask->load(
|
|
arg ? datafilenamepattern.arg(r) : datafilenamepattern);
|
|
ok = ok
|
|
&& !img[i]->collision_mask->isNull()
|
|
&& img[i]->collision_mask->depth()==1;
|
|
} else {
|
|
img[i]=new TQCanvasPixmap(
|
|
arg ? datafilenamepattern.arg(r) : datafilenamepattern);
|
|
ok = ok && !img[i]->isNull();
|
|
}
|
|
}
|
|
if ( !ok ) {
|
|
reset();
|
|
}
|
|
return ok;
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
\obsolete
|
|
|
|
Use isValid() instead.
|
|
|
|
This returns FALSE if the array is valid, and TRUE if it is not.
|
|
*/
|
|
bool TQCanvasPixmapArray::operator!()
|
|
{
|
|
return img==0;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the pixmap array is valid; otherwise returns
|
|
FALSE.
|
|
*/
|
|
bool TQCanvasPixmapArray::isValid() const
|
|
{
|
|
return (img != 0);
|
|
}
|
|
|
|
/*!
|
|
\fn TQCanvasPixmap* TQCanvasPixmapArray::image(int i) const
|
|
|
|
Returns pixmap \a i in the array, if \a i is non-negative and less
|
|
than than count(), and returns an unspecified value otherwise.
|
|
*/
|
|
|
|
// ### wouldn't it be better to put empty TQCanvasPixmaps in there instead of
|
|
// initializing the additional elements in the array to 0? Lars
|
|
/*!
|
|
Replaces the pixmap at index \a i with pixmap \a p.
|
|
|
|
The array takes ownership of \a p and will delete \a p when the
|
|
array itself is deleted.
|
|
|
|
If \a i is beyond the end of the array the array is extended to at
|
|
least i+1 elements, with elements count() to i-1 being initialized
|
|
to 0.
|
|
*/
|
|
void TQCanvasPixmapArray::setImage(int i, TQCanvasPixmap* p)
|
|
{
|
|
if ( i >= framecount ) {
|
|
TQCanvasPixmap** newimg = new TQCanvasPixmap*[i+1];
|
|
memcpy(newimg, img, sizeof( TQCanvasPixmap * )*framecount);
|
|
memset(newimg + framecount, 0, sizeof( TQCanvasPixmap * )*( i+1 - framecount ) );
|
|
framecount = i+1;
|
|
delete [] img;
|
|
img = newimg;
|
|
}
|
|
delete img[i]; img[i]=p;
|
|
}
|
|
|
|
/*!
|
|
\fn uint TQCanvasPixmapArray::count() const
|
|
|
|
Returns the number of pixmaps in the array.
|
|
*/
|
|
|
|
/*!
|
|
Returns the x-coordinate of the current left edge of the sprite.
|
|
(This may change as the sprite animates since different frames may
|
|
have different left edges.)
|
|
|
|
\sa rightEdge() bottomEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::leftEdge() const
|
|
{
|
|
return int(x()) - image()->hotx;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns what the x-coordinate of the left edge of the sprite would
|
|
be if the sprite (actually its hotspot) were moved to x-position
|
|
\a nx.
|
|
|
|
\sa rightEdge() bottomEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::leftEdge(int nx) const
|
|
{
|
|
return nx - image()->hotx;
|
|
}
|
|
|
|
/*!
|
|
Returns the y-coordinate of the top edge of the sprite. (This may
|
|
change as the sprite animates since different frames may have
|
|
different top edges.)
|
|
|
|
\sa leftEdge() rightEdge() bottomEdge()
|
|
*/
|
|
int TQCanvasSprite::topEdge() const
|
|
{
|
|
return int(y()) - image()->hoty;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns what the y-coordinate of the top edge of the sprite would
|
|
be if the sprite (actually its hotspot) were moved to y-position
|
|
\a ny.
|
|
|
|
\sa leftEdge() rightEdge() bottomEdge()
|
|
*/
|
|
int TQCanvasSprite::topEdge(int ny) const
|
|
{
|
|
return ny - image()->hoty;
|
|
}
|
|
|
|
/*!
|
|
Returns the x-coordinate of the current right edge of the sprite.
|
|
(This may change as the sprite animates since different frames may
|
|
have different right edges.)
|
|
|
|
\sa leftEdge() bottomEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::rightEdge() const
|
|
{
|
|
return leftEdge() + image()->width()-1;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns what the x-coordinate of the right edge of the sprite
|
|
would be if the sprite (actually its hotspot) were moved to
|
|
x-position \a nx.
|
|
|
|
\sa leftEdge() bottomEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::rightEdge(int nx) const
|
|
{
|
|
return leftEdge(nx) + image()->width()-1;
|
|
}
|
|
|
|
/*!
|
|
Returns the y-coordinate of the current bottom edge of the sprite.
|
|
(This may change as the sprite animates since different frames may
|
|
have different bottom edges.)
|
|
|
|
\sa leftEdge() rightEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::bottomEdge() const
|
|
{
|
|
return topEdge() + image()->height()-1;
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Returns what the y-coordinate of the top edge of the sprite would
|
|
be if the sprite (actually its hotspot) were moved to y-position
|
|
\a ny.
|
|
|
|
\sa leftEdge() rightEdge() topEdge()
|
|
*/
|
|
int TQCanvasSprite::bottomEdge(int ny) const
|
|
{
|
|
return topEdge(ny) + image()->height()-1;
|
|
}
|
|
|
|
/*!
|
|
\fn TQCanvasPixmap* TQCanvasSprite::image() const
|
|
|
|
Returns the current frame's image.
|
|
|
|
\sa frame(), setFrame()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQCanvasPixmap* TQCanvasSprite::image(int f) const
|
|
\overload
|
|
|
|
Returns the image for frame \a f. Does not do any bounds checking on \a f.
|
|
*/
|
|
|
|
/*!
|
|
Returns the image the sprite \e will have after advance(1) is
|
|
called. By default this is the same as image().
|
|
*/
|
|
TQCanvasPixmap* TQCanvasSprite::imageAdvanced() const
|
|
{
|
|
return image();
|
|
}
|
|
|
|
/*!
|
|
Returns the bounding rectangle for the image in the sprite's
|
|
current frame. This assumes that the images are tightly cropped
|
|
(i.e. do not have transparent pixels all along a side).
|
|
*/
|
|
TQRect TQCanvasSprite::boundingRect() const
|
|
{
|
|
return TQRect(leftEdge(), topEdge(), width(), height());
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
Returns the chunks covered by the item.
|
|
*/
|
|
TQPointArray TQCanvasItem::chunks() const
|
|
{
|
|
TQPointArray r;
|
|
int n=0;
|
|
TQRect br = boundingRect();
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
br &= TQRect(0,0,canvas()->width(),canvas()->height());
|
|
if ( br.isValid() ) {
|
|
r.resize((br.width()/chunksize+2)*(br.height()/chunksize+2));
|
|
for (int j=br.top()/chunksize; j<=br.bottom()/chunksize; j++) {
|
|
for (int i=br.left()/chunksize; i<=br.right()/chunksize; i++) {
|
|
r[n++] = TQPoint(i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
r.resize(n);
|
|
return r;
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
Add the sprite to the chunks in its TQCanvas which it overlaps.
|
|
*/
|
|
void TQCanvasSprite::addToChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=topEdge()/chunksize; j<=bottomEdge()/chunksize; j++) {
|
|
for (int i=leftEdge()/chunksize; i<=rightEdge()/chunksize; i++) {
|
|
canvas()->addItemToChunk(this,i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Remove the sprite from the chunks in its TQCanvas which it overlaps.
|
|
|
|
\sa addToChunks()
|
|
*/
|
|
void TQCanvasSprite::removeFromChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=topEdge()/chunksize; j<=bottomEdge()/chunksize; j++) {
|
|
for (int i=leftEdge()/chunksize; i<=rightEdge()/chunksize; i++) {
|
|
canvas()->removeItemFromChunk(this,i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
The width of the sprite for the current frame's image.
|
|
|
|
\sa frame()
|
|
*/
|
|
//### mark: Why don't we have width(int) and height(int) to be
|
|
//consistent with leftEdge() and leftEdge(int)?
|
|
int TQCanvasSprite::width() const
|
|
{
|
|
return image()->width();
|
|
}
|
|
|
|
/*!
|
|
The height of the sprite for the current frame's image.
|
|
|
|
\sa frame()
|
|
*/
|
|
int TQCanvasSprite::height() const
|
|
{
|
|
return image()->height();
|
|
}
|
|
|
|
|
|
/*!
|
|
Draws the current frame's image at the sprite's current position
|
|
on painter \a painter.
|
|
*/
|
|
void TQCanvasSprite::draw(TQPainter& painter)
|
|
{
|
|
painter.drawPixmap(leftEdge(),topEdge(),*image());
|
|
}
|
|
|
|
/*!
|
|
\class TQCanvasView ntqcanvas.h
|
|
\brief The TQCanvasView class provides an on-screen view of a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A TQCanvasView is widget which provides a view of a TQCanvas.
|
|
|
|
If you want users to be able to interact with a canvas view,
|
|
subclass TQCanvasView. You might then reimplement
|
|
TQScrollView::contentsMousePressEvent(). For example, assuming no
|
|
transformation matrix is set:
|
|
|
|
\code
|
|
void MyCanvasView::contentsMousePressEvent( TQMouseEvent* e )
|
|
{
|
|
TQCanvasItemList l = canvas()->collisions(e->pos());
|
|
for (TQCanvasItemList::Iterator it=l.begin(); it!=l.end(); ++it) {
|
|
if ( (*it)->rtti() == TQCanvasRectangle::RTTI )
|
|
tqDebug("A TQCanvasRectangle lies somewhere at this point");
|
|
}
|
|
}
|
|
\endcode
|
|
|
|
The canvas view shows canvas canvas(); this can be changed using
|
|
setCanvas().
|
|
|
|
A transformation matrix can be used to transform the view of the
|
|
canvas in various ways, for example, zooming in or out or rotating.
|
|
For example:
|
|
|
|
\code
|
|
TQWMatrix wm;
|
|
wm.scale( 2, 2 ); // Zooms in by 2 times
|
|
wm.rotate( 90 ); // Rotates 90 degrees counter clockwise
|
|
// around the origin.
|
|
wm.translate( 0, -canvas->height() );
|
|
// moves the canvas down so what was visible
|
|
// before is still visible.
|
|
myCanvasView->setWorldMatrix( wm );
|
|
\endcode
|
|
|
|
Use setWorldMatrix() to set the canvas view's world matrix: you must
|
|
ensure that the world matrix is invertible. The current world matrix
|
|
is retrievable with worldMatrix(), and its inversion is retrievable
|
|
with inverseWorldMatrix().
|
|
|
|
Example:
|
|
|
|
The following code finds the part of the canvas that is visible in
|
|
this view, i.e. the bounding rectangle of the view in canvas coordinates.
|
|
|
|
\code
|
|
TQRect rc = TQRect( myCanvasView->contentsX(), myCanvasView->contentsY(),
|
|
myCanvasView->visibleWidth(), myCanvasView->visibleHeight() );
|
|
TQRect canvasRect = myCanvasView->inverseWorldMatrix().mapRect(rc);
|
|
\endcode
|
|
|
|
\sa TQWMatrix TQPainter::setWorldMatrix()
|
|
|
|
*/
|
|
|
|
/*!
|
|
Constructs a TQCanvasView with parent \a parent, and name \a name,
|
|
using the widget flags \a f. The canvas view is not associated
|
|
with a canvas, so you must to call setCanvas() to view a
|
|
canvas.
|
|
*/
|
|
TQCanvasView::TQCanvasView(TQWidget* parent, const char* name, WFlags f) :
|
|
TQScrollView(parent,name,f|WResizeNoErase|WStaticContents)
|
|
{
|
|
d = new TQCanvasViewData;
|
|
viewing = 0;
|
|
setCanvas(0);
|
|
connect(this,SIGNAL(contentsMoving(int,int)),this,SLOT(cMoving(int,int)));
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
Constructs a TQCanvasView which views canvas \a canvas, with parent
|
|
\a parent, and name \a name, using the widget flags \a f.
|
|
*/
|
|
TQCanvasView::TQCanvasView(TQCanvas* canvas, TQWidget* parent, const char* name, WFlags f) :
|
|
TQScrollView(parent,name,f|WResizeNoErase|WStaticContents)
|
|
{
|
|
d = new TQCanvasViewData;
|
|
viewing = 0;
|
|
setCanvas(canvas);
|
|
|
|
connect(this,SIGNAL(contentsMoving(int,int)),this,SLOT(cMoving(int,int)));
|
|
}
|
|
|
|
/*!
|
|
Destroys the canvas view. The associated canvas is \e not deleted.
|
|
*/
|
|
TQCanvasView::~TQCanvasView()
|
|
{
|
|
delete d;
|
|
d = 0;
|
|
setCanvas(0);
|
|
}
|
|
|
|
/*!
|
|
\fn TQCanvas* TQCanvasView::canvas() const
|
|
|
|
Returns a pointer to the canvas which the TQCanvasView is currently
|
|
showing.
|
|
*/
|
|
|
|
|
|
/*!
|
|
Sets the canvas that the TQCanvasView is showing to the canvas \a
|
|
canvas.
|
|
*/
|
|
void TQCanvasView::setCanvas(TQCanvas* canvas)
|
|
{
|
|
if (viewing) {
|
|
disconnect(viewing);
|
|
viewing->removeView(this);
|
|
}
|
|
viewing=canvas;
|
|
if (viewing) {
|
|
connect(viewing,SIGNAL(resized()), this, SLOT(updateContentsSize()));
|
|
viewing->addView(this);
|
|
}
|
|
if ( d ) // called by d'tor
|
|
updateContentsSize();
|
|
}
|
|
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
/*!
|
|
Returns a reference to the canvas view's current transformation matrix.
|
|
|
|
\sa setWorldMatrix() inverseWorldMatrix()
|
|
*/
|
|
const TQWMatrix &TQCanvasView::worldMatrix() const
|
|
{
|
|
return d->xform;
|
|
}
|
|
|
|
/*!
|
|
Returns a reference to the inverse of the canvas view's current
|
|
transformation matrix.
|
|
|
|
\sa setWorldMatrix() worldMatrix()
|
|
*/
|
|
const TQWMatrix &TQCanvasView::inverseWorldMatrix() const
|
|
{
|
|
return d->ixform;
|
|
}
|
|
|
|
/*!
|
|
Sets the transformation matrix of the TQCanvasView to \a wm. The
|
|
matrix must be invertible (i.e. if you create a world matrix that
|
|
zooms out by 2 times, then the inverse of this matrix is one that
|
|
will zoom in by 2 times).
|
|
|
|
When you use this, you should note that the performance of the
|
|
TQCanvasView will decrease considerably.
|
|
|
|
Returns FALSE if \a wm is not invertable; otherwise returns TRUE.
|
|
|
|
\sa worldMatrix() inverseWorldMatrix() TQWMatrix::isInvertible()
|
|
*/
|
|
bool TQCanvasView::setWorldMatrix( const TQWMatrix & wm )
|
|
{
|
|
bool ok = wm.isInvertible();
|
|
if ( ok ) {
|
|
d->xform = wm;
|
|
d->ixform = wm.invert();
|
|
updateContentsSize();
|
|
viewport()->update();
|
|
}
|
|
return ok;
|
|
}
|
|
#endif
|
|
|
|
void TQCanvasView::updateContentsSize()
|
|
{
|
|
if ( viewing ) {
|
|
TQRect br;
|
|
#ifndef QT_NO_TRANSFORMATIONS
|
|
br = d->xform.map(TQRect(0,0,viewing->width(),viewing->height()));
|
|
#else
|
|
br = TQRect(0,0,viewing->width(),viewing->height());
|
|
#endif
|
|
|
|
if ( br.width() < contentsWidth() ) {
|
|
TQRect r(contentsToViewport(TQPoint(br.width(),0)),
|
|
TQSize(contentsWidth()-br.width(),contentsHeight()));
|
|
viewport()->erase(r);
|
|
}
|
|
if ( br.height() < contentsHeight() ) {
|
|
TQRect r(contentsToViewport(TQPoint(0,br.height())),
|
|
TQSize(contentsWidth(),contentsHeight()-br.height()));
|
|
viewport()->erase(r);
|
|
}
|
|
|
|
resizeContents(br.width(),br.height());
|
|
} else {
|
|
viewport()->erase();
|
|
resizeContents(1,1);
|
|
}
|
|
}
|
|
|
|
void TQCanvasView::cMoving(int x, int y)
|
|
{
|
|
// A little kludge to smooth up repaints when scrolling
|
|
int dx = x - contentsX();
|
|
int dy = y - contentsY();
|
|
d->repaint_from_moving = TQABS(dx) < width()/8 && TQABS(dy) < height()/8;
|
|
}
|
|
|
|
/*!
|
|
Repaints part of the TQCanvas that the canvas view is showing
|
|
starting at \a cx by \a cy, with a width of \a cw and a height of \a
|
|
ch using the painter \a p.
|
|
|
|
\warning When double buffering is enabled, drawContents() will
|
|
not respect the current settings of the painter when setting up
|
|
the painter for the double buffer (e.g., viewport() and
|
|
window()). Also, be aware that TQCanvas::update() bypasses
|
|
drawContents(), which means any reimplementation of
|
|
drawContents() is not called.
|
|
|
|
\sa TQCanvas::setDoubleBuffering()
|
|
*/
|
|
void TQCanvasView::drawContents(TQPainter *p, int cx, int cy, int cw, int ch)
|
|
{
|
|
TQRect r(cx,cy,cw,ch);
|
|
if (viewing) {
|
|
//viewing->drawViewArea(this,p,r,TRUE);
|
|
viewing->drawViewArea(this,p,r,!d->repaint_from_moving);
|
|
d->repaint_from_moving = FALSE;
|
|
} else {
|
|
p->eraseRect(r);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
\internal
|
|
|
|
(Implemented to get rid of a compiler warning.)
|
|
*/
|
|
void TQCanvasView::drawContents( TQPainter * )
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Suggests a size sufficient to view the entire canvas.
|
|
*/
|
|
TQSize TQCanvasView::sizeHint() const
|
|
{
|
|
if ( !canvas() )
|
|
return TQScrollView::sizeHint();
|
|
// should maybe take transformations into account
|
|
return ( canvas()->size() + 2 * TQSize(frameWidth(), frameWidth()) )
|
|
.boundedTo( 3 * TQApplication::desktop()->size() / 4 );
|
|
}
|
|
|
|
// ### TQt 4.0 customer request: operate on doubles rather than int.
|
|
// ### I know, almost impossible due to the use of TQRegion etc.
|
|
/*!
|
|
\class TQCanvasPolygonalItem ntqcanvas.h
|
|
\brief The TQCanvasPolygonalItem class provides a polygonal canvas item
|
|
on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
The mostly rectangular classes, such as TQCanvasSprite and
|
|
TQCanvasText, use the object's bounding rectangle for movement,
|
|
repainting and collision calculations. For most other items, the
|
|
bounding rectangle can be far too large -- a diagonal line being
|
|
the worst case, and there are many other cases which are also bad.
|
|
TQCanvasPolygonalItem provides polygon-based bounding rectangle
|
|
handling, etc., which is much faster for non-rectangular items.
|
|
|
|
Derived classes should try to define as small an area as possible
|
|
to maximize efficiency, but the polygon must \e definitely be
|
|
contained completely within the polygonal area. Calculating the
|
|
exact requirements is usually difficult, but if you allow a small
|
|
overestimate it can be easy and quick, while still getting almost
|
|
all of TQCanvasPolygonalItem's speed.
|
|
|
|
Note that all subclasses \e must call hide() in their destructor
|
|
since hide() needs to be able to access areaPoints().
|
|
|
|
Normally, TQCanvasPolygonalItem uses the odd-even algorithm for
|
|
determining whether an object intersects this object. You can
|
|
change this to the winding algorithm using setWinding().
|
|
|
|
The bounding rectangle is available using boundingRect(). The
|
|
points bounding the polygonal item are retrieved with
|
|
areaPoints(). Use areaPointsAdvanced() to retrieve the bounding
|
|
points the polygonal item \e will have after
|
|
TQCanvasItem::advance(1) has been called.
|
|
|
|
If the shape of the polygonal item is about to change while the
|
|
item is visible, call invalidate() before updating with a
|
|
different result from \l areaPoints().
|
|
|
|
By default, TQCanvasPolygonalItem objects have a black pen and no
|
|
brush (the default TQPen and TQBrush constructors). You can change
|
|
this with setPen() and setBrush(), but note that some
|
|
TQCanvasPolygonalItem subclasses only use the brush, ignoring the
|
|
pen setting.
|
|
|
|
The polygonal item can be drawn on a painter with draw().
|
|
Subclasses must reimplement drawShape() to draw themselves.
|
|
|
|
Like any other canvas item polygonal items can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting coordinates
|
|
with TQCanvasItem::setX(), TQCanvasItem::setY() and TQCanvasItem::setZ().
|
|
|
|
*/
|
|
|
|
|
|
/*
|
|
Since most polygonal items don't have a pen, the default is
|
|
NoPen and a black brush.
|
|
*/
|
|
static const TQPen& defaultPolygonPen()
|
|
{
|
|
static TQPen* dp=0;
|
|
if ( !dp )
|
|
dp = new TQPen;
|
|
return *dp;
|
|
}
|
|
|
|
static const TQBrush& defaultPolygonBrush()
|
|
{
|
|
static TQBrush* db=0;
|
|
if ( !db )
|
|
db = new TQBrush;
|
|
return *db;
|
|
}
|
|
|
|
/*!
|
|
Constructs a TQCanvasPolygonalItem on the canvas \a canvas.
|
|
*/
|
|
TQCanvasPolygonalItem::TQCanvasPolygonalItem(TQCanvas* canvas) :
|
|
TQCanvasItem(canvas),
|
|
br(defaultPolygonBrush()),
|
|
pn(defaultPolygonPen())
|
|
{
|
|
wind=0;
|
|
}
|
|
|
|
/*!
|
|
Note that all subclasses \e must call hide() in their destructor
|
|
since hide() needs to be able to access areaPoints().
|
|
*/
|
|
TQCanvasPolygonalItem::~TQCanvasPolygonalItem()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the polygonal item uses the winding algorithm to
|
|
determine the "inside" of the polygon. Returns FALSE if it uses
|
|
the odd-even algorithm.
|
|
|
|
The default is to use the odd-even algorithm.
|
|
|
|
\sa setWinding()
|
|
*/
|
|
bool TQCanvasPolygonalItem::winding() const
|
|
{
|
|
return wind;
|
|
}
|
|
|
|
/*!
|
|
If \a enable is TRUE, the polygonal item will use the winding
|
|
algorithm to determine the "inside" of the polygon; otherwise the
|
|
odd-even algorithm will be used.
|
|
|
|
The default is to use the odd-even algorithm.
|
|
|
|
\sa winding()
|
|
*/
|
|
void TQCanvasPolygonalItem::setWinding(bool enable)
|
|
{
|
|
wind = enable;
|
|
}
|
|
|
|
/*!
|
|
Invalidates all information about the area covered by the canvas
|
|
item. The item will be updated automatically on the next call that
|
|
changes the item's status, for example, move() or update(). Call
|
|
this function if you are going to change the shape of the item (as
|
|
returned by areaPoints()) while the item is visible.
|
|
*/
|
|
void TQCanvasPolygonalItem::invalidate()
|
|
{
|
|
val = (uint)FALSE;
|
|
removeFromChunks();
|
|
}
|
|
|
|
/*!
|
|
\fn TQCanvasPolygonalItem::isValid() const
|
|
|
|
Returns TRUE if the polygonal item's area information has not been
|
|
invalidated; otherwise returns FALSE.
|
|
|
|
\sa invalidate()
|
|
*/
|
|
|
|
/*!
|
|
Returns the points the polygonal item \e will have after
|
|
TQCanvasItem::advance(1) is called, i.e. what the points are when
|
|
advanced by the current xVelocity() and yVelocity().
|
|
*/
|
|
TQPointArray TQCanvasPolygonalItem::areaPointsAdvanced() const
|
|
{
|
|
int dx = int(x()+xVelocity())-int(x());
|
|
int dy = int(y()+yVelocity())-int(y());
|
|
TQPointArray r = areaPoints();
|
|
r.detach(); // Explicit sharing is stupid.
|
|
if ( dx || dy )
|
|
r.translate(dx,dy);
|
|
return r;
|
|
}
|
|
|
|
//#define TQCANVAS_POLYGONS_DEBUG
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
static TQWidget* dbg_wid=0;
|
|
static TQPainter* dbg_ptr=0;
|
|
#endif
|
|
|
|
class TQPolygonalProcessor {
|
|
public:
|
|
TQPolygonalProcessor(TQCanvas* c, const TQPointArray& pa) :
|
|
canvas(c)
|
|
{
|
|
TQRect pixelbounds = pa.boundingRect();
|
|
int cs = canvas->chunkSize();
|
|
TQRect canvasbounds = pixelbounds.intersect(canvas->rect());
|
|
bounds.setLeft(canvasbounds.left()/cs);
|
|
bounds.setRight(canvasbounds.right()/cs);
|
|
bounds.setTop(canvasbounds.top()/cs);
|
|
bounds.setBottom(canvasbounds.bottom()/cs);
|
|
bitmap = TQImage(bounds.width() + 1, bounds.height(), 1, 2, TQImage::LittleEndian);
|
|
pnt = 0;
|
|
bitmap.fill(0);
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
dbg_start();
|
|
#endif
|
|
}
|
|
|
|
inline void add(int x, int y)
|
|
{
|
|
if ( pnt >= (int)result.size() ) {
|
|
result.resize(pnt*2+10);
|
|
}
|
|
result[pnt++] = TQPoint(x+bounds.x(),y+bounds.y());
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) {
|
|
int cs = canvas->chunkSize();
|
|
TQRect r(x*cs+bounds.x()*cs,y*cs+bounds.y()*cs,cs-1,cs-1);
|
|
dbg_ptr->setPen(TQt::blue);
|
|
dbg_ptr->drawRect(r);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
inline void addBits(int x1, int x2, uchar newbits, int xo, int yo)
|
|
{
|
|
for (int i=x1; i<=x2; i++)
|
|
if ( newbits & (1<<i) )
|
|
add(xo+i,yo);
|
|
}
|
|
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
void dbg_start()
|
|
{
|
|
if ( !dbg_wid ) {
|
|
dbg_wid = new TQWidget;
|
|
dbg_wid->resize(800,600);
|
|
dbg_wid->show();
|
|
dbg_ptr = new TQPainter(dbg_wid);
|
|
dbg_ptr->setBrush(TQt::NoBrush);
|
|
}
|
|
dbg_ptr->fillRect(dbg_wid->rect(),TQt::white);
|
|
}
|
|
#endif
|
|
|
|
void doSpans(int n, TQPoint* pt, int* w)
|
|
{
|
|
int cs = canvas->chunkSize();
|
|
for (int j=0; j<n; j++) {
|
|
int y = pt[j].y()/cs-bounds.y();
|
|
if (y >= bitmap.height() || y < 0) continue;
|
|
uchar* l = bitmap.scanLine(y);
|
|
int x = pt[j].x();
|
|
int x1 = x/cs-bounds.x();
|
|
if (x1 > bounds.width()) continue;
|
|
x1 = TQMAX(0,x1);
|
|
int x2 = (x+w[j])/cs-bounds.x();
|
|
if (x2 < 0) continue;
|
|
x2 = TQMIN(bounds.width(), x2);
|
|
int x1q = x1/8;
|
|
int x1r = x1%8;
|
|
int x2q = x2/8;
|
|
int x2r = x2%8;
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) dbg_ptr->setPen(TQt::yellow);
|
|
#endif
|
|
if ( x1q == x2q ) {
|
|
uchar newbits = (~l[x1q]) & (((2<<(x2r-x1r))-1)<<x1r);
|
|
if ( newbits ) {
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) dbg_ptr->setPen(TQt::darkGreen);
|
|
#endif
|
|
addBits(x1r,x2r,newbits,x1q*8,y);
|
|
l[x1q] |= newbits;
|
|
}
|
|
} else {
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) dbg_ptr->setPen(TQt::blue);
|
|
#endif
|
|
uchar newbits1 = (~l[x1q]) & (0xff<<x1r);
|
|
if ( newbits1 ) {
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) dbg_ptr->setPen(TQt::green);
|
|
#endif
|
|
addBits(x1r,7,newbits1,x1q*8,y);
|
|
l[x1q] |= newbits1;
|
|
}
|
|
for (int i=x1q+1; i<x2q; i++) {
|
|
if ( l[i] != 0xff ) {
|
|
addBits(0,7,~l[i],i*8,y);
|
|
l[i]=0xff;
|
|
}
|
|
}
|
|
uchar newbits2 = (~l[x2q]) & (0xff>>(7-x2r));
|
|
if ( newbits2 ) {
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) dbg_ptr->setPen(TQt::red);
|
|
#endif
|
|
addBits(0,x2r,newbits2,x2q*8,y);
|
|
l[x2q] |= newbits2;
|
|
}
|
|
}
|
|
#ifdef TQCANVAS_POLYGONS_DEBUG
|
|
if ( dbg_ptr ) {
|
|
dbg_ptr->drawLine(pt[j],pt[j]+TQPoint(w[j],0));
|
|
}
|
|
#endif
|
|
}
|
|
result.resize(pnt);
|
|
}
|
|
|
|
int pnt;
|
|
TQPointArray result;
|
|
TQCanvas* canvas;
|
|
TQRect bounds;
|
|
TQImage bitmap;
|
|
};
|
|
|
|
|
|
TQPointArray TQCanvasPolygonalItem::chunks() const
|
|
{
|
|
TQPointArray pa = areaPoints();
|
|
|
|
if ( !pa.size() ) {
|
|
pa.detach(); // Explicit sharing is stupid.
|
|
return pa;
|
|
}
|
|
|
|
TQPolygonalProcessor processor(canvas(),pa);
|
|
|
|
scanPolygon(pa, wind, processor);
|
|
|
|
return processor.result;
|
|
}
|
|
/*!
|
|
Simply calls TQCanvasItem::chunks().
|
|
*/
|
|
TQPointArray TQCanvasRectangle::chunks() const
|
|
{
|
|
// No need to do a polygon scan!
|
|
return TQCanvasItem::chunks();
|
|
}
|
|
|
|
/*!
|
|
Returns the bounding rectangle of the polygonal item, based on
|
|
areaPoints().
|
|
*/
|
|
TQRect TQCanvasPolygonalItem::boundingRect() const
|
|
{
|
|
return areaPoints().boundingRect();
|
|
}
|
|
|
|
/*!
|
|
Reimplemented from TQCanvasItem, this draws the polygonal item by
|
|
setting the pen and brush for the item on the painter \a p and
|
|
calling drawShape().
|
|
*/
|
|
void TQCanvasPolygonalItem::draw(TQPainter & p)
|
|
{
|
|
p.setPen(pn);
|
|
p.setBrush(br);
|
|
drawShape(p);
|
|
}
|
|
|
|
/*!
|
|
\fn void TQCanvasPolygonalItem::drawShape(TQPainter & p)
|
|
|
|
Subclasses must reimplement this function to draw their shape. The
|
|
pen and brush of \a p are already set to pen() and brush() prior
|
|
to calling this function.
|
|
|
|
\warning When you reimplement this function, make sure that you
|
|
leave the painter in the same state as you found it. For example,
|
|
if you start by calling TQPainter::translate(50, 50), end your
|
|
code by calling TQPainter::translate(-50, -50). Be also aware that
|
|
the painter might already have some transformations set (i.e.,
|
|
don't call TQPainter::resetXForm() when you're done).
|
|
|
|
\sa draw()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQPen TQCanvasPolygonalItem::pen() const
|
|
|
|
Returns the TQPen used to draw the outline of the item, if any.
|
|
|
|
\sa setPen()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQBrush TQCanvasPolygonalItem::brush() const
|
|
|
|
Returns the TQBrush used to fill the item, if filled.
|
|
|
|
\sa setBrush()
|
|
*/
|
|
|
|
/*!
|
|
Sets the TQPen used when drawing the item to the pen \a p.
|
|
Note that many TQCanvasPolygonalItems do not use the pen value.
|
|
|
|
\sa setBrush(), pen(), drawShape()
|
|
*/
|
|
void TQCanvasPolygonalItem::setPen(TQPen p)
|
|
{
|
|
if ( pn != p ) {
|
|
removeFromChunks();
|
|
pn = p;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Sets the TQBrush used when drawing the polygonal item to the brush \a b.
|
|
|
|
\sa setPen(), brush(), drawShape()
|
|
*/
|
|
void TQCanvasPolygonalItem::setBrush(TQBrush b)
|
|
{
|
|
if ( br != b) {
|
|
br = b;
|
|
changeChunks();
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\class TQCanvasPolygon ntqcanvas.h
|
|
\brief The TQCanvasPolygon class provides a polygon on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
Paints a polygon with a TQBrush. The polygon's points can be set in
|
|
the constructor or set or changed later using setPoints(). Use
|
|
points() to retrieve the points, or areaPoints() to retrieve the
|
|
points relative to the canvas's origin.
|
|
|
|
The polygon can be drawn on a painter with drawShape().
|
|
|
|
Like any other canvas item polygons can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting
|
|
coordinates with TQCanvasItem::setX(), TQCanvasItem::setY() and
|
|
TQCanvasItem::setZ().
|
|
|
|
Note: TQCanvasPolygon does not use the pen.
|
|
*/
|
|
|
|
/*!
|
|
Constructs a point-less polygon on the canvas \a canvas. You
|
|
should call setPoints() before using it further.
|
|
*/
|
|
TQCanvasPolygon::TQCanvasPolygon(TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroys the polygon.
|
|
*/
|
|
TQCanvasPolygon::~TQCanvasPolygon()
|
|
{
|
|
hide();
|
|
}
|
|
|
|
/*!
|
|
Draws the polygon using the painter \a p.
|
|
|
|
Note that TQCanvasPolygon does not support an outline (the pen is
|
|
always NoPen).
|
|
*/
|
|
void TQCanvasPolygon::drawShape(TQPainter & p)
|
|
{
|
|
// ### why can't we draw outlines? We could use drawPolyline for it. Lars
|
|
// ### see other message. Warwick
|
|
|
|
p.setPen(NoPen); // since TQRegion(TQPointArray) excludes outline :-( )-:
|
|
p.drawPolygon(poly);
|
|
}
|
|
|
|
/*!
|
|
Sets the points of the polygon to be \a pa. These points will have
|
|
their x and y coordinates automatically translated by x(), y() as
|
|
the polygon is moved.
|
|
*/
|
|
void TQCanvasPolygon::setPoints(TQPointArray pa)
|
|
{
|
|
removeFromChunks();
|
|
poly = pa;
|
|
poly.detach(); // Explicit sharing is stupid.
|
|
poly.translate((int)x(),(int)y());
|
|
addToChunks();
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQCanvasPolygon::moveBy(double dx, double dy)
|
|
{
|
|
// Note: does NOT call TQCanvasPolygonalItem::moveBy(), since that
|
|
// only does half this work.
|
|
//
|
|
int idx = int(x()+dx)-int(x());
|
|
int idy = int(y()+dy)-int(y());
|
|
if ( idx || idy ) {
|
|
removeFromChunks();
|
|
poly.translate(idx,idy);
|
|
}
|
|
myx+=dx;
|
|
myy+=dy;
|
|
if ( idx || idy ) {
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\class TQCanvasSpline ntqcanvas.h
|
|
\brief The TQCanvasSpline class provides multi-bezier splines on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A TQCanvasSpline is a sequence of 4-point bezier curves joined
|
|
together to make a curved shape.
|
|
|
|
You set the control points of the spline with setControlPoints().
|
|
|
|
If the bezier is closed(), then the first control point will be
|
|
re-used as the last control point. Therefore, a closed bezier must
|
|
have a multiple of 3 control points and an open bezier must have
|
|
one extra point.
|
|
|
|
The beziers are not necessarily joined "smoothly". To ensure this,
|
|
set control points appropriately (general reference texts about
|
|
beziers will explain this in detail).
|
|
|
|
Like any other canvas item splines can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting
|
|
coordinates with TQCanvasItem::setX(), TQCanvasItem::setY() and
|
|
TQCanvasItem::setZ().
|
|
|
|
*/
|
|
|
|
/*!
|
|
Create a spline with no control points on the canvas \a canvas.
|
|
|
|
\sa setControlPoints()
|
|
*/
|
|
TQCanvasSpline::TQCanvasSpline(TQCanvas* canvas) :
|
|
TQCanvasPolygon(canvas),
|
|
cl(TRUE)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroy the spline.
|
|
*/
|
|
TQCanvasSpline::~TQCanvasSpline()
|
|
{
|
|
}
|
|
|
|
// ### shouldn't we handle errors more gracefully than with an assert? Lars
|
|
// ### no, since it's a programming error. Warwick
|
|
/*!
|
|
Set the spline control points to \a ctrl.
|
|
|
|
If \a close is TRUE, then the first point in \a ctrl will be
|
|
re-used as the last point, and the number of control points must
|
|
be a multiple of 3. If \a close is FALSE, one additional control
|
|
point is required, and the number of control points must be one of
|
|
(4, 7, 10, 13, ...).
|
|
|
|
If the number of control points doesn't meet the above conditions,
|
|
the number of points will be truncated to the largest number of
|
|
points that do meet the requirement.
|
|
*/
|
|
void TQCanvasSpline::setControlPoints(TQPointArray ctrl, bool close)
|
|
{
|
|
if ( (int)ctrl.count() % 3 != (close ? 0 : 1) ) {
|
|
tqWarning( "TQCanvasSpline::setControlPoints(): Number of points doesn't fit." );
|
|
int numCurves = (ctrl.count() - (close ? 0 : 1 ))/ 3;
|
|
ctrl.resize( numCurves*3 + ( close ? 0 : 1 ) );
|
|
}
|
|
|
|
cl = close;
|
|
bez = ctrl;
|
|
recalcPoly();
|
|
}
|
|
|
|
/*!
|
|
Returns the current set of control points.
|
|
|
|
\sa setControlPoints(), closed()
|
|
*/
|
|
TQPointArray TQCanvasSpline::controlPoints() const
|
|
{
|
|
return bez;
|
|
}
|
|
|
|
/*!
|
|
Returns TRUE if the control points are a closed set; otherwise
|
|
returns FALSE.
|
|
*/
|
|
bool TQCanvasSpline::closed() const
|
|
{
|
|
return cl;
|
|
}
|
|
|
|
void TQCanvasSpline::recalcPoly()
|
|
{
|
|
TQPtrList<TQPointArray> segs;
|
|
segs.setAutoDelete(TRUE);
|
|
int n=0;
|
|
for (int i=0; i<(int)bez.count()-1; i+=3) {
|
|
TQPointArray ctrl(4);
|
|
ctrl[0] = bez[i+0];
|
|
ctrl[1] = bez[i+1];
|
|
ctrl[2] = bez[i+2];
|
|
if ( cl )
|
|
ctrl[3] = bez[(i+3)%(int)bez.count()];
|
|
else
|
|
ctrl[3] = bez[i+3];
|
|
TQPointArray *seg = new TQPointArray(ctrl.cubicBezier());
|
|
n += seg->count()-1;
|
|
segs.append(seg);
|
|
}
|
|
TQPointArray p(n+1);
|
|
n=0;
|
|
for (TQPointArray* seg = segs.first(); seg; seg = segs.next()) {
|
|
for (int i=0; i<(int)seg->count()-1; i++)
|
|
p[n++] = seg->point(i);
|
|
if ( n == (int)p.count()-1 )
|
|
p[n] = seg->point(seg->count()-1);
|
|
}
|
|
TQCanvasPolygon::setPoints(p);
|
|
}
|
|
|
|
/*!
|
|
\fn TQPointArray TQCanvasPolygonalItem::areaPoints() const
|
|
|
|
This function must be reimplemented by subclasses. It \e must
|
|
return the points bounding (i.e. outside and not touching) the
|
|
shape or drawing errors will occur.
|
|
*/
|
|
|
|
/*!
|
|
\fn TQPointArray TQCanvasPolygon::points() const
|
|
|
|
Returns the vertices of the polygon, not translated by the position.
|
|
|
|
\sa setPoints(), areaPoints()
|
|
*/
|
|
TQPointArray TQCanvasPolygon::points() const
|
|
{
|
|
TQPointArray pa = areaPoints();
|
|
pa.translate(int(-x()),int(-y()));
|
|
return pa;
|
|
}
|
|
|
|
/*!
|
|
Returns the vertices of the polygon translated by the polygon's
|
|
current x(), y() position, i.e. relative to the canvas's origin.
|
|
|
|
\sa setPoints(), points()
|
|
*/
|
|
TQPointArray TQCanvasPolygon::areaPoints() const
|
|
{
|
|
return poly.copy();
|
|
}
|
|
|
|
// ### mark: Why don't we offer a constructor that lets the user set the
|
|
// points -- that way for some uses just the constructor call would be
|
|
// required?
|
|
/*!
|
|
\class TQCanvasLine ntqcanvas.h
|
|
\brief The TQCanvasLine class provides a line on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
The line inherits functionality from TQCanvasPolygonalItem, for
|
|
example the setPen() function. The start and end points of the
|
|
line are set with setPoints().
|
|
|
|
Like any other canvas item lines can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting
|
|
coordinates with TQCanvasItem::setX(), TQCanvasItem::setY() and
|
|
TQCanvasItem::setZ().
|
|
*/
|
|
|
|
/*!
|
|
Constructs a line from (0,0) to (0,0) on \a canvas.
|
|
|
|
\sa setPoints().
|
|
*/
|
|
TQCanvasLine::TQCanvasLine(TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas)
|
|
{
|
|
x1 = y1 = x2 = y2 = 0;
|
|
}
|
|
|
|
/*!
|
|
Destroys the line.
|
|
*/
|
|
TQCanvasLine::~TQCanvasLine()
|
|
{
|
|
hide();
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQCanvasLine::setPen(TQPen p)
|
|
{
|
|
TQCanvasPolygonalItem::setPen(p);
|
|
}
|
|
|
|
/*!
|
|
\fn TQPoint TQCanvasLine::startPoint () const
|
|
|
|
Returns the start point of the line.
|
|
|
|
\sa setPoints(), endPoint()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQPoint TQCanvasLine::endPoint () const
|
|
|
|
Returns the end point of the line.
|
|
|
|
\sa setPoints(), startPoint()
|
|
*/
|
|
|
|
/*!
|
|
Sets the line's start point to (\a xa, \a ya) and its end point to
|
|
(\a xb, \a yb).
|
|
*/
|
|
void TQCanvasLine::setPoints(int xa, int ya, int xb, int yb)
|
|
{
|
|
if ( x1 != xa || x2 != xb || y1 != ya || y2 != yb ) {
|
|
removeFromChunks();
|
|
x1 = xa;
|
|
y1 = ya;
|
|
x2 = xb;
|
|
y2 = yb;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQCanvasLine::drawShape(TQPainter &p)
|
|
{
|
|
p.drawLine((int)(x()+x1), (int)(y()+y1), (int)(x()+x2), (int)(y()+y2));
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
|
|
Note that the area defined by the line is somewhat thicker than
|
|
the line that is actually drawn.
|
|
*/
|
|
TQPointArray TQCanvasLine::areaPoints() const
|
|
{
|
|
TQPointArray p(4);
|
|
int xi = int(x());
|
|
int yi = int(y());
|
|
int pw = pen().width();
|
|
int dx = TQABS(x1-x2);
|
|
int dy = TQABS(y1-y2);
|
|
pw = pw*4/3+2; // approx pw*sqrt(2)
|
|
int px = x1<x2 ? -pw : pw ;
|
|
int py = y1<y2 ? -pw : pw ;
|
|
if ( dx && dy && (dx > dy ? (dx*2/dy <= 2) : (dy*2/dx <= 2)) ) {
|
|
// steep
|
|
if ( px == py ) {
|
|
p[0] = TQPoint(x1+xi ,y1+yi+py);
|
|
p[1] = TQPoint(x2+xi-px,y2+yi );
|
|
p[2] = TQPoint(x2+xi ,y2+yi-py);
|
|
p[3] = TQPoint(x1+xi+px,y1+yi );
|
|
} else {
|
|
p[0] = TQPoint(x1+xi+px,y1+yi );
|
|
p[1] = TQPoint(x2+xi ,y2+yi-py);
|
|
p[2] = TQPoint(x2+xi-px,y2+yi );
|
|
p[3] = TQPoint(x1+xi ,y1+yi+py);
|
|
}
|
|
} else if ( dx > dy ) {
|
|
// horizontal
|
|
p[0] = TQPoint(x1+xi+px,y1+yi+py);
|
|
p[1] = TQPoint(x2+xi-px,y2+yi+py);
|
|
p[2] = TQPoint(x2+xi-px,y2+yi-py);
|
|
p[3] = TQPoint(x1+xi+px,y1+yi-py);
|
|
} else {
|
|
// vertical
|
|
p[0] = TQPoint(x1+xi+px,y1+yi+py);
|
|
p[1] = TQPoint(x2+xi+px,y2+yi-py);
|
|
p[2] = TQPoint(x2+xi-px,y2+yi-py);
|
|
p[3] = TQPoint(x1+xi-px,y1+yi+py);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
|
|
*/
|
|
|
|
void TQCanvasLine::moveBy(double dx, double dy)
|
|
{
|
|
TQCanvasPolygonalItem::moveBy(dx, dy);
|
|
}
|
|
|
|
/*!
|
|
\class TQCanvasRectangle ntqcanvas.h
|
|
\brief The TQCanvasRectangle class provides a rectangle on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
This item paints a single rectangle which may have any pen() and
|
|
brush(), but may not be tilted/rotated. For rotated rectangles,
|
|
use TQCanvasPolygon.
|
|
|
|
The rectangle's size and initial position can be set in the
|
|
constructor. The size can be set or changed later using setSize().
|
|
Use height() and width() to retrieve the rectangle's dimensions.
|
|
|
|
The rectangle can be drawn on a painter with drawShape().
|
|
|
|
Like any other canvas item rectangles can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting
|
|
coordinates with TQCanvasItem::setX(), TQCanvasItem::setY() and
|
|
TQCanvasItem::setZ().
|
|
|
|
*/
|
|
|
|
/*!
|
|
Constructs a rectangle at position (0,0) with both width and
|
|
height set to 32 pixels on \a canvas.
|
|
*/
|
|
TQCanvasRectangle::TQCanvasRectangle(TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(32), h(32)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Constructs a rectangle positioned and sized by \a r on \a canvas.
|
|
*/
|
|
TQCanvasRectangle::TQCanvasRectangle(const TQRect& r, TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(r.width()), h(r.height())
|
|
{
|
|
move(r.x(),r.y());
|
|
}
|
|
|
|
/*!
|
|
Constructs a rectangle at position (\a x, \a y) and size \a width
|
|
by \a height, on \a canvas.
|
|
*/
|
|
TQCanvasRectangle::TQCanvasRectangle(int x, int y, int width, int height,
|
|
TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(width), h(height)
|
|
{
|
|
move(x,y);
|
|
}
|
|
|
|
/*!
|
|
Destroys the rectangle.
|
|
*/
|
|
TQCanvasRectangle::~TQCanvasRectangle()
|
|
{
|
|
hide();
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the width of the rectangle.
|
|
*/
|
|
int TQCanvasRectangle::width() const
|
|
{
|
|
return w;
|
|
}
|
|
|
|
/*!
|
|
Returns the height of the rectangle.
|
|
*/
|
|
int TQCanvasRectangle::height() const
|
|
{
|
|
return h;
|
|
}
|
|
|
|
/*!
|
|
Sets the \a width and \a height of the rectangle.
|
|
*/
|
|
void TQCanvasRectangle::setSize(int width, int height)
|
|
{
|
|
if ( w != width || h != height ) {
|
|
removeFromChunks();
|
|
w = width;
|
|
h = height;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn TQSize TQCanvasRectangle::size() const
|
|
|
|
Returns the width() and height() of the rectangle.
|
|
|
|
\sa rect(), setSize()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQRect TQCanvasRectangle::rect() const
|
|
|
|
Returns the integer-converted x(), y() position and size() of the
|
|
rectangle as a TQRect.
|
|
*/
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQPointArray TQCanvasRectangle::areaPoints() const
|
|
{
|
|
TQPointArray pa(4);
|
|
int pw = (pen().width()+1)/2;
|
|
if ( pw < 1 ) pw = 1;
|
|
if ( pen() == NoPen ) pw = 0;
|
|
pa[0] = TQPoint((int)x()-pw,(int)y()-pw);
|
|
pa[1] = pa[0] + TQPoint(w+pw*2,0);
|
|
pa[2] = pa[1] + TQPoint(0,h+pw*2);
|
|
pa[3] = pa[0] + TQPoint(0,h+pw*2);
|
|
return pa;
|
|
}
|
|
|
|
/*!
|
|
Draws the rectangle on painter \a p.
|
|
*/
|
|
void TQCanvasRectangle::drawShape(TQPainter & p)
|
|
{
|
|
p.drawRect((int)x(), (int)y(), w, h);
|
|
}
|
|
|
|
|
|
/*!
|
|
\class TQCanvasEllipse ntqcanvas.h
|
|
\brief The TQCanvasEllipse class provides an ellipse or ellipse segment on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A canvas item that paints an ellipse or ellipse segment with a TQBrush.
|
|
The ellipse's height, width, start angle and angle length can be set
|
|
at construction time. The size can be changed at runtime with
|
|
setSize(), and the angles can be changed (if you're displaying an
|
|
ellipse segment rather than a whole ellipse) with setAngles().
|
|
|
|
Note that angles are specified in 16ths of a degree.
|
|
|
|
\target anglediagram
|
|
\img qcanvasellipse.png Ellipse
|
|
|
|
If a start angle and length angle are set then an ellipse segment
|
|
will be drawn. The start angle is the angle that goes from zero in a
|
|
counter-clockwise direction (shown in green in the diagram). The
|
|
length angle is the angle from the start angle in a
|
|
counter-clockwise direction (shown in blue in the diagram). The blue
|
|
segment is the segment of the ellipse that would be drawn. If no
|
|
start angle and length angle are specified the entire ellipse is
|
|
drawn.
|
|
|
|
The ellipse can be drawn on a painter with drawShape().
|
|
|
|
Like any other canvas item ellipses can be moved with move() and
|
|
moveBy(), or by setting coordinates with setX(), setY() and setZ().
|
|
|
|
Note: TQCanvasEllipse does not use the pen.
|
|
*/
|
|
|
|
/*!
|
|
Constructs a 32x32 ellipse, centered at (0, 0) on \a canvas.
|
|
*/
|
|
TQCanvasEllipse::TQCanvasEllipse(TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(32), h(32),
|
|
a1(0), a2(360*16)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Constructs a \a width by \a height pixel ellipse, centered at
|
|
(0, 0) on \a canvas.
|
|
*/
|
|
TQCanvasEllipse::TQCanvasEllipse(int width, int height, TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(width),h(height),
|
|
a1(0),a2(360*16)
|
|
{
|
|
}
|
|
|
|
// ### add a constructor taking degrees in float. 1/16 degrees is stupid. Lars
|
|
// ### it's how TQPainter does it, so TQCanvas does too for consistency. If it's
|
|
// ### a good idea, it should be added to TQPainter, not just to TQCanvas. Warwick
|
|
/*!
|
|
Constructs a \a width by \a height pixel ellipse, centered at
|
|
(0, 0) on \a canvas. Only a segment of the ellipse is drawn,
|
|
starting at angle \a startangle, and extending for angle \a angle
|
|
(the angle length).
|
|
|
|
Note that angles are specified in
|
|
<small><sup>1</sup>/<sub>16</sub></small>ths of a degree.
|
|
*/
|
|
TQCanvasEllipse::TQCanvasEllipse(int width, int height,
|
|
int startangle, int angle, TQCanvas* canvas) :
|
|
TQCanvasPolygonalItem(canvas),
|
|
w(width),h(height),
|
|
a1(startangle),a2(angle)
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroys the ellipse.
|
|
*/
|
|
TQCanvasEllipse::~TQCanvasEllipse()
|
|
{
|
|
hide();
|
|
}
|
|
|
|
/*!
|
|
Returns the width of the ellipse.
|
|
*/
|
|
int TQCanvasEllipse::width() const
|
|
{
|
|
return w;
|
|
}
|
|
|
|
/*!
|
|
Returns the height of the ellipse.
|
|
*/
|
|
int TQCanvasEllipse::height() const
|
|
{
|
|
return h;
|
|
}
|
|
|
|
/*!
|
|
Sets the \a width and \a height of the ellipse.
|
|
*/
|
|
void TQCanvasEllipse::setSize(int width, int height)
|
|
{
|
|
if ( w != width || h != height ) {
|
|
removeFromChunks();
|
|
w = width;
|
|
h = height;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\fn int TQCanvasEllipse::angleStart() const
|
|
|
|
Returns the start angle in 16ths of a degree. Initially
|
|
this will be 0.
|
|
|
|
\sa setAngles(), angleLength()
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvasEllipse::angleLength() const
|
|
|
|
Returns the length angle (the extent of the ellipse segment) in
|
|
16ths of a degree. Initially this will be 360 * 16 (a complete
|
|
ellipse).
|
|
|
|
\sa setAngles(), angleStart()
|
|
*/
|
|
|
|
/*!
|
|
Sets the angles for the ellipse. The start angle is \a start and
|
|
the extent of the segment is \a length (the angle length) from the
|
|
\a start. The angles are specified in 16ths of a degree. By
|
|
default the ellipse will start at 0 and have an angle length of
|
|
360 * 16 (a complete ellipse).
|
|
|
|
\sa angleStart(), angleLength()
|
|
*/
|
|
void TQCanvasEllipse::setAngles(int start, int length)
|
|
{
|
|
if ( a1 != start || a2 != length ) {
|
|
removeFromChunks();
|
|
a1 = start;
|
|
a2 = length;
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
TQPointArray TQCanvasEllipse::areaPoints() const
|
|
{
|
|
TQPointArray r;
|
|
// makeArc at 0,0, then translate so that fixed point math doesn't overflow
|
|
r.makeArc(int(x()-w/2.0+0.5)-1, int(y()-h/2.0+0.5)-1, w+3, h+3, a1, a2);
|
|
r.resize(r.size()+1);
|
|
r.setPoint(r.size()-1,int(x()),int(y()));
|
|
return r;
|
|
}
|
|
|
|
// ### support outlines! Lars
|
|
// ### TQRegion doesn't, so we cannot (try it). Warwick
|
|
/*!
|
|
Draws the ellipse, centered at x(), y() using the painter \a p.
|
|
|
|
Note that TQCanvasEllipse does not support an outline (the pen is
|
|
always NoPen).
|
|
*/
|
|
void TQCanvasEllipse::drawShape(TQPainter & p)
|
|
{
|
|
p.setPen(NoPen); // since TQRegion(TQPointArray) excludes outline :-( )-:
|
|
if ( !a1 && a2 == 360*16 ) {
|
|
p.drawEllipse(int(x()-w/2.0+0.5), int(y()-h/2.0+0.5), w, h);
|
|
} else {
|
|
p.drawPie(int(x()-w/2.0+0.5), int(y()-h/2.0+0.5), w, h, a1, a2);
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\class TQCanvasText ntqcanvas.h
|
|
\brief The TQCanvasText class provides a text object on a TQCanvas.
|
|
\if defined(commercial)
|
|
It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
|
|
\endif
|
|
|
|
\module canvas
|
|
\ingroup graphics
|
|
\ingroup images
|
|
|
|
A canvas text item has text with font, color and alignment
|
|
attributes. The text and font can be set in the constructor or set
|
|
or changed later with setText() and setFont(). The color is set
|
|
with setColor() and the alignment with setTextFlags(). The text
|
|
item's bounding rectangle is retrieved with boundingRect().
|
|
|
|
The text can be drawn on a painter with draw().
|
|
|
|
Like any other canvas item text items can be moved with
|
|
TQCanvasItem::move() and TQCanvasItem::moveBy(), or by setting
|
|
coordinates with TQCanvasItem::setX(), TQCanvasItem::setY() and
|
|
TQCanvasItem::setZ().
|
|
*/
|
|
|
|
/*!
|
|
Constructs a TQCanvasText with the text "\<text\>", on \a canvas.
|
|
*/
|
|
TQCanvasText::TQCanvasText(TQCanvas* canvas) :
|
|
TQCanvasItem(canvas),
|
|
txt("<text>"), flags(0)
|
|
{
|
|
setRect();
|
|
}
|
|
|
|
// ### add textflags to the constructor? Lars
|
|
/*!
|
|
Constructs a TQCanvasText with the text \a t, on canvas \a canvas.
|
|
*/
|
|
TQCanvasText::TQCanvasText(const TQString& t, TQCanvas* canvas) :
|
|
TQCanvasItem(canvas),
|
|
txt(t), flags(0)
|
|
{
|
|
setRect();
|
|
}
|
|
|
|
// ### see above
|
|
/*!
|
|
Constructs a TQCanvasText with the text \a t and font \a f, on the
|
|
canvas \a canvas.
|
|
*/
|
|
TQCanvasText::TQCanvasText(const TQString& t, TQFont f, TQCanvas* canvas) :
|
|
TQCanvasItem(canvas),
|
|
txt(t), flags(0),
|
|
fnt(f)
|
|
{
|
|
setRect();
|
|
}
|
|
|
|
/*!
|
|
Destroys the canvas text item.
|
|
*/
|
|
TQCanvasText::~TQCanvasText()
|
|
{
|
|
removeFromChunks();
|
|
}
|
|
|
|
/*!
|
|
Returns the bounding rectangle of the text.
|
|
*/
|
|
TQRect TQCanvasText::boundingRect() const { return brect; }
|
|
|
|
void TQCanvasText::setRect()
|
|
{
|
|
brect = TQFontMetrics(fnt).boundingRect(int(x()), int(y()), 0, 0, flags, txt);
|
|
brect.setWidth(brect.width()+1);
|
|
}
|
|
|
|
/*!
|
|
\fn int TQCanvasText::textFlags() const
|
|
|
|
Returns the currently set alignment flags.
|
|
|
|
\sa setTextFlags() TQt::AlignmentFlags
|
|
*/
|
|
|
|
|
|
/*!
|
|
Sets the alignment flags to \a f. These are a bitwise OR of the
|
|
flags available to TQPainter::drawText() -- see the
|
|
\l{TQt::AlignmentFlags}.
|
|
|
|
\sa setFont() setColor()
|
|
*/
|
|
void TQCanvasText::setTextFlags(int f)
|
|
{
|
|
if ( flags != f ) {
|
|
removeFromChunks();
|
|
flags = f;
|
|
setRect();
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the text item's text.
|
|
|
|
\sa setText()
|
|
*/
|
|
TQString TQCanvasText::text() const
|
|
{
|
|
return txt;
|
|
}
|
|
|
|
|
|
/*!
|
|
Sets the text item's text to \a t. The text may contain newlines.
|
|
|
|
\sa text(), setFont(), setColor() setTextFlags()
|
|
*/
|
|
void TQCanvasText::setText( const TQString& t )
|
|
{
|
|
if ( txt != t ) {
|
|
removeFromChunks();
|
|
txt = t;
|
|
setRect();
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the font in which the text is drawn.
|
|
|
|
\sa setFont()
|
|
*/
|
|
TQFont TQCanvasText::font() const
|
|
{
|
|
return fnt;
|
|
}
|
|
|
|
/*!
|
|
Sets the font in which the text is drawn to font \a f.
|
|
|
|
\sa font()
|
|
*/
|
|
void TQCanvasText::setFont( const TQFont& f )
|
|
{
|
|
if ( f != fnt ) {
|
|
removeFromChunks();
|
|
fnt = f;
|
|
setRect();
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Returns the color of the text.
|
|
|
|
\sa setColor()
|
|
*/
|
|
TQColor TQCanvasText::color() const
|
|
{
|
|
return col;
|
|
}
|
|
|
|
/*!
|
|
Sets the color of the text to the color \a c.
|
|
|
|
\sa color(), setFont()
|
|
*/
|
|
void TQCanvasText::setColor(const TQColor& c)
|
|
{
|
|
col=c;
|
|
changeChunks();
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQCanvasText::moveBy(double dx, double dy)
|
|
{
|
|
int idx = int(x()+dx)-int(x());
|
|
int idy = int(y()+dy)-int(y());
|
|
if ( idx || idy ) {
|
|
removeFromChunks();
|
|
}
|
|
myx+=dx;
|
|
myy+=dy;
|
|
if ( idx || idy ) {
|
|
brect.moveBy(idx,idy);
|
|
addToChunks();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Draws the text using the painter \a painter.
|
|
*/
|
|
void TQCanvasText::draw(TQPainter& painter)
|
|
{
|
|
painter.setFont(fnt);
|
|
painter.setPen(col);
|
|
painter.drawText(brect, flags, txt);
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void TQCanvasText::changeChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=brect.top()/chunksize; j<=brect.bottom()/chunksize; j++) {
|
|
for (int i=brect.left()/chunksize; i<=brect.right()/chunksize; i++) {
|
|
canvas()->setChangedChunk(i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Adds the text item to the appropriate chunks.
|
|
*/
|
|
void TQCanvasText::addToChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=brect.top()/chunksize; j<=brect.bottom()/chunksize; j++) {
|
|
for (int i=brect.left()/chunksize; i<=brect.right()/chunksize; i++) {
|
|
canvas()->addItemToChunk(this,i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Removes the text item from the appropriate chunks.
|
|
*/
|
|
void TQCanvasText::removeFromChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=brect.top()/chunksize; j<=brect.bottom()/chunksize; j++) {
|
|
for (int i=brect.left()/chunksize; i<=brect.right()/chunksize; i++) {
|
|
canvas()->removeItemFromChunk(this,i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns 0 (TQCanvasItem::Rtti_Item).
|
|
|
|
Make your derived classes return their own values for rtti(), so
|
|
that you can distinguish between objects returned by
|
|
TQCanvas::at(). You should use values greater than 1000 to allow
|
|
for extensions to this class.
|
|
|
|
Overuse of this functionality can damage it's extensibility. For
|
|
example, once you have identified a base class of a TQCanvasItem
|
|
found by TQCanvas::at(), cast it to that type and call meaningful
|
|
methods rather than acting upon the object based on its rtti
|
|
value.
|
|
|
|
For example:
|
|
|
|
\code
|
|
TQCanvasItem* item;
|
|
// Find an item, e.g. with TQCanvasItem::collisions().
|
|
...
|
|
if (item->rtti() == MySprite::RTTI ) {
|
|
MySprite* s = (MySprite*)item;
|
|
if (s->isDamagable()) s->loseHitPoints(1000);
|
|
if (s->isHot()) myself->loseHitPoints(1000);
|
|
...
|
|
}
|
|
\endcode
|
|
*/
|
|
int TQCanvasItem::rtti() const { return RTTI; }
|
|
int TQCanvasItem::RTTI = Rtti_Item;
|
|
|
|
/*!
|
|
Returns 1 (TQCanvasItem::Rtti_Sprite).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasSprite::rtti() const { return RTTI; }
|
|
int TQCanvasSprite::RTTI = Rtti_Sprite;
|
|
|
|
/*!
|
|
Returns 2 (TQCanvasItem::Rtti_PolygonalItem).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasPolygonalItem::rtti() const { return RTTI; }
|
|
int TQCanvasPolygonalItem::RTTI = Rtti_PolygonalItem;
|
|
|
|
/*!
|
|
Returns 3 (TQCanvasItem::Rtti_Text).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasText::rtti() const { return RTTI; }
|
|
int TQCanvasText::RTTI = Rtti_Text;
|
|
|
|
/*!
|
|
Returns 4 (TQCanvasItem::Rtti_Polygon).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasPolygon::rtti() const { return RTTI; }
|
|
int TQCanvasPolygon::RTTI = Rtti_Polygon;
|
|
|
|
/*!
|
|
Returns 5 (TQCanvasItem::Rtti_Rectangle).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasRectangle::rtti() const { return RTTI; }
|
|
int TQCanvasRectangle::RTTI = Rtti_Rectangle;
|
|
|
|
/*!
|
|
Returns 6 (TQCanvasItem::Rtti_Ellipse).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasEllipse::rtti() const { return RTTI; }
|
|
int TQCanvasEllipse::RTTI = Rtti_Ellipse;
|
|
|
|
/*!
|
|
Returns 7 (TQCanvasItem::Rtti_Line).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasLine::rtti() const { return RTTI; }
|
|
int TQCanvasLine::RTTI = Rtti_Line;
|
|
|
|
/*!
|
|
Returns 8 (TQCanvasItem::Rtti_Spline).
|
|
|
|
\sa TQCanvasItem::rtti()
|
|
*/
|
|
int TQCanvasSpline::rtti() const { return RTTI; }
|
|
int TQCanvasSpline::RTTI = Rtti_Spline;
|
|
|
|
/*!
|
|
Constructs a TQCanvasSprite which uses images from the
|
|
TQCanvasPixmapArray \a a.
|
|
|
|
The sprite in initially positioned at (0, 0) on \a canvas, using
|
|
frame 0.
|
|
*/
|
|
TQCanvasSprite::TQCanvasSprite(TQCanvasPixmapArray* a, TQCanvas* canvas) :
|
|
TQCanvasItem(canvas),
|
|
frm(0),
|
|
anim_val(0),
|
|
anim_state(0),
|
|
anim_type(0),
|
|
images(a)
|
|
{
|
|
}
|
|
|
|
|
|
/*!
|
|
Set the array of images used for displaying the sprite to the
|
|
TQCanvasPixmapArray \a a.
|
|
|
|
If the current frame() is larger than the number of images in \a
|
|
a, the current frame will be reset to 0.
|
|
*/
|
|
void TQCanvasSprite::setSequence(TQCanvasPixmapArray* a)
|
|
{
|
|
bool isvisible = isVisible();
|
|
if ( isvisible && images )
|
|
hide();
|
|
images = a;
|
|
if ( frm >= (int)images->count() )
|
|
frm = 0;
|
|
if ( isvisible )
|
|
show();
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Marks any chunks the sprite touches as changed.
|
|
*/
|
|
void TQCanvasSprite::changeChunks()
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
int chunksize=canvas()->chunkSize();
|
|
for (int j=topEdge()/chunksize; j<=bottomEdge()/chunksize; j++) {
|
|
for (int i=leftEdge()/chunksize; i<=rightEdge()/chunksize; i++) {
|
|
canvas()->setChangedChunk(i,j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Destroys the sprite and removes it from the canvas. Does \e not
|
|
delete the images.
|
|
*/
|
|
TQCanvasSprite::~TQCanvasSprite()
|
|
{
|
|
removeFromChunks();
|
|
}
|
|
|
|
/*!
|
|
Sets the animation frame used for displaying the sprite to \a f,
|
|
an index into the TQCanvasSprite's TQCanvasPixmapArray. The call
|
|
will be ignored if \a f is larger than frameCount() or smaller
|
|
than 0.
|
|
|
|
\sa frame() move()
|
|
*/
|
|
void TQCanvasSprite::setFrame(int f)
|
|
{
|
|
move(x(),y(),f);
|
|
}
|
|
|
|
/*!
|
|
\enum TQCanvasSprite::FrameAnimationType
|
|
|
|
This enum is used to identify the different types of frame
|
|
animation offered by TQCanvasSprite.
|
|
|
|
\value Cycle at each advance the frame number will be incremented by
|
|
1 (modulo the frame count).
|
|
\value Oscillate at each advance the frame number will be
|
|
incremented by 1 up to the frame count then decremented to by 1 to
|
|
0, repeating this sequence forever.
|
|
*/
|
|
|
|
/*!
|
|
Sets the animation characteristics for the sprite.
|
|
|
|
For \a type == \c Cycle, the frames will increase by \a step
|
|
at each advance, modulo the frameCount().
|
|
|
|
For \a type == \c Oscillate, the frames will increase by \a step
|
|
at each advance, up to the frameCount(), then decrease by \a step
|
|
back to 0, repeating forever.
|
|
|
|
The \a state parameter is for internal use.
|
|
*/
|
|
void TQCanvasSprite::setFrameAnimation(FrameAnimationType type, int step, int state)
|
|
{
|
|
anim_val = step;
|
|
anim_type = type;
|
|
anim_state = state;
|
|
setAnimated(TRUE);
|
|
}
|
|
|
|
/*!
|
|
Extends the default TQCanvasItem implementation to provide the
|
|
functionality of setFrameAnimation().
|
|
|
|
The \a phase is 0 or 1: see TQCanvasItem::advance() for details.
|
|
|
|
\sa TQCanvasItem::advance() setVelocity()
|
|
*/
|
|
void TQCanvasSprite::advance(int phase)
|
|
{
|
|
if ( phase==1 ) {
|
|
int nf = frame();
|
|
if ( anim_type == Oscillate ) {
|
|
if ( anim_state )
|
|
nf += anim_val;
|
|
else
|
|
nf -= anim_val;
|
|
if ( nf < 0 ) {
|
|
nf = abs(anim_val);
|
|
anim_state = !anim_state;
|
|
} else if ( nf >= frameCount() ) {
|
|
nf = frameCount()-1-abs(anim_val);
|
|
anim_state = !anim_state;
|
|
}
|
|
} else {
|
|
nf = (nf + anim_val + frameCount()) % frameCount();
|
|
}
|
|
move(x()+xVelocity(),y()+yVelocity(),nf);
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn int TQCanvasSprite::frame() const
|
|
|
|
Returns the index of the current animation frame in the
|
|
TQCanvasSprite's TQCanvasPixmapArray.
|
|
|
|
\sa setFrame(), move()
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQCanvasSprite::frameCount() const
|
|
|
|
Returns the number of frames in the TQCanvasSprite's
|
|
TQCanvasPixmapArray.
|
|
*/
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
\internal
|
|
Moves the sprite to the position \a x, \a y.
|
|
Keep it visible.
|
|
*/
|
|
void TQCanvasSprite::move(double x, double y) { TQCanvasItem::move(x,y); }
|
|
|
|
/*!
|
|
\fn void TQCanvasSprite::move(double nx, double ny, int nf)
|
|
|
|
Set the position of the sprite to \a nx, \a ny and the current
|
|
frame to \a nf. \a nf will be ignored if it is larger than
|
|
frameCount() or smaller than 0.
|
|
*/
|
|
void TQCanvasSprite::move(double nx, double ny, int nf)
|
|
{
|
|
if (isVisible() && canvas()) {
|
|
hide();
|
|
TQCanvasItem::move(nx,ny);
|
|
if ( nf >= 0 && nf < frameCount() )
|
|
frm=nf;
|
|
show();
|
|
} else {
|
|
TQCanvasItem::move(nx,ny);
|
|
if ( nf >= 0 && nf < frameCount() )
|
|
frm=nf;
|
|
}
|
|
}
|
|
|
|
class TQCanvasPolygonScanner : public TQPolygonScanner {
|
|
TQPolygonalProcessor& processor;
|
|
public:
|
|
TQCanvasPolygonScanner(TQPolygonalProcessor& p) :
|
|
processor(p)
|
|
{
|
|
}
|
|
void processSpans( int n, TQPoint* point, int* width )
|
|
{
|
|
processor.doSpans(n,point,width);
|
|
}
|
|
};
|
|
|
|
void TQCanvasPolygonalItem::scanPolygon(const TQPointArray& pa, int winding, TQPolygonalProcessor& process) const
|
|
{
|
|
TQCanvasPolygonScanner scanner(process);
|
|
scanner.scan(pa,winding);
|
|
}
|
|
|
|
|
|
#endif // QT_NO_CANVAS
|