TQt4 port koffice

This should enable compilation under both Qt3 and Qt4; fixes for any missed components will be forthcoming


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1238284 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 128 insertions, 128 deletions

diff --git a/krita/ui/kis_qpaintdevice_canvas_painter.cc b/krita/ui/kis_qpaintdevice_canvas_painter.cc
index eb68117d..e8a8e696 100644
--- a/krita/ui/kis_qpaintdevice_canvas_painter.cc
+++ b/krita/ui/kis_qpaintdevice_canvas_painter.cc
@@ -20,22 +20,22 @@
 #include "kis_canvas_painter.h"
 #include "kis_qpaintdevice_canvas_painter.h"
 
-KisQPaintDeviceCanvasPainter::KisQPaintDeviceCanvasPainter()
+KisTQPaintDeviceCanvasPainter::KisTQPaintDeviceCanvasPainter()
 {
 }
 
-KisQPaintDeviceCanvasPainter::KisQPaintDeviceCanvasPainter(const QPaintDevice *paintDevice)
+KisTQPaintDeviceCanvasPainter::KisTQPaintDeviceCanvasPainter(const TQPaintDevice *paintDevice)
     : m_painter(paintDevice)
 {
 }
 
-KisQPaintDeviceCanvasPainter::~KisQPaintDeviceCanvasPainter()
+KisTQPaintDeviceCanvasPainter::~KisTQPaintDeviceCanvasPainter()
 {
 }
 
-bool KisQPaintDeviceCanvasPainter::begin(KisCanvasWidget *canvasWidget, bool unclipped)
+bool KisTQPaintDeviceCanvasPainter::begin(KisCanvasWidget *canvasWidget, bool unclipped)
 {
-    QWidget *widget = dynamic_cast<QWidget *>(canvasWidget);
+    TQWidget *widget = dynamic_cast<TQWidget *>(canvasWidget);
 
     if (widget != 0) {
         return m_painter.begin(widget, unclipped);
@@ -44,602 +44,602 @@ bool KisQPaintDeviceCanvasPainter::begin(KisCanvasWidget *canvasWidget, bool unc
     }
 }
 
-bool KisQPaintDeviceCanvasPainter::begin(const QPaintDevice* paintDevice, bool unclipped)
+bool KisTQPaintDeviceCanvasPainter::begin(const TQPaintDevice* paintDevice, bool unclipped)
 {
     return m_painter.begin(paintDevice, unclipped);
 }
 
-bool KisQPaintDeviceCanvasPainter::end()
+bool KisTQPaintDeviceCanvasPainter::end()
 {
     return m_painter.end();
 }
 
-void KisQPaintDeviceCanvasPainter::save()
+void KisTQPaintDeviceCanvasPainter::save()
 {
     m_painter.save();
 }
 
-void KisQPaintDeviceCanvasPainter::restore()
+void KisTQPaintDeviceCanvasPainter::restore()
 {
     m_painter.restore();
 }
 
-QFontMetrics KisQPaintDeviceCanvasPainter::fontMetrics() const
+TQFontMetrics KisTQPaintDeviceCanvasPainter::fontMetrics() const
 {
     return m_painter.fontMetrics();
 }
 
-QFontInfo KisQPaintDeviceCanvasPainter::fontInfo() const
+TQFontInfo KisTQPaintDeviceCanvasPainter::fontInfo() const
 {
     return m_painter.fontInfo();
 }
 
-const QFont& KisQPaintDeviceCanvasPainter::font() const
+const TQFont& KisTQPaintDeviceCanvasPainter::font() const
 {
     return m_painter.font();
 }
 
-void KisQPaintDeviceCanvasPainter::setFont(const QFont& font)
+void KisTQPaintDeviceCanvasPainter::setFont(const TQFont& font)
 {
     m_painter.setFont(font);
 }
 
-const QPen& KisQPaintDeviceCanvasPainter::pen() const
+const TQPen& KisTQPaintDeviceCanvasPainter::pen() const
 {
     return m_painter.pen();
 }
 
-void KisQPaintDeviceCanvasPainter::setPen(const QPen& pen)
+void KisTQPaintDeviceCanvasPainter::setPen(const TQPen& pen)
 {
     m_painter.setPen(pen);
 }
 
-void KisQPaintDeviceCanvasPainter::setPen(Qt::PenStyle penStyle)
+void KisTQPaintDeviceCanvasPainter::setPen(Qt::PenStyle penStyle)
 {
     m_painter.setPen(penStyle);
 }
 
-void KisQPaintDeviceCanvasPainter::setPen(const QColor& color)
+void KisTQPaintDeviceCanvasPainter::setPen(const TQColor& color)
 {
     m_painter.setPen(color);;
 }
 
-const QBrush& KisQPaintDeviceCanvasPainter::brush() const
+const TQBrush& KisTQPaintDeviceCanvasPainter::brush() const
 {
     return m_painter.brush();
 }
 
-void KisQPaintDeviceCanvasPainter::setBrush(const QBrush& brush)
+void KisTQPaintDeviceCanvasPainter::setBrush(const TQBrush& brush)
 {
     m_painter.setBrush(brush);
 }
 
-void KisQPaintDeviceCanvasPainter::setBrush(Qt::BrushStyle brushStyle)
+void KisTQPaintDeviceCanvasPainter::setBrush(TQt::BrushStyle brushStyle)
 {
     m_painter.setBrush(brushStyle);
 }
 
-void KisQPaintDeviceCanvasPainter::setBrush(const QColor& color)
+void KisTQPaintDeviceCanvasPainter::setBrush(const TQColor& color)
 {
     m_painter.setBrush(color);
 }
 
-QPoint KisQPaintDeviceCanvasPainter::pos() const
+TQPoint KisTQPaintDeviceCanvasPainter::pos() const
 {
     return m_painter.pos();
 }
 
-const QColor& KisQPaintDeviceCanvasPainter::backgroundColor() const
+const TQColor& KisTQPaintDeviceCanvasPainter::backgroundColor() const
 {
     return m_painter.backgroundColor();
 }
 
-void KisQPaintDeviceCanvasPainter::setBackgroundColor(const QColor& color)
+void KisTQPaintDeviceCanvasPainter::setBackgroundColor(const TQColor& color)
 {
     m_painter.setBackgroundColor(color);
 }
 
-Qt::Qt::BGMode KisQPaintDeviceCanvasPainter::backgroundMode() const
+TQt::Qt::BGMode KisTQPaintDeviceCanvasPainter::backgroundMode() const
 {
     return m_painter.backgroundMode();
 }
 
-void KisQPaintDeviceCanvasPainter::setBackgroundMode(Qt::BGMode bgMode)
+void KisTQPaintDeviceCanvasPainter::setBackgroundMode(Qt::BGMode bgMode)
 {
     m_painter.setBackgroundMode(bgMode);
 }
 
-Qt::RasterOp KisQPaintDeviceCanvasPainter::rasterOp() const
+TQt::RasterOp KisTQPaintDeviceCanvasPainter::rasterOp() const
 {
     return m_painter.rasterOp();
 }
 
-void KisQPaintDeviceCanvasPainter::setRasterOp(Qt::RasterOp rasterOp)
+void KisTQPaintDeviceCanvasPainter::setRasterOp(TQt::RasterOp rasterOp)
 {
     m_painter.setRasterOp(rasterOp);
 }
 
-const QPoint& KisQPaintDeviceCanvasPainter::brushOrigin() const
+const TQPoint& KisTQPaintDeviceCanvasPainter::brushOrigin() const
 {
     return m_painter.brushOrigin();
 }
 
-void KisQPaintDeviceCanvasPainter::setBrushOrigin(int x, int y)
+void KisTQPaintDeviceCanvasPainter::setBrushOrigin(int x, int y)
 {
     m_painter.setBrushOrigin(x, y);
 }
 
-void KisQPaintDeviceCanvasPainter::setBrushOrigin(const QPoint& origin)
+void KisTQPaintDeviceCanvasPainter::setBrushOrigin(const TQPoint& origin)
 {
     m_painter.setBrushOrigin(origin);
 }
 
-bool KisQPaintDeviceCanvasPainter::hasViewXForm() const
+bool KisTQPaintDeviceCanvasPainter::hasViewXForm() const
 {
     return m_painter.hasViewXForm();
 }
 
-bool KisQPaintDeviceCanvasPainter::hasWorldXForm() const
+bool KisTQPaintDeviceCanvasPainter::hasWorldXForm() const
 {
     return m_painter.hasWorldXForm();
 }
 
-void KisQPaintDeviceCanvasPainter::setViewXForm(bool enable)
+void KisTQPaintDeviceCanvasPainter::setViewXForm(bool enable)
 {
     m_painter.setViewXForm(enable);
 }
 
-QRect KisQPaintDeviceCanvasPainter::window() const
+TQRect KisTQPaintDeviceCanvasPainter::window() const
 {
     return m_painter.window();
 }
 
-void KisQPaintDeviceCanvasPainter::setWindow(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::setWindow(const TQRect& r)
 {
     m_painter.setWindow(r);
 }
 
-void KisQPaintDeviceCanvasPainter::setWindow(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::setWindow(int x, int y, int w, int h)
 {
     m_painter.setWindow(x, y, w, h);
 }
 
-QRect KisQPaintDeviceCanvasPainter::viewport() const
+TQRect KisTQPaintDeviceCanvasPainter::viewport() const
 {
     return m_painter.viewport();
 }
 
-void KisQPaintDeviceCanvasPainter::setViewport(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::setViewport(const TQRect& r)
 {
     m_painter.setViewport(r);
 }
 
-void KisQPaintDeviceCanvasPainter::setViewport(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::setViewport(int x, int y, int w, int h)
 {
     m_painter.setViewport(x, y, w, h);
 }
 
-void KisQPaintDeviceCanvasPainter::setWorldXForm(bool enable)
+void KisTQPaintDeviceCanvasPainter::setWorldXForm(bool enable)
 {
     m_painter.setWorldXForm(enable);
 }
 
-const QWMatrix& KisQPaintDeviceCanvasPainter::worldMatrix() const
+const TQWMatrix& KisTQPaintDeviceCanvasPainter::tqworldMatrix() const
 {
-    return m_painter.worldMatrix();
+    return m_painter.tqworldMatrix();
 }
 
-void KisQPaintDeviceCanvasPainter::setWorldMatrix(const QWMatrix& matrix, bool combine)
+void KisTQPaintDeviceCanvasPainter::setWorldMatrix(const TQWMatrix& matrix, bool combine)
 {
     m_painter.setWorldMatrix(matrix, combine);
 }
 
-void KisQPaintDeviceCanvasPainter::saveWorldMatrix()
+void KisTQPaintDeviceCanvasPainter::saveWorldMatrix()
 {
     m_painter.saveWorldMatrix();
 }
 
-void KisQPaintDeviceCanvasPainter::restoreWorldMatrix()
+void KisTQPaintDeviceCanvasPainter::restoreWorldMatrix()
 {
     m_painter.restoreWorldMatrix();
 }
 
-void KisQPaintDeviceCanvasPainter::scale(double sx, double sy)
+void KisTQPaintDeviceCanvasPainter::scale(double sx, double sy)
 {
     m_painter.scale(sx, sy);
 }
 
-void KisQPaintDeviceCanvasPainter::shear(double sh, double sv)
+void KisTQPaintDeviceCanvasPainter::shear(double sh, double sv)
 {
     m_painter.shear(sh, sv);
 }
 
-void KisQPaintDeviceCanvasPainter::rotate(double a)
+void KisTQPaintDeviceCanvasPainter::rotate(double a)
 {
     m_painter.rotate(a);
 }
 
-void KisQPaintDeviceCanvasPainter::translate(double dx, double dy)
+void KisTQPaintDeviceCanvasPainter::translate(double dx, double dy)
 {
     m_painter.translate(dx, dy);
 }
 
-void KisQPaintDeviceCanvasPainter::resetXForm()
+void KisTQPaintDeviceCanvasPainter::resetXForm()
 {
     m_painter.resetXForm();
 }
 
-double KisQPaintDeviceCanvasPainter::translationX() const
+double KisTQPaintDeviceCanvasPainter::translationX() const
 {
     return m_painter.translationX();
 }
 
-double KisQPaintDeviceCanvasPainter::translationY() const
+double KisTQPaintDeviceCanvasPainter::translationY() const
 {
     return m_painter.translationY();
 }
 
-QPoint KisQPaintDeviceCanvasPainter::xForm(const QPoint& point) const
+TQPoint KisTQPaintDeviceCanvasPainter::xForm(const TQPoint& point) const
 {
     return m_painter.xForm(point);
 }
 
-QRect KisQPaintDeviceCanvasPainter::xForm(const QRect& r) const
+TQRect KisTQPaintDeviceCanvasPainter::xForm(const TQRect& r) const
 {
     return m_painter.xForm(r);
 }
 
-QPointArray KisQPaintDeviceCanvasPainter::xForm(const QPointArray& pointArray) const
+TQPointArray KisTQPaintDeviceCanvasPainter::xForm(const TQPointArray& pointArray) const
 {
     return m_painter.xForm(pointArray);
 }
 
-QPointArray KisQPaintDeviceCanvasPainter::xForm(const QPointArray& pointArray, int index, int npoints) const
+TQPointArray KisTQPaintDeviceCanvasPainter::xForm(const TQPointArray& pointArray, int index, int npoints) const
 {
     return m_painter.xForm(pointArray, index, npoints);
 }
 
-QPoint KisQPaintDeviceCanvasPainter::xFormDev(const QPoint& point) const
+TQPoint KisTQPaintDeviceCanvasPainter::xFormDev(const TQPoint& point) const
 {
     return m_painter.xFormDev(point);
 }
 
-QRect KisQPaintDeviceCanvasPainter::xFormDev(const QRect& r) const
+TQRect KisTQPaintDeviceCanvasPainter::xFormDev(const TQRect& r) const
 {
     return m_painter.xFormDev(r);
 }
 
-QPointArray KisQPaintDeviceCanvasPainter::xFormDev(const QPointArray& pointArray) const
+TQPointArray KisTQPaintDeviceCanvasPainter::xFormDev(const TQPointArray& pointArray) const
 {
     return m_painter.xFormDev(pointArray);
 }
 
-QPointArray KisQPaintDeviceCanvasPainter::xFormDev(const QPointArray& pointArray, int index, int npoints) const
+TQPointArray KisTQPaintDeviceCanvasPainter::xFormDev(const TQPointArray& pointArray, int index, int npoints) const
 {
     return m_painter.xFormDev(pointArray, index, npoints);
 }
 
-void KisQPaintDeviceCanvasPainter::setClipping(bool enable)
+void KisTQPaintDeviceCanvasPainter::setClipping(bool enable)
 {
     m_painter.setClipping(enable);
 }
 
-bool KisQPaintDeviceCanvasPainter::hasClipping() const
+bool KisTQPaintDeviceCanvasPainter::hasClipping() const
 {
     return m_painter.hasClipping();
 }
 
-QRegion KisQPaintDeviceCanvasPainter::clipRegion(QPainter::CoordinateMode mode) const
+TQRegion KisTQPaintDeviceCanvasPainter::clipRegion(TQPainter::CoordinateMode mode) const
 {
     return m_painter.clipRegion(mode);
 }
 
-void KisQPaintDeviceCanvasPainter::setClipRect(const QRect& r, QPainter::CoordinateMode mode)
+void KisTQPaintDeviceCanvasPainter::setClipRect(const TQRect& r, TQPainter::CoordinateMode mode)
 {
     m_painter.setClipRect(r, mode);
 }
 
-void KisQPaintDeviceCanvasPainter::setClipRect(int x, int y, int w, int h, QPainter::CoordinateMode mode)
+void KisTQPaintDeviceCanvasPainter::setClipRect(int x, int y, int w, int h, TQPainter::CoordinateMode mode)
 {
     m_painter.setClipRect(x, y, w, h, mode);
 }
 
-void KisQPaintDeviceCanvasPainter::setClipRegion(const QRegion& rgn, QPainter::CoordinateMode mode)
+void KisTQPaintDeviceCanvasPainter::setClipRegion(const TQRegion& rgn, TQPainter::CoordinateMode mode)
 {
     m_painter.setClipRegion(rgn, mode);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPoint(int x, int y)
+void KisTQPaintDeviceCanvasPainter::drawPoint(int x, int y)
 {
     m_painter.drawPoint(x, y);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPoint(const QPoint& point)
+void KisTQPaintDeviceCanvasPainter::drawPoint(const TQPoint& point)
 {
     m_painter.drawPoint(point);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPoints(const QPointArray& pointArray, int index, int npoints)
+void KisTQPaintDeviceCanvasPainter::drawPoints(const TQPointArray& pointArray, int index, int npoints)
 {
     m_painter.drawPoints(pointArray, index, npoints);
 }
 
-void KisQPaintDeviceCanvasPainter::moveTo(int x, int y)
+void KisTQPaintDeviceCanvasPainter::moveTo(int x, int y)
 {
     m_painter.moveTo(x, y);
 }
 
-void KisQPaintDeviceCanvasPainter::moveTo(const QPoint& point)
+void KisTQPaintDeviceCanvasPainter::moveTo(const TQPoint& point)
 {
     m_painter.moveTo(point);
 }
 
-void KisQPaintDeviceCanvasPainter::lineTo(int x, int y)
+void KisTQPaintDeviceCanvasPainter::lineTo(int x, int y)
 {
     m_painter.lineTo(x, y);
 }
 
-void KisQPaintDeviceCanvasPainter::lineTo(const QPoint& point)
+void KisTQPaintDeviceCanvasPainter::lineTo(const TQPoint& point)
 {
     m_painter.lineTo(point);
 }
 
-void KisQPaintDeviceCanvasPainter::drawLine(int x1, int y1, int x2, int y2)
+void KisTQPaintDeviceCanvasPainter::drawLine(int x1, int y1, int x2, int y2)
 {
     m_painter.drawLine(x1, y1, x2, y2);
 }
 
-void KisQPaintDeviceCanvasPainter::drawLine(const QPoint& start, const QPoint& end)
+void KisTQPaintDeviceCanvasPainter::drawLine(const TQPoint& start, const TQPoint& end)
 {
     m_painter.drawLine(start, end);
 }
 
-void KisQPaintDeviceCanvasPainter::drawRect(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::drawRect(int x, int y, int w, int h)
 {
     m_painter.drawRect(x, y, w, h);
 }
 
-void KisQPaintDeviceCanvasPainter::drawRect(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::drawRect(const TQRect& r)
 {
     m_painter.drawRect(r);
 }
 
-void KisQPaintDeviceCanvasPainter::drawWinFocusRect(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::drawWinFocusRect(int x, int y, int w, int h)
 {
     m_painter.drawWinFocusRect(x, y, w, h);
 }
 
-void KisQPaintDeviceCanvasPainter::drawWinFocusRect(int x, int y, int w, int h, const QColor& bgColor)
+void KisTQPaintDeviceCanvasPainter::drawWinFocusRect(int x, int y, int w, int h, const TQColor& bgColor)
 {
     m_painter.drawWinFocusRect(x, y, w, h, bgColor);
 }
 
-void KisQPaintDeviceCanvasPainter::drawWinFocusRect(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::drawWinFocusRect(const TQRect& r)
 {
     m_painter.drawWinFocusRect(r);
 }
 
-void KisQPaintDeviceCanvasPainter::drawWinFocusRect(const QRect& r, const QColor& bgColor)
+void KisTQPaintDeviceCanvasPainter::drawWinFocusRect(const TQRect& r, const TQColor& bgColor)
 {
     m_painter.drawWinFocusRect(r, bgColor);
 }
 
-void KisQPaintDeviceCanvasPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
+void KisTQPaintDeviceCanvasPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
 {
     m_painter.drawRoundRect(x, y, w, h, xRnd, yRnd);
 }
 
-void KisQPaintDeviceCanvasPainter::drawRoundRect(const QRect& r, int xRnd, int yRnd)
+void KisTQPaintDeviceCanvasPainter::drawRoundRect(const TQRect& r, int xRnd, int yRnd)
 {
     m_painter.drawRoundRect(r, xRnd, yRnd);
 }
 
-void KisQPaintDeviceCanvasPainter::drawEllipse(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::drawEllipse(int x, int y, int w, int h)
 {
     m_painter.drawEllipse(x, y, w, h);
 }
 
-void KisQPaintDeviceCanvasPainter::drawEllipse(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::drawEllipse(const TQRect& r)
 {
     m_painter.drawEllipse(r);
 }
 
-void KisQPaintDeviceCanvasPainter::drawArc(int x, int y, int w, int h, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawArc(int x, int y, int w, int h, int a, int alen)
 {
     m_painter.drawArc(x, y, w, h, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawArc(const QRect& r, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawArc(const TQRect& r, int a, int alen)
 {
     m_painter.drawArc(r, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPie(int x, int y, int w, int h, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawPie(int x, int y, int w, int h, int a, int alen)
 {
     m_painter.drawPie(x, y, w, h, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPie(const QRect& r, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawPie(const TQRect& r, int a, int alen)
 {
     m_painter.drawPie(r, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawChord(int x, int y, int w, int h, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawChord(int x, int y, int w, int h, int a, int alen)
 {
     m_painter.drawChord(x, y, w, h, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawChord(const QRect& r, int a, int alen)
+void KisTQPaintDeviceCanvasPainter::drawChord(const TQRect& r, int a, int alen)
 {
     m_painter.drawChord(r, a, alen);
 }
 
-void KisQPaintDeviceCanvasPainter::drawLineSegments(const QPointArray& pointArray, int index, int nlines)
+void KisTQPaintDeviceCanvasPainter::drawLineSegments(const TQPointArray& pointArray, int index, int nlines)
 {
     m_painter.drawLineSegments(pointArray, index, nlines);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPolyline(const QPointArray& pointArray, int index, int npoints)
+void KisTQPaintDeviceCanvasPainter::drawPolyline(const TQPointArray& pointArray, int index, int npoints)
 {
     m_painter.drawPolyline(pointArray, index, npoints);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPolygon(const QPointArray& pointArray, bool winding, int index, int npoints)
+void KisTQPaintDeviceCanvasPainter::drawPolygon(const TQPointArray& pointArray, bool winding, int index, int npoints)
 {
     m_painter.drawPolygon(pointArray, winding, index, npoints);
 }
 
-void KisQPaintDeviceCanvasPainter::drawConvexPolygon(const QPointArray& pointArray, int index, int npoints)
+void KisTQPaintDeviceCanvasPainter::drawConvexPolygon(const TQPointArray& pointArray, int index, int npoints)
 {
     m_painter.drawConvexPolygon(pointArray, index, npoints);
 }
 
-void KisQPaintDeviceCanvasPainter::drawCubicBezier(const QPointArray& pointArray, int index)
+void KisTQPaintDeviceCanvasPainter::drawCubicBezier(const TQPointArray& pointArray, int index)
 {
     m_painter.drawCubicBezier(pointArray, index);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPixmap(int x, int y, const QPixmap& pixmap, int sx, int sy, int sw, int sh)
+void KisTQPaintDeviceCanvasPainter::drawPixmap(int x, int y, const TQPixmap& pixmap, int sx, int sy, int sw, int sh)
 {
     m_painter.drawPixmap(x, y, pixmap, sx, sy, sw, sh);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap, const QRect& sr)
+void KisTQPaintDeviceCanvasPainter::drawPixmap(const TQPoint& point, const TQPixmap& pixmap, const TQRect& sr)
 {
     m_painter.drawPixmap(point, pixmap, sr);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap)
+void KisTQPaintDeviceCanvasPainter::drawPixmap(const TQPoint& point, const TQPixmap& pixmap)
 {
     m_painter.drawPixmap(point, pixmap);
 }
 
-void KisQPaintDeviceCanvasPainter::drawPixmap(const QRect& r, const QPixmap& pixmap)
+void KisTQPaintDeviceCanvasPainter::drawPixmap(const TQRect& r, const TQPixmap& pixmap)
 {
     m_painter.drawPixmap(r, pixmap);
 }
 
-void KisQPaintDeviceCanvasPainter::drawImage(int x, int y, const QImage& image, int sx, int sy, int sw, int sh, int conversionFlags)
+void KisTQPaintDeviceCanvasPainter::drawImage(int x, int y, const TQImage& image, int sx, int sy, int sw, int sh, int conversionFlags)
 {
     m_painter.drawImage(x, y, image, sx, sy, sw, sh, conversionFlags);
 }
 
-void KisQPaintDeviceCanvasPainter::drawImage(const QPoint& point, const QImage& image, const QRect& sr, int conversionFlags)
+void KisTQPaintDeviceCanvasPainter::drawImage(const TQPoint& point, const TQImage& image, const TQRect& sr, int conversionFlags)
 {
     m_painter.drawImage(point, image, sr, conversionFlags);
 }
 
-void KisQPaintDeviceCanvasPainter::drawImage(const QPoint& point, const QImage& image, int conversion_flags)
+void KisTQPaintDeviceCanvasPainter::drawImage(const TQPoint& point, const TQImage& image, int conversion_flags)
 {
     m_painter.drawImage(point, image, conversion_flags);
 }
 
-void KisQPaintDeviceCanvasPainter::drawImage(const QRect& r, const QImage& image)
+void KisTQPaintDeviceCanvasPainter::drawImage(const TQRect& r, const TQImage& image)
 {
     m_painter.drawImage(r, image);
 }
 
-void KisQPaintDeviceCanvasPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap& pixmap, int sx, int sy)
+void KisTQPaintDeviceCanvasPainter::drawTiledPixmap(int x, int y, int w, int h, const TQPixmap& pixmap, int sx, int sy)
 {
     m_painter.drawTiledPixmap(x, y, w, h, pixmap, sx, sy);
 }
 
-void KisQPaintDeviceCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap, const QPoint& point)
+void KisTQPaintDeviceCanvasPainter::drawTiledPixmap(const TQRect& r, const TQPixmap& pixmap, const TQPoint& point)
 {
     m_painter.drawTiledPixmap(r, pixmap, point);
 }
 
-void KisQPaintDeviceCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap)
+void KisTQPaintDeviceCanvasPainter::drawTiledPixmap(const TQRect& r, const TQPixmap& pixmap)
 {
     m_painter.drawTiledPixmap(r, pixmap);
 }
 
-void KisQPaintDeviceCanvasPainter::fillRect(int x, int y, int w, int h, const QBrush& brush)
+void KisTQPaintDeviceCanvasPainter::fillRect(int x, int y, int w, int h, const TQBrush& brush)
 {
     m_painter.fillRect(x, y, w, h, brush);
 }
 
-void KisQPaintDeviceCanvasPainter::fillRect(const QRect& r, const QBrush& brush)
+void KisTQPaintDeviceCanvasPainter::fillRect(const TQRect& r, const TQBrush& brush)
 {
     m_painter.fillRect(r, brush);
 }
 
-void KisQPaintDeviceCanvasPainter::eraseRect(int x, int y, int w, int h)
+void KisTQPaintDeviceCanvasPainter::eraseRect(int x, int y, int w, int h)
 {
     m_painter.eraseRect(x, y, w, h);
 }
 
-void KisQPaintDeviceCanvasPainter::eraseRect(const QRect& r)
+void KisTQPaintDeviceCanvasPainter::eraseRect(const TQRect& r)
 {
     m_painter.eraseRect(r);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(int x, int y, const QString& text, int len, QPainter::TextDirection dir)
+void KisTQPaintDeviceCanvasPainter::drawText(int x, int y, const TQString& text, int len, TQPainter::TextDirection dir)
 {
     m_painter.drawText(x, y, text, len, dir);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(const QPoint& point, const QString& text, int len, QPainter::TextDirection dir)
+void KisTQPaintDeviceCanvasPainter::drawText(const TQPoint& point, const TQString& text, int len, TQPainter::TextDirection dir)
 {
     m_painter.drawText(point, text, len, dir);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(int x, int y, const QString& text, int pos, int len, QPainter::TextDirection dir)
+void KisTQPaintDeviceCanvasPainter::drawText(int x, int y, const TQString& text, int pos, int len, TQPainter::TextDirection dir)
 {
     m_painter.drawText(x, y, text, pos, len, dir);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(const QPoint& point, const QString& text, int pos, int len, QPainter::TextDirection dir)
+void KisTQPaintDeviceCanvasPainter::drawText(const TQPoint& point, const TQString& text, int pos, int len, TQPainter::TextDirection dir)
 {
     m_painter.drawText(point, text, pos, len, dir);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(int x, int y, int w, int h, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
+void KisTQPaintDeviceCanvasPainter::drawText(int x, int y, int w, int h, int flags, const TQString& text, int len, TQRect *br, TQTextParag **intern)
 {
     m_painter.drawText(x, y, w, h, flags, text, len, br, intern);
 }
 
-void KisQPaintDeviceCanvasPainter::drawText(const QRect& r, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
+void KisTQPaintDeviceCanvasPainter::drawText(const TQRect& r, int flags, const TQString& text, int len, TQRect *br, TQTextParag **intern)
 {
     m_painter.drawText(r, flags, text, len, br, intern);
 }
 
-void KisQPaintDeviceCanvasPainter::drawTextItem(int x, int y, const QTextItem& ti, int textflags)
+void KisTQPaintDeviceCanvasPainter::tqdrawTextItem(int x, int y, const TQTextItem& ti, int textflags)
 {
-    m_painter.drawTextItem(x, y, ti, textflags);
+    m_painter.tqdrawTextItem(x, y, ti, textflags);
 }
 
-void KisQPaintDeviceCanvasPainter::drawTextItem(const QPoint& p, const QTextItem& ti, int textflags)
+void KisTQPaintDeviceCanvasPainter::tqdrawTextItem(const TQPoint& p, const TQTextItem& ti, int textflags)
 {
-    m_painter.drawTextItem(p, ti, textflags);
+    m_painter.tqdrawTextItem(p, ti, textflags);
 }
 
-QRect KisQPaintDeviceCanvasPainter::boundingRect(int x, int y, int w, int h, int flags, const QString& text, int len, QTextParag **intern)
+TQRect KisTQPaintDeviceCanvasPainter::boundingRect(int x, int y, int w, int h, int flags, const TQString& text, int len, TQTextParag **intern)
 {
     return m_painter.boundingRect(x, y, w, h, flags, text, len, intern);
 }
 
-QRect KisQPaintDeviceCanvasPainter::boundingRect(const QRect& r, int flags, const QString& text, int len, QTextParag **intern)
+TQRect KisTQPaintDeviceCanvasPainter::boundingRect(const TQRect& r, int flags, const TQString& text, int len, TQTextParag **intern)
 {
     return m_painter.boundingRect(r, flags, text, len, intern);
 }
 
-int	KisQPaintDeviceCanvasPainter::tabStops() const
+int	KisTQPaintDeviceCanvasPainter::tabStops() const
 {
     return m_painter.tabStops();
 }
 
-void KisQPaintDeviceCanvasPainter::setTabStops(int ts)
+void KisTQPaintDeviceCanvasPainter::setTabStops(int ts)
 {
     m_painter.setTabStops(ts);
 }
 
-int	*KisQPaintDeviceCanvasPainter::tabArray() const
+int	*KisTQPaintDeviceCanvasPainter::tabArray() const
 {
     return m_painter.tabArray();
 }
 
-void KisQPaintDeviceCanvasPainter::setTabArray(int *ts)
+void KisTQPaintDeviceCanvasPainter::setTabArray(int *ts)
 {
     m_painter.setTabArray(ts);
 }