Initial TQt conversion

1 files changed, 282 insertions, 282 deletions

diff --git a/kjsembed/tools/headers/qcanvas.h b/kjsembed/tools/headers/qcanvas.h
index 8eb70959..b89fd795 100644
--- a/kjsembed/tools/headers/qcanvas.h
+++ b/kjsembed/tools/headers/qcanvas.h
@@ -1,7 +1,7 @@
 /**********************************************************************
 ** 
 **
-** Definition of TQCanvas classes
+** Definition of TTQCanvas classes
 **
 ** Created : 991211
 **
@@ -11,7 +11,7 @@
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
-** LICENSE.QPL included in the packaging of this file.
+** LICENSE.TQPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
@@ -27,7 +27,7 @@
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
-** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/qpl/ for TQPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
@@ -35,8 +35,8 @@
 **
 **********************************************************************/
 
-#ifndef QCANVAS_H
-#define QCANVAS_H
+#ifndef TQCANVAS_H
+#define TQCANVAS_H
 
 #ifndef QT_H
 #include "tqscrollview.h"
@@ -49,44 +49,44 @@
 #endif // QT_H
 
 #if !defined( QT_MODULE_CANVAS ) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_CANVAS )
-#define QM_EXPORT_CANVAS
-#define QM_TEMPLATE_EXTERN_CANVAS
+#define TQM_EXPORT_CANVAS
+#define TQM_TEMPLATE_EXTERN_CANVAS
 #else
-#define QM_EXPORT_CANVAS Q_EXPORT
-#define QM_TEMPLATE_EXTERN_CANVAS Q_TEMPLATE_EXTERN
+#define TQM_EXPORT_CANVAS Q_EXPORT
+#define TQM_TEMPLATE_EXTERN_CANVAS Q_TEMPLATE_EXTERN
 #endif
 
 #ifndef QT_NO_CANVAS
 
 
-class TQCanvasSprite;
-class TQCanvasPolygonalItem;
-class TQCanvasRectangle;
-class TQCanvasPolygon;
-class TQCanvasEllipse;
-class TQCanvasText;
-class TQCanvasLine;
-class TQCanvasChunk;
-class TQCanvas;
-class TQCanvasItem;
-class TQCanvasView;
-class TQCanvasPixmap;
+class TTQCanvasSprite;
+class TTQCanvasPolygonalItem;
+class TTQCanvasRectangle;
+class TTQCanvasPolygon;
+class TTQCanvasEllipse;
+class TTQCanvasText;
+class TTQCanvasLine;
+class TTQCanvasChunk;
+class TTQCanvas;
+class TTQCanvasItem;
+class TTQCanvasView;
+class TTQCanvasPixmap;
 
 
-class QM_EXPORT_CANVAS TQCanvasItemList : public TQValueList<TQCanvasItem*> {
+class TQM_EXPORT_CANVAS TTQCanvasItemList : public TTQValueList<TTQCanvasItem*> {
 public:
     void sort();
-    void drawUnique( TQPainter& painter );
+    void drawUnique( TTQPainter& painter );
 };
 
 
-class TQCanvasItemExtra;
+class TTQCanvasItemExtra;
 
-class QM_EXPORT_CANVAS TQCanvasItem : public Qt
+class TQM_EXPORT_CANVAS TTQCanvasItem : public Qt
 {
 public:
-    TQCanvasItem(TQCanvas* canvas);
-    virtual ~TQCanvasItem();
+    TTQCanvasItem(TTQCanvas* canvas);
+    virtual ~TTQCanvasItem();
 
     double x() const
 	{ return myx; }
@@ -110,13 +110,13 @@ public:
     double yVelocity() const;
     virtual void advance(int stage);
 
-    virtual bool collidesWith( const TQCanvasItem* ) const=0;
+    virtual bool collidesWith( const TTQCanvasItem* ) const=0;
 
-    TQCanvasItemList collisions(bool exact /* NO DEFAULT */ ) const;
+    TTQCanvasItemList collisions(bool exact /* NO DEFAULT */ ) const;
 
-    virtual void setCanvas(TQCanvas*);
+    virtual void setCanvas(TTQCanvas*);
 
-    virtual void draw(TQPainter&)=0;
+    virtual void draw(TTQPainter&)=0;
 
     void show();
     void hide();
@@ -159,10 +159,10 @@ public:
     virtual int rtti() const;
     static int RTTI;
 
-    virtual TQRect boundingRect() const=0;
-    virtual TQRect boundingRectAdvanced() const;
+    virtual TTQRect boundingRect() const=0;
+    virtual TTQRect boundingRectAdvanced() const;
 
-    TQCanvas* canvas() const
+    TTQCanvas* canvas() const
 	{ return cnv; }
 
 protected:
@@ -171,30 +171,30 @@ protected:
 private:
     // For friendly subclasses...
 
-    friend class TQCanvasPolygonalItem;
-    friend class TQCanvasSprite;
-    friend class TQCanvasRectangle;
-    friend class TQCanvasPolygon;
-    friend class TQCanvasEllipse;
-    friend class TQCanvasText;
-    friend class TQCanvasLine;
+    friend class TTQCanvasPolygonalItem;
+    friend class TTQCanvasSprite;
+    friend class TTQCanvasRectangle;
+    friend class TTQCanvasPolygon;
+    friend class TTQCanvasEllipse;
+    friend class TTQCanvasText;
+    friend class TTQCanvasLine;
 
-    virtual TQPointArray chunks() const;
+    virtual TTQPointArray chunks() const;
     virtual void addToChunks();
     virtual void removeFromChunks();
     virtual void changeChunks();
-    virtual bool collidesWith( const TQCanvasSprite*,
-			       const TQCanvasPolygonalItem*,
-			       const TQCanvasRectangle*,
-			       const TQCanvasEllipse*,
-			       const TQCanvasText* ) const = 0;
+    virtual bool collidesWith( const TTQCanvasSprite*,
+			       const TTQCanvasPolygonalItem*,
+			       const TTQCanvasRectangle*,
+			       const TTQCanvasEllipse*,
+			       const TTQCanvasText* ) const = 0;
     // End of friend stuff
 
-    TQCanvas* cnv;
-    static TQCanvas* current_canvas;
+    TTQCanvas* cnv;
+    static TTQCanvas* current_canvas;
     double myx,myy,myz;
-    TQCanvasItemExtra *ext;
-    TQCanvasItemExtra& extra();
+    TTQCanvasItemExtra *ext;
+    TTQCanvasItemExtra& extra();
     uint ani:1;
     uint vis:1;
     uint val:1;
@@ -204,25 +204,25 @@ private:
 };
 
 
-class TQCanvasData;
+class TTQCanvasData;
 
-class QM_EXPORT_CANVAS TQCanvas : public QObject
+class TQM_EXPORT_CANVAS TTQCanvas : public TQObject
 {
     Q_OBJECT
 public:
-    TQCanvas( TQObject* parent = 0, const char* name = 0 );
-    TQCanvas(int w, int h);
-    TQCanvas( TQPixmap p, int h, int v, int tilewidth, int tileheight );
+    TTQCanvas( TTQObject* parent = 0, const char* name = 0 );
+    TTQCanvas(int w, int h);
+    TTQCanvas( TTQPixmap p, int h, int v, int tilewidth, int tileheight );
 
-    virtual ~TQCanvas();
+    virtual ~TTQCanvas();
 
-    virtual void setTiles( TQPixmap tiles, int h, int v,
+    virtual void setTiles( TTQPixmap tiles, int h, int v,
 			   int tilewidth, int tileheight );
-    virtual void setBackgroundPixmap( const TQPixmap& p );
-    TQPixmap backgroundPixmap() const;
+    virtual void setBackgroundPixmap( const TTQPixmap& p );
+    TTQPixmap backgroundPixmap() const;
 
-    virtual void setBackgroundColor( const TQColor& c );
-    TQColor backgroundColor() const;
+    virtual void setBackgroundColor( const TTQColor& c );
+    TTQColor backgroundColor() const;
 
     virtual void setTile( int x, int y, int tilenum );
     int tile( int x, int y ) const
@@ -243,17 +243,17 @@ public:
 	{ return awidth; }
     int height() const
 	{ return aheight; }
-    TQSize size() const
-	{ return TQSize(awidth,aheight); }
-    TQRect rect() const
-	{ return TQRect( 0, 0, awidth, aheight ); }
+    TTQSize size() const
+	{ return TTQSize(awidth,aheight); }
+    TTQRect rect() const
+	{ return TTQRect( 0, 0, awidth, aheight ); }
     bool onCanvas( int x, int y ) const
 	{ return x>=0 && y>=0 && x<awidth && y<aheight; }
-    bool onCanvas( const TQPoint& p ) const
+    bool onCanvas( const TTQPoint& p ) const
 	{ return onCanvas(p.x(),p.y()); }
     bool validChunk( int x, int y ) const
 	{ return x>=0 && y>=0 && x<chwidth && y<chheight; }
-    bool validChunk( const TQPoint& p ) const
+    bool validChunk( const TTQPoint& p ) const
 	{ return validChunk(p.x(),p.y()); }
 
     int chunkSize() const
@@ -265,34 +265,34 @@ public:
     virtual void setChangedChunk(int i, int j);
     virtual void setChangedChunkContaining(int x, int y);
     virtual void setAllChanged();
-    virtual void setChanged(const TQRect& area);
-    virtual void setUnchanged(const TQRect& area);
+    virtual void setChanged(const TTQRect& area);
+    virtual void setUnchanged(const TTQRect& area);
 
     // These call setChangedChunk.
-    void addItemToChunk(TQCanvasItem*, int i, int j);
-    void removeItemFromChunk(TQCanvasItem*, int i, int j);
-    void addItemToChunkContaining(TQCanvasItem*, int x, int y);
-    void removeItemFromChunkContaining(TQCanvasItem*, int x, int y);
-
-    TQCanvasItemList allItems();
-    TQCanvasItemList collisions( const TQPoint&) const;
-    TQCanvasItemList collisions( const TQRect&) const;
-    TQCanvasItemList collisions( const TQPointArray& pa, const TQCanvasItem* item,
+    void addItemToChunk(TTQCanvasItem*, int i, int j);
+    void removeItemFromChunk(TTQCanvasItem*, int i, int j);
+    void addItemToChunkContaining(TTQCanvasItem*, int x, int y);
+    void removeItemFromChunkContaining(TTQCanvasItem*, int x, int y);
+
+    TTQCanvasItemList allItems();
+    TTQCanvasItemList collisions( const TTQPoint&) const;
+    TTQCanvasItemList collisions( const TTQRect&) const;
+    TTQCanvasItemList collisions( const TTQPointArray& pa, const TTQCanvasItem* item,
 				bool exact) const;
 
-    void drawArea(const TQRect&, TQPainter* p, bool double_buffer=FALSE);
+    void drawArea(const TTQRect&, TTQPainter* p, bool double_buffer=FALSE);
 
-    // These are for TQCanvasView to call
-    virtual void addView(TQCanvasView*);
-    virtual void removeView(TQCanvasView*);
-    void drawCanvasArea(const TQRect&, TQPainter* p=0, bool double_buffer=TRUE);
-    void drawViewArea( TQCanvasView* view, TQPainter* p, const TQRect& r, bool dbuf );
+    // These are for TTQCanvasView to call
+    virtual void addView(TTQCanvasView*);
+    virtual void removeView(TTQCanvasView*);
+    void drawCanvasArea(const TTQRect&, TTQPainter* p=0, bool double_buffer=TRUE);
+    void drawViewArea( TTQCanvasView* view, TTQPainter* p, const TTQRect& r, bool dbuf );
 
-    // These are for TQCanvasItem to call
-    virtual void addItem(TQCanvasItem*);
-    virtual void addAnimation(TQCanvasItem*);
-    virtual void removeItem(TQCanvasItem*);
-    virtual void removeAnimation(TQCanvasItem*);
+    // These are for TTQCanvasItem to call
+    virtual void addItem(TTQCanvasItem*);
+    virtual void addAnimation(TTQCanvasItem*);
+    virtual void removeItem(TTQCanvasItem*);
+    virtual void removeAnimation(TTQCanvasItem*);
 
     virtual void setAdvancePeriod(int ms);
     virtual void setUpdatePeriod(int ms);
@@ -307,77 +307,77 @@ public slots:
     virtual void update();
 
 protected:
-    virtual void drawBackground(TQPainter&, const TQRect& area);
-    virtual void drawForeground(TQPainter&, const TQRect& area);
+    virtual void drawBackground(TTQPainter&, const TTQRect& area);
+    virtual void drawForeground(TTQPainter&, const TTQRect& area);
 
 private:
     void init(int w, int h, int chunksze=16, int maxclust=100);
 
-    TQCanvasChunk& chunk(int i, int j) const;
-    TQCanvasChunk& chunkContaining(int x, int y) const;
+    TTQCanvasChunk& chunk(int i, int j) const;
+    TTQCanvasChunk& chunkContaining(int x, int y) const;
 
-    TQRect changeBounds(const TQRect& inarea);
-    void drawChanges(const TQRect& inarea);
+    TTQRect changeBounds(const TTQRect& inarea);
+    void drawChanges(const TTQRect& inarea);
 
     void ensureOffScrSize( int osw, int osh );
-    TQPixmap offscr;
+    TTQPixmap offscr;
     int awidth,aheight;
     int chunksize;
     int maxclusters;
     int chwidth,chheight;
-    TQCanvasChunk* chunks;
+    TTQCanvasChunk* chunks;
 
-    TQCanvasData* d;
+    TTQCanvasData* d;
 
-    void initTiles(TQPixmap p, int h, int v, int tilewidth, int tileheight);
+    void initTiles(TTQPixmap p, int h, int v, int tilewidth, int tileheight);
     ushort *grid;
     ushort htiles;
     ushort vtiles;
     ushort tilew;
     ushort tileh;
     bool oneone;
-    TQPixmap pm;
-    TQTimer* update_timer;
-    TQColor bgcolor;
+    TTQPixmap pm;
+    TTQTimer* update_timer;
+    TTQColor bgcolor;
     bool debug_redraw_areas;
     bool dblbuf;
 
-    friend void qt_unview(TQCanvas* c);
+    friend void qt_unview(TTQCanvas* c);
 
 #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator=
-    TQCanvas( const TQCanvas & );
-    TQCanvas &operator=( const TQCanvas & );
+    TTQCanvas( const TTQCanvas & );
+    TTQCanvas &operator=( const TTQCanvas & );
 #endif
 };
 
-class TQCanvasViewData;
+class TTQCanvasViewData;
 
-class QM_EXPORT_CANVAS TQCanvasView : public QScrollView
+class TQM_EXPORT_CANVAS TTQCanvasView : public TQScrollView
 {
     Q_OBJECT
 public:
 
-    TQCanvasView(TQWidget* parent=0, const char* name=0, WFlags f=0);
-    TQCanvasView(TQCanvas* viewing, TQWidget* parent=0, const char* name=0, WFlags f=0);
-    ~TQCanvasView();
+    TTQCanvasView(TTQWidget* parent=0, const char* name=0, WFlags f=0);
+    TTQCanvasView(TTQCanvas* viewing, TTQWidget* parent=0, const char* name=0, WFlags f=0);
+    ~TTQCanvasView();
 
-    TQCanvas* canvas() const
+    TTQCanvas* canvas() const
 	{ return viewing; }
-    void setCanvas(TQCanvas* v);
+    void setCanvas(TTQCanvas* v);
 
-    const TQWMatrix &worldMatrix() const;
-    const TQWMatrix &inverseWorldMatrix() const;
-    bool setWorldMatrix( const TQWMatrix & );
+    const TTQWMatrix &worldMatrix() const;
+    const TTQWMatrix &inverseWorldMatrix() const;
+    bool setWorldMatrix( const TTQWMatrix & );
 
 protected:
-    void drawContents( TQPainter*, int cx, int cy, int cw, int ch );
-    TQSize sizeHint() const;
+    void drawContents( TTQPainter*, int cx, int cy, int cw, int ch );
+    TTQSize sizeHint() const;
 
 private:
-    void drawContents( TQPainter* );
-    TQCanvas* viewing;
-    TQCanvasViewData* d;
-    friend void qt_unview(TQCanvas* c);
+    void drawContents( TTQPainter* );
+    TTQCanvas* viewing;
+    TTQCanvasViewData* d;
+    friend void qt_unview(TTQCanvas* c);
 
 private slots:
     void cMoving(int,int);
@@ -385,21 +385,21 @@ private slots:
 
 private:
 #if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator=
-    TQCanvasView( const TQCanvasView & );
-    TQCanvasView &operator=( const TQCanvasView & );
+    TTQCanvasView( const TTQCanvasView & );
+    TTQCanvasView &operator=( const TTQCanvasView & );
 #endif
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasPixmap : public QPixmap
+class TQM_EXPORT_CANVAS TTQCanvasPixmap : public TQPixmap
 {
 public:
 #ifndef QT_NO_IMAGEIO
-    TQCanvasPixmap(const TQString& datafilename);
+    TTQCanvasPixmap(const TTQString& datafilename);
 #endif
-    TQCanvasPixmap(const TQImage& image);
-    TQCanvasPixmap(const TQPixmap&, const TQPoint& hotspot);
-    ~TQCanvasPixmap();
+    TTQCanvasPixmap(const TTQImage& image);
+    TTQCanvasPixmap(const TTQPixmap&, const TTQPoint& hotspot);
+    ~TTQCanvasPixmap();
 
     int offsetX() const
 	{ return hotx; }
@@ -409,73 +409,73 @@ public:
 
 private:
 #if defined(Q_DISABLE_COPY)
-    TQCanvasPixmap( const TQCanvasPixmap & );
-    TQCanvasPixmap &operator=( const TQCanvasPixmap & );
+    TTQCanvasPixmap( const TTQCanvasPixmap & );
+    TTQCanvasPixmap &operator=( const TTQCanvasPixmap & );
 #endif
-    void init(const TQImage&);
-    void init(const TQPixmap& pixmap, int hx, int hy);
+    void init(const TTQImage&);
+    void init(const TTQPixmap& pixmap, int hx, int hy);
 
-    friend class TQCanvasSprite;
-    friend class TQCanvasPixmapArray;
-    friend bool qt_testCollision(const TQCanvasSprite* s1, const TQCanvasSprite* s2);
+    friend class TTQCanvasSprite;
+    friend class TTQCanvasPixmapArray;
+    friend bool qt_testCollision(const TTQCanvasSprite* s1, const TTQCanvasSprite* s2);
 
     int hotx,hoty;
 
-    TQImage* collision_mask;
+    TTQImage* collision_mask;
 };
 
 
-class QM_EXPORT_CANVAS QCanvasPixmapArray
+class TQM_EXPORT_CANVAS TQCanvasPixmapArray
 {
 public:
-    TQCanvasPixmapArray();
+    TTQCanvasPixmapArray();
 #ifndef QT_NO_IMAGEIO
-    TQCanvasPixmapArray(const TQString& datafilenamepattern, int framecount=0);
+    TTQCanvasPixmapArray(const TTQString& datafilenamepattern, int framecount=0);
 #endif
     // this form is deprecated
-    TQCanvasPixmapArray(TQPtrList<TQPixmap>, TQPtrList<TQPoint> hotspots);
+    TTQCanvasPixmapArray(TTQPtrList<TTQPixmap>, TTQPtrList<TTQPoint> hotspots);
 
-    TQCanvasPixmapArray(TQValueList<TQPixmap>, TQPointArray hotspots = TQPointArray() );
-    ~TQCanvasPixmapArray();
+    TTQCanvasPixmapArray(TTQValueList<TTQPixmap>, TTQPointArray hotspots = TTQPointArray() );
+    ~TTQCanvasPixmapArray();
 
 #ifndef QT_NO_IMAGEIO
-    bool readPixmaps(const TQString& datafilenamepattern, int framecount=0);
-    bool readCollisionMasks(const TQString& filenamepattern);
+    bool readPixmaps(const TTQString& datafilenamepattern, int framecount=0);
+    bool readCollisionMasks(const TTQString& filenamepattern);
 #endif
 
     // deprecated
     bool operator!(); // Failure check.
     bool isValid() const;
 
-    TQCanvasPixmap* image(int i) const
+    TTQCanvasPixmap* image(int i) const
 	{ return img ? img[i] : 0; }
-    void setImage(int i, TQCanvasPixmap* p);
+    void setImage(int i, TTQCanvasPixmap* p);
     uint count() const
 	{ return (uint)framecount; }
 
 private:
 #if defined(Q_DISABLE_COPY)
-    TQCanvasPixmapArray( const TQCanvasPixmapArray & );
-    TQCanvasPixmapArray &operator=( const TQCanvasPixmapArray & );
+    TTQCanvasPixmapArray( const TTQCanvasPixmapArray & );
+    TTQCanvasPixmapArray &operator=( const TTQCanvasPixmapArray & );
 #endif
 #ifndef QT_NO_IMAGEIO
-    bool readPixmaps(const TQString& datafilenamepattern, int framecount, bool maskonly);
+    bool readPixmaps(const TTQString& datafilenamepattern, int framecount, bool maskonly);
 #endif
 
     void reset();
     int framecount;
-    TQCanvasPixmap** img;
+    TTQCanvasPixmap** img;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasSprite : public QCanvasItem
+class TQM_EXPORT_CANVAS TTQCanvasSprite : public TQCanvasItem
 {
 public:
-    TQCanvasSprite(TQCanvasPixmapArray* array, TQCanvas* canvas);
+    TTQCanvasSprite(TTQCanvasPixmapArray* array, TTQCanvas* canvas);
 
-    void setSequence(TQCanvasPixmapArray* seq);
+    void setSequence(TTQCanvasPixmapArray* seq);
 
-    virtual ~TQCanvasSprite();
+    virtual ~TTQCanvasSprite();
 
     void move(double x, double y);
     virtual void move(double x, double y, int frame);
@@ -490,9 +490,9 @@ public:
     int rtti() const;
     static int RTTI;
 
-    bool collidesWith( const TQCanvasItem* ) const;
+    bool collidesWith( const TTQCanvasItem* ) const;
 
-    TQRect boundingRect() const;
+    TTQRect boundingRect() const;
 
     // is there a reason for these to be protected? Lars
 //protected:
@@ -509,20 +509,20 @@ public:
     int topEdge(int ny) const;
     int rightEdge(int nx) const;
     int bottomEdge(int ny) const;
-    TQCanvasPixmap* image() const
+    TTQCanvasPixmap* image() const
 	{ return images->image(frm); }
-    virtual TQCanvasPixmap* imageAdvanced() const;
-    TQCanvasPixmap* image(int f) const
+    virtual TTQCanvasPixmap* imageAdvanced() const;
+    TTQCanvasPixmap* image(int f) const
 	{ return images->image(f); }
     virtual void advance(int stage);
 
 public:
-    void draw(TQPainter& painter);
+    void draw(TTQPainter& painter);
 
 private:
 #if defined(Q_DISABLE_COPY)
-    TQCanvasSprite( const TQCanvasSprite & );
-    TQCanvasSprite &operator=( const TQCanvasSprite & );
+    TTQCanvasSprite( const TTQCanvasSprite & );
+    TTQCanvasSprite &operator=( const TTQCanvasSprite & );
 #endif
     void addToChunks();
     void removeFromChunks();
@@ -532,46 +532,46 @@ private:
     ushort anim_val;
     uint anim_state:2;
     uint anim_type:14;
-    bool collidesWith( const TQCanvasSprite*,
-		       const TQCanvasPolygonalItem*,
-		       const TQCanvasRectangle*,
-		       const TQCanvasEllipse*,
-		       const TQCanvasText* ) const;
+    bool collidesWith( const TTQCanvasSprite*,
+		       const TTQCanvasPolygonalItem*,
+		       const TTQCanvasRectangle*,
+		       const TTQCanvasEllipse*,
+		       const TTQCanvasText* ) const;
 
-    friend bool qt_testCollision( const TQCanvasSprite* s1,
-				  const TQCanvasSprite* s2 );
+    friend bool qt_testCollision( const TTQCanvasSprite* s1,
+				  const TTQCanvasSprite* s2 );
 
-    TQCanvasPixmapArray* images;
+    TTQCanvasPixmapArray* images;
 };
 
-class TQPolygonalProcessor;
+class TTQPolygonalProcessor;
 
-class QM_EXPORT_CANVAS TQCanvasPolygonalItem : public QCanvasItem
+class TQM_EXPORT_CANVAS TTQCanvasPolygonalItem : public TQCanvasItem
 {
 public:
-    TQCanvasPolygonalItem(TQCanvas* canvas);
-    virtual ~TQCanvasPolygonalItem();
+    TTQCanvasPolygonalItem(TTQCanvas* canvas);
+    virtual ~TTQCanvasPolygonalItem();
 
-    bool collidesWith( const TQCanvasItem* ) const;
+    bool collidesWith( const TTQCanvasItem* ) const;
 
-    virtual void setPen(TQPen p);
-    virtual void setBrush(TQBrush b);
+    virtual void setPen(TTQPen p);
+    virtual void setBrush(TTQBrush b);
 
-    TQPen pen() const
+    TTQPen pen() const
 	{ return pn; }
-    TQBrush brush() const
+    TTQBrush brush() const
 	{ return br; }
 
-    virtual TQPointArray areaPoints() const=0;
-    virtual TQPointArray areaPointsAdvanced() const;
-    TQRect boundingRect() const;
+    virtual TTQPointArray areaPoints() const=0;
+    virtual TTQPointArray areaPointsAdvanced() const;
+    TTQRect boundingRect() const;
 
     int rtti() const;
     static int RTTI;
 
 protected:
-    void draw(TQPainter &);
-    virtual void drawShape(TQPainter &) = 0;
+    void draw(TTQPainter &);
+    virtual void drawShape(TTQPainter &) = 0;
 
     bool winding() const;
     void setWinding(bool);
@@ -581,88 +581,88 @@ protected:
 	{ return (bool)val; }
 
 private:
-    void scanPolygon( const TQPointArray& pa, int winding,
-		      TQPolygonalProcessor& process ) const;
-    TQPointArray chunks() const;
-
-    bool collidesWith( const TQCanvasSprite*,
-		       const TQCanvasPolygonalItem*,
-		       const TQCanvasRectangle*,
-		       const TQCanvasEllipse*,
-		       const TQCanvasText* ) const;
-
-    TQBrush br;
-    TQPen pn;
+    void scanPolygon( const TTQPointArray& pa, int winding,
+		      TTQPolygonalProcessor& process ) const;
+    TTQPointArray chunks() const;
+
+    bool collidesWith( const TTQCanvasSprite*,
+		       const TTQCanvasPolygonalItem*,
+		       const TTQCanvasRectangle*,
+		       const TTQCanvasEllipse*,
+		       const TTQCanvasText* ) const;
+
+    TTQBrush br;
+    TTQPen pn;
     uint wind:1;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasRectangle : public QCanvasPolygonalItem
+class TQM_EXPORT_CANVAS TTQCanvasRectangle : public TQCanvasPolygonalItem
 {
 public:
-    TQCanvasRectangle(TQCanvas* canvas);
-    TQCanvasRectangle(const TQRect&, TQCanvas* canvas);
-    TQCanvasRectangle(int x, int y, int width, int height, TQCanvas* canvas);
+    TTQCanvasRectangle(TTQCanvas* canvas);
+    TTQCanvasRectangle(const TTQRect&, TTQCanvas* canvas);
+    TTQCanvasRectangle(int x, int y, int width, int height, TTQCanvas* canvas);
 
-    ~TQCanvasRectangle();
+    ~TTQCanvasRectangle();
 
     int width() const;
     int height() const;
     void setSize(int w, int h);
-    TQSize size() const
-	{ return TQSize(w,h); }
-    TQPointArray areaPoints() const;
-    TQRect rect() const
-	{ return TQRect(int(x()),int(y()),w,h); }
+    TTQSize size() const
+	{ return TTQSize(w,h); }
+    TTQPointArray areaPoints() const;
+    TTQRect rect() const
+	{ return TTQRect(int(x()),int(y()),w,h); }
 
-    bool collidesWith( const TQCanvasItem* ) const;
+    bool collidesWith( const TTQCanvasItem* ) const;
 
     int rtti() const;
     static int RTTI;
 
 protected:
-    void drawShape(TQPainter &);
-    TQPointArray chunks() const;
+    void drawShape(TTQPainter &);
+    TTQPointArray chunks() const;
 
 private:
-    bool collidesWith(   const TQCanvasSprite*,
-			 const TQCanvasPolygonalItem*,
-			 const TQCanvasRectangle*,
-			 const TQCanvasEllipse*,
-			 const TQCanvasText* ) const;
+    bool collidesWith(   const TTQCanvasSprite*,
+			 const TTQCanvasPolygonalItem*,
+			 const TTQCanvasRectangle*,
+			 const TTQCanvasEllipse*,
+			 const TTQCanvasText* ) const;
 
     int w, h;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasPolygon : public QCanvasPolygonalItem
+class TQM_EXPORT_CANVAS TTQCanvasPolygon : public TQCanvasPolygonalItem
 {
 public:
-    TQCanvasPolygon(TQCanvas* canvas);
-    ~TQCanvasPolygon();
-    void setPoints(TQPointArray);
-    TQPointArray points() const;
+    TTQCanvasPolygon(TTQCanvas* canvas);
+    ~TTQCanvasPolygon();
+    void setPoints(TTQPointArray);
+    TTQPointArray points() const;
     void moveBy(double dx, double dy);
 
-    TQPointArray areaPoints() const;
+    TTQPointArray areaPoints() const;
 
     int rtti() const;
     static int RTTI;
 
 protected:
-    void drawShape(TQPainter &);
-    TQPointArray poly;
+    void drawShape(TTQPainter &);
+    TTQPointArray poly;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasSpline : public QCanvasPolygon
+class TQM_EXPORT_CANVAS TTQCanvasSpline : public TQCanvasPolygon
 {
 public:
-    TQCanvasSpline(TQCanvas* canvas);
-    ~TQCanvasSpline();
+    TTQCanvasSpline(TTQCanvas* canvas);
+    ~TTQCanvasSpline();
 
-    void setControlPoints(TQPointArray, bool closed=TRUE);
-    TQPointArray controlPoints() const;
+    void setControlPoints(TTQPointArray, bool closed=TRUE);
+    TTQPointArray controlPoints() const;
     bool closed() const;
 
     int rtti() const;
@@ -670,47 +670,47 @@ public:
 
 private:
     void recalcPoly();
-    TQPointArray bez;
+    TTQPointArray bez;
     bool cl;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasLine : public QCanvasPolygonalItem
+class TQM_EXPORT_CANVAS TTQCanvasLine : public TQCanvasPolygonalItem
 {
 public:
-    TQCanvasLine(TQCanvas* canvas);
-    ~TQCanvasLine();
+    TTQCanvasLine(TTQCanvas* canvas);
+    ~TTQCanvasLine();
     void setPoints(int x1, int y1, int x2, int y2);
 
-    TQPoint startPoint() const
-	{ return TQPoint(x1,y1); }
-    TQPoint endPoint() const
-	{ return TQPoint(x2,y2); }
+    TTQPoint startPoint() const
+	{ return TTQPoint(x1,y1); }
+    TTQPoint endPoint() const
+	{ return TTQPoint(x2,y2); }
 
     int rtti() const;
     static int RTTI;
 
-    void setPen(TQPen p);
+    void setPen(TTQPen p);
 
 protected:
-    void drawShape(TQPainter &);
-    TQPointArray areaPoints() const;
+    void drawShape(TTQPainter &);
+    TTQPointArray areaPoints() const;
 
 private:
     int x1,y1,x2,y2;
 };
 
 
-class QM_EXPORT_CANVAS TQCanvasEllipse : public QCanvasPolygonalItem
+class TQM_EXPORT_CANVAS TTQCanvasEllipse : public TQCanvasPolygonalItem
 {
 
 public:
-    TQCanvasEllipse( TQCanvas* canvas );
-    TQCanvasEllipse( int width, int height, TQCanvas* canvas );
-    TQCanvasEllipse( int width, int height, int startangle, int angle,
-		    TQCanvas* canvas );
+    TTQCanvasEllipse( TTQCanvas* canvas );
+    TTQCanvasEllipse( int width, int height, TTQCanvas* canvas );
+    TTQCanvasEllipse( int width, int height, int startangle, int angle,
+		    TTQCanvas* canvas );
 
-    ~TQCanvasEllipse();
+    ~TTQCanvasEllipse();
 
     int width() const;
     int height() const;
@@ -720,44 +720,44 @@ public:
 	{ return a1; }
     int angleLength() const
 	{ return a2; }
-    TQPointArray areaPoints() const;
+    TTQPointArray areaPoints() const;
 
-    bool collidesWith( const TQCanvasItem* ) const;
+    bool collidesWith( const TTQCanvasItem* ) const;
 
     int rtti() const;
     static int RTTI;
 
 protected:
-    void drawShape(TQPainter &);
+    void drawShape(TTQPainter &);
 
 private:
-    bool collidesWith( const TQCanvasSprite*,
-		       const TQCanvasPolygonalItem*,
-		       const TQCanvasRectangle*,
-		       const TQCanvasEllipse*,
-		       const TQCanvasText* ) const;
+    bool collidesWith( const TTQCanvasSprite*,
+		       const TTQCanvasPolygonalItem*,
+		       const TTQCanvasRectangle*,
+		       const TTQCanvasEllipse*,
+		       const TTQCanvasText* ) const;
     int w, h;
     int a1, a2;
 };
 
 
-class TQCanvasTextExtra;
+class TTQCanvasTextExtra;
 
-class QM_EXPORT_CANVAS TQCanvasText : public QCanvasItem
+class TQM_EXPORT_CANVAS TTQCanvasText : public TQCanvasItem
 {
 public:
-    TQCanvasText(TQCanvas* canvas);
-    TQCanvasText(const TQString&, TQCanvas* canvas);
-    TQCanvasText(const TQString&, TQFont, TQCanvas* canvas);
+    TTQCanvasText(TTQCanvas* canvas);
+    TTQCanvasText(const TTQString&, TTQCanvas* canvas);
+    TTQCanvasText(const TTQString&, TTQFont, TTQCanvas* canvas);
 
-    virtual ~TQCanvasText();
+    virtual ~TTQCanvasText();
 
-    void setText( const TQString& );
-    void setFont( const TQFont& );
-    void setColor( const TQColor& );
-    TQString text() const;
-    TQFont font() const;
-    TQColor color() const;
+    void setText( const TTQString& );
+    void setFont( const TTQFont& );
+    void setColor( const TTQColor& );
+    TTQString text() const;
+    TTQFont font() const;
+    TTQColor color() const;
 
     void moveBy(double dx, double dy);
 
@@ -765,42 +765,42 @@ public:
 	{ return flags; }
     void setTextFlags(int);
 
-    TQRect boundingRect() const;
+    TTQRect boundingRect() const;
 
-    bool collidesWith( const TQCanvasItem* ) const;
+    bool collidesWith( const TTQCanvasItem* ) const;
 
     int rtti() const;
     static int RTTI;
 
 protected:
-    virtual void draw(TQPainter&);
+    virtual void draw(TTQPainter&);
 
 private:
 #if defined(Q_DISABLE_COPY)
-    TQCanvasText( const TQCanvasText & );
-    TQCanvasText &operator=( const TQCanvasText & );
+    TTQCanvasText( const TTQCanvasText & );
+    TTQCanvasText &operator=( const TTQCanvasText & );
 #endif
     void addToChunks();
     void removeFromChunks();
     void changeChunks();
 
     void setRect();
-    TQRect brect;
-    TQString txt;
+    TTQRect brect;
+    TTQString txt;
     int flags;
-    TQFont fnt;
-    TQColor col;
-    TQCanvasTextExtra* extra;
-
-    bool collidesWith(   const TQCanvasSprite*,
-			 const TQCanvasPolygonalItem*,
-			 const TQCanvasRectangle*,
-			 const TQCanvasEllipse*,
-			 const TQCanvasText* ) const;
+    TTQFont fnt;
+    TTQColor col;
+    TTQCanvasTextExtra* extra;
+
+    bool collidesWith(   const TTQCanvasSprite*,
+			 const TTQCanvasPolygonalItem*,
+			 const TTQCanvasRectangle*,
+			 const TTQCanvasEllipse*,
+			 const TTQCanvasText* ) const;
 };
 
 #define Q_DEFINED_QCANVAS
 #include "tqwinexport.h"
 #endif // QT_NO_CANVAS
 
-#endif // QCANVAS_H
+#endif // TQCANVAS_H