Added old abandoned KDE3 version of koffice

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

1 files changed, 1440 insertions, 0 deletions

diff --git a/krita/ui/kis_canvas_painter.cc b/krita/ui/kis_canvas_painter.cc
new file mode 100644
index 000000000..f9103e650
--- /dev/null
+++ b/krita/ui/kis_canvas_painter.cc
@@ -0,0 +1,1440 @@
+/*
+ *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.g
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_canvas.h"
+#include "kis_canvas_painter.h"
+#include "kis_qpaintdevice_canvas_painter.h"
+
+KisCanvasWidgetPainter::KisCanvasWidgetPainter()
+{
+}
+
+KisCanvasWidgetPainter::~KisCanvasWidgetPainter()
+{
+}
+
+bool KisCanvasWidgetPainter::end()
+{
+    return true;
+}
+
+void KisCanvasWidgetPainter::save()
+{
+}
+
+void KisCanvasWidgetPainter::restore()
+{
+}
+
+QFontMetrics KisCanvasWidgetPainter::fontMetrics() const
+{
+    return QFontMetrics(QFont());
+}
+
+QFontInfo KisCanvasWidgetPainter::fontInfo() const
+{
+    return QFontInfo(QFont());
+}
+
+const QFont& KisCanvasWidgetPainter::font() const
+{
+    return m_defaultFont;
+}
+
+void KisCanvasWidgetPainter::setFont(const QFont& /*font*/)
+{
+}
+
+const QPen& KisCanvasWidgetPainter::pen() const
+{
+    return m_defaultPen;
+}
+
+void KisCanvasWidgetPainter::setPen(const QPen& /*pen*/)
+{
+}
+
+void KisCanvasWidgetPainter::setPen(Qt::PenStyle /*penStyle*/)
+{
+}
+
+void KisCanvasWidgetPainter::setPen(const QColor& /*color*/)
+{
+}
+
+const QBrush& KisCanvasWidgetPainter::brush() const
+{
+    return m_defaultBrush;
+}
+
+void KisCanvasWidgetPainter::setBrush(const QBrush& /*brush*/)
+{
+}
+
+void KisCanvasWidgetPainter::setBrush(Qt::BrushStyle /*brushStyle*/)
+{
+}
+
+void KisCanvasWidgetPainter::setBrush(const QColor& /*color*/)
+{
+}
+
+QPoint KisCanvasWidgetPainter::pos() const
+{
+    return QPoint();
+}
+
+const QColor& KisCanvasWidgetPainter::backgroundColor() const
+{
+    return m_defaultColor;
+}
+
+void KisCanvasWidgetPainter::setBackgroundColor(const QColor& /*color*/)
+{
+}
+
+Qt::Qt::BGMode KisCanvasWidgetPainter::backgroundMode() const
+{
+    return Qt::TransparentMode;
+}
+
+void KisCanvasWidgetPainter::setBackgroundMode(Qt::Qt::BGMode /*bgMode*/)
+{
+}
+
+Qt::Qt::RasterOp KisCanvasWidgetPainter::rasterOp() const
+{
+    return Qt::CopyROP;
+}
+
+void KisCanvasWidgetPainter::setRasterOp(Qt::RasterOp /*rasterOp*/)
+{
+}
+
+const QPoint& KisCanvasWidgetPainter::brushOrigin() const
+{
+    return m_defaultBrushOrigin;
+}
+
+void KisCanvasWidgetPainter::setBrushOrigin(int /*x*/, int /*y*/)
+{
+}
+
+void KisCanvasWidgetPainter::setBrushOrigin(const QPoint& /*origin*/)
+{
+}
+
+bool KisCanvasWidgetPainter::hasViewXForm() const
+{
+    return false;
+}
+
+bool KisCanvasWidgetPainter::hasWorldXForm() const
+{
+    return false;
+}
+
+void KisCanvasWidgetPainter::setViewXForm(bool /*enable*/)
+{
+}
+
+QRect KisCanvasWidgetPainter::window() const
+{
+    return QRect();
+}
+
+void KisCanvasWidgetPainter::setWindow(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::setWindow(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+QRect KisCanvasWidgetPainter::viewport() const
+{
+    return QRect();
+}
+
+void KisCanvasWidgetPainter::setViewport(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::setViewport(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+
+void KisCanvasWidgetPainter::setWorldXForm(bool /*enable*/)
+{
+}
+
+const QWMatrix& KisCanvasWidgetPainter::worldMatrix() const
+{
+    return m_defaultWorldMatrix;
+}
+
+void KisCanvasWidgetPainter::setWorldMatrix(const QWMatrix& /*matrix*/, bool /*combine*/)
+{
+}
+
+void KisCanvasWidgetPainter::saveWorldMatrix()
+{
+}
+
+void KisCanvasWidgetPainter::restoreWorldMatrix()
+{
+}
+
+void KisCanvasWidgetPainter::scale(double /*sx*/, double /*sy*/)
+{
+}
+
+void KisCanvasWidgetPainter::shear(double /*sh*/, double /*sv*/)
+{
+}
+
+void KisCanvasWidgetPainter::rotate(double /*a*/)
+{
+}
+
+void KisCanvasWidgetPainter::translate(double /*dx*/, double /*dy*/)
+{
+}
+
+void KisCanvasWidgetPainter::resetXForm()
+{
+}
+
+double KisCanvasWidgetPainter::translationX() const
+{
+    return 0;
+}
+
+double KisCanvasWidgetPainter::translationY() const
+{
+    return 0;
+}
+
+QPoint KisCanvasWidgetPainter::xForm(const QPoint& point) const
+{
+    return point;
+}
+
+QRect KisCanvasWidgetPainter::xForm(const QRect& r) const
+{
+    return r;
+}
+
+QPointArray KisCanvasWidgetPainter::xForm(const QPointArray& pointArray) const
+{
+    return pointArray;
+}
+
+QPointArray KisCanvasWidgetPainter::xForm(const QPointArray& pointArray, int /*index*/, int /*npoints*/) const
+{
+    return pointArray;
+}
+
+QPoint KisCanvasWidgetPainter::xFormDev(const QPoint& point) const
+{
+    return point;
+}
+
+QRect KisCanvasWidgetPainter::xFormDev(const QRect& r) const
+{
+    return r;
+}
+
+QPointArray KisCanvasWidgetPainter::xFormDev(const QPointArray& pointArray) const
+{
+    return pointArray;
+}
+
+QPointArray KisCanvasWidgetPainter::xFormDev(const QPointArray& pointArray, int /*index*/, int /*npoints*/) const
+{
+    return pointArray;
+}
+
+void KisCanvasWidgetPainter::setClipping(bool /*enable*/)
+{
+}
+
+bool KisCanvasWidgetPainter::hasClipping() const
+{
+    return true;
+}
+
+QRegion KisCanvasWidgetPainter::clipRegion(QPainter::CoordinateMode /*mode*/) const
+{
+    return QRegion();
+}
+
+void KisCanvasWidgetPainter::setClipRect(const QRect& /*r*/, QPainter::CoordinateMode /*mode*/)
+{
+}
+
+void KisCanvasWidgetPainter::setClipRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, QPainter::CoordinateMode /*mode*/)
+{
+}
+
+void KisCanvasWidgetPainter::setClipRegion(const QRegion& /*rgn*/, QPainter::CoordinateMode /*mode*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPoint(int /*x*/, int /*y*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPoint(const QPoint& /*point*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPoints(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
+{
+}
+
+void KisCanvasWidgetPainter::moveTo(int /*x*/, int /*y*/)
+{
+}
+
+void KisCanvasWidgetPainter::moveTo(const QPoint& /*point*/)
+{
+}
+
+void KisCanvasWidgetPainter::lineTo(int /*x*/, int /*y*/)
+{
+}
+
+void KisCanvasWidgetPainter::lineTo(const QPoint& /*point*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawLine(int /*x1*/, int /*y1*/, int /*x2*/, int /*y2*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawLine(const QPoint& /*start*/, const QPoint& /*end*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawRect(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawWinFocusRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawWinFocusRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QColor& /*bgColor*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawWinFocusRect(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawWinFocusRect(const QRect& /*r*/, const QColor& /*bgColor*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawRoundRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*xRnd*/, int /*yRnd*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawRoundRect(const QRect& /*r*/, int /*xRnd*/, int /*yRnd*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawEllipse(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawEllipse(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawArc(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawArc(const QRect& /*r*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPie(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPie(const QRect& /*r*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawChord(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawChord(const QRect& /*r*/, int /*a*/, int /*alen*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawLineSegments(const QPointArray& /*pointArray*/, int /*index*/, int /*nlines*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPolyline(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPolygon(const QPointArray& /*pointArray*/, bool /*winding*/, int /*index*/, int /*npoints*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawConvexPolygon(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawCubicBezier(const QPointArray& /*pointArray*/, int /*index*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPixmap(int /*x*/, int /*y*/, const QPixmap& /*pixmap*/, int /*sx*/, int /*sy*/, int /*sw*/, int /*sh*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPixmap(const QPoint& /*point*/, const QPixmap& /*pixmap*/, const QRect& /*sr*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPixmap(const QPoint& /*point*/, const QPixmap& /*pixmap*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawImage(int /*x*/, int /*y*/, const QImage& /*image*/, int /*sx*/, int /*sy*/, int /*sw*/, int /*sh*/, int /*conversionFlags*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawImage(const QPoint& /*point*/, const QImage& /*image*/, const QRect& /*sr*/, int /*conversionFlags*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawImage(const QPoint& /*point*/, const QImage& /*image*/, int /*conversion_flags*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawImage(const QRect& /*r*/, const QImage& /*image*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawTiledPixmap(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QPixmap& /*pixmap*/, int /*sx*/, int /*sy*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawTiledPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/, const QPoint& /*point*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawTiledPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/)
+{
+}
+
+void KisCanvasWidgetPainter::fillRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QBrush& /*brush*/)
+{
+}
+
+void KisCanvasWidgetPainter::fillRect(const QRect& /*r*/, const QBrush& /*brush*/)
+{
+}
+
+void KisCanvasWidgetPainter::eraseRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+{
+}
+
+void KisCanvasWidgetPainter::eraseRect(const QRect& /*r*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, const QString& /*text*/, int /*len*/, QPainter::TextDirection /*dir*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(const QPoint& /*point*/, const QString& /*text*/, int /*len*/, QPainter::TextDirection /*dir*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, const QString& /*text*/, int /*pos*/, int /*len*/, QPainter::TextDirection /*dir*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(const QPoint& /*point*/, const QString& /*text*/, int /*pos*/, int /*len*/, QPainter::TextDirection /*dir*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*flags*/, const QString& /*text*/, int /*len*/, QRect */*br*/, QTextParag **/*intern*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawText(const QRect& /*r*/, int /*flags*/, const QString& /*text*/, int /*len*/, QRect */*br*/, QTextParag **/*intern*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawTextItem(int /*x*/, int /*y*/, const QTextItem& /*ti*/, int /*textflags*/)
+{
+}
+
+void KisCanvasWidgetPainter::drawTextItem(const QPoint& /*p*/, const QTextItem& /*ti*/, int /*textflags*/)
+{
+}
+
+QRect KisCanvasWidgetPainter::boundingRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*flags*/, const QString& /*text*/, int /*len*/, QTextParag **/*intern*/)
+{
+    return QRect();
+}
+
+QRect KisCanvasWidgetPainter::boundingRect(const QRect& /*r*/, int /*flags*/, const QString& /*text*/, int /*len*/, QTextParag **/*intern*/)
+{
+    return QRect();
+}
+
+int	KisCanvasWidgetPainter::tabStops() const
+{
+    return 0;
+}
+
+void KisCanvasWidgetPainter::setTabStops(int /*ts*/)
+{
+}
+
+int	*KisCanvasWidgetPainter::tabArray() const
+{
+    return 0;
+}
+
+void KisCanvasWidgetPainter::setTabArray(int */*ts*/)
+{
+}
+
+/*************************************************************************/
+
+KisCanvasPainter::KisCanvasPainter()
+{
+    m_canvasWidgetPainter = 0;
+}
+
+KisCanvasPainter::KisCanvasPainter(KisCanvas *canvas)
+{
+    m_canvasWidgetPainter = canvas->createPainter();
+}
+
+KisCanvasPainter::KisCanvasPainter(const QPaintDevice *paintDevice)
+{
+    m_canvasWidgetPainter = new KisQPaintDeviceCanvasPainter(paintDevice);
+}
+
+KisCanvasPainter::~KisCanvasPainter()
+{
+    delete m_canvasWidgetPainter;
+}
+
+bool KisCanvasPainter::begin(KisCanvas *canvas, bool unclipped)
+{
+    delete m_canvasWidgetPainter;
+    m_canvasWidgetPainter = canvas->createPainter();
+    return m_canvasWidgetPainter->begin(canvas->canvasWidget(), unclipped);
+}
+
+bool KisCanvasPainter::begin(const QPaintDevice *paintDevice, bool unclipped)
+{
+    delete m_canvasWidgetPainter;
+    m_canvasWidgetPainter = new KisQPaintDeviceCanvasPainter();
+    return static_cast<KisQPaintDeviceCanvasPainter *>(m_canvasWidgetPainter)->begin(paintDevice, unclipped);
+}
+
+bool KisCanvasPainter::end()
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->end();
+    }
+    return false;
+}
+
+void KisCanvasPainter::save()
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->save();
+    }
+}
+
+void KisCanvasPainter::restore()
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->restore();
+    }
+}
+
+QFontMetrics KisCanvasPainter::fontMetrics() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->fontMetrics();
+    }
+    return QFontMetrics(QFont());
+}
+
+QFontInfo KisCanvasPainter::fontInfo() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->fontInfo();
+    }
+    return QFontInfo(QFont());
+}
+
+const QFont& KisCanvasPainter::font() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->font();
+    }
+    return m_defaultFont;
+}
+
+void KisCanvasPainter::setFont(const QFont& font)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setFont(font);
+    }
+}
+
+const QPen& KisCanvasPainter::pen() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->pen();
+    }
+    return m_defaultPen;
+}
+
+void KisCanvasPainter::setPen(const QPen& pen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setPen(pen);
+    }
+}
+
+void KisCanvasPainter::setPen(Qt::PenStyle penStyle)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setPen(penStyle);
+    }
+}
+
+void KisCanvasPainter::setPen(const QColor& color)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setPen(color);;
+    }
+}
+
+const QBrush& KisCanvasPainter::brush() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->brush();
+    }
+    return m_defaultBrush;
+}
+
+void KisCanvasPainter::setBrush(const QBrush& brush)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBrush(brush);
+    }
+}
+
+void KisCanvasPainter::setBrush(Qt::BrushStyle brushStyle)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBrush(brushStyle);
+    }
+}
+
+void KisCanvasPainter::setBrush(const QColor& color)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBrush(color);
+    }
+}
+
+QPoint KisCanvasPainter::pos() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->pos();
+    }
+    return QPoint();
+}
+
+const QColor& KisCanvasPainter::backgroundColor() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->backgroundColor();
+    }
+    return m_defaultColor;
+}
+
+void KisCanvasPainter::setBackgroundColor(const QColor& color)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBackgroundColor(color);
+    }
+}
+
+Qt::BGMode KisCanvasPainter::backgroundMode() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->backgroundMode();
+    }
+    return Qt::TransparentMode;
+}
+
+void KisCanvasPainter::setBackgroundMode(Qt::BGMode bgMode)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBackgroundMode(bgMode);
+    }
+}
+
+Qt::RasterOp KisCanvasPainter::rasterOp() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->rasterOp();
+    }
+    return Qt::CopyROP;
+}
+
+void KisCanvasPainter::setRasterOp(Qt::RasterOp rasterOp)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setRasterOp(rasterOp);
+    }
+}
+
+const QPoint& KisCanvasPainter::brushOrigin() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->brushOrigin();
+    }
+    return m_defaultBrushOrigin;
+}
+
+void KisCanvasPainter::setBrushOrigin(int x, int y)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBrushOrigin(x, y);
+    }
+}
+
+void KisCanvasPainter::setBrushOrigin(const QPoint& origin)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setBrushOrigin(origin);
+    }
+}
+
+bool KisCanvasPainter::hasViewXForm() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->hasViewXForm();
+    }
+    return false;
+}
+
+bool KisCanvasPainter::hasWorldXForm() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->hasWorldXForm();
+    }
+    return false;
+}
+
+void KisCanvasPainter::setViewXForm(bool enable)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setViewXForm(enable);
+    }
+}
+
+QRect KisCanvasPainter::window() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->window();
+    }
+    return QRect();
+}
+
+void KisCanvasPainter::setWindow(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setWindow(r);
+    }
+}
+
+void KisCanvasPainter::setWindow(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setWindow(x, y, w, h);
+    }
+}
+
+QRect KisCanvasPainter::viewport() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->viewport();
+    }
+    return QRect();
+}
+
+void KisCanvasPainter::setViewport(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setViewport(r);
+    }
+}
+
+void KisCanvasPainter::setViewport(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setViewport(x, y, w, h);
+    }
+}
+
+void KisCanvasPainter::setWorldXForm(bool enable)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setWorldXForm(enable);
+    }
+}
+
+const QWMatrix& KisCanvasPainter::worldMatrix() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->worldMatrix();
+    }
+    return m_defaultWorldMatrix;
+}
+
+void KisCanvasPainter::setWorldMatrix(const QWMatrix& matrix, bool combine)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setWorldMatrix(matrix, combine);
+    }
+}
+
+void KisCanvasPainter::saveWorldMatrix()
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->saveWorldMatrix();
+    }
+}
+
+void KisCanvasPainter::restoreWorldMatrix()
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->restoreWorldMatrix();
+    }
+}
+
+void KisCanvasPainter::scale(double sx, double sy)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->scale(sx, sy);
+    }
+}
+
+void KisCanvasPainter::shear(double sh, double sv)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->shear(sh, sv);
+    }
+}
+
+void KisCanvasPainter::rotate(double a)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->rotate(a);
+    }
+}
+
+void KisCanvasPainter::translate(double dx, double dy)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->translate(dx, dy);
+    }
+}
+
+void KisCanvasPainter::resetXForm()
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->resetXForm();
+    }
+}
+
+double KisCanvasPainter::translationX() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->translationX();
+    }
+    return 0;
+}
+
+double KisCanvasPainter::translationY() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->translationY();
+    }
+    return 0;
+}
+
+QPoint KisCanvasPainter::xForm(const QPoint& point) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xForm(point);
+    }
+    return point;
+}
+
+QRect KisCanvasPainter::xForm(const QRect& r) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xForm(r);
+    }
+    return r;
+}
+
+QPointArray KisCanvasPainter::xForm(const QPointArray& pointArray) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xForm(pointArray);
+    }
+    return pointArray;
+}
+
+QPointArray KisCanvasPainter::xForm(const QPointArray& pointArray, int index, int npoints) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xForm(pointArray, index, npoints);
+    }
+    return pointArray;
+}
+
+QPoint KisCanvasPainter::xFormDev(const QPoint& point) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xFormDev(point);
+    }
+    return point;
+}
+
+QRect KisCanvasPainter::xFormDev(const QRect& r) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xFormDev(r);
+    }
+    return r;
+}
+
+QPointArray KisCanvasPainter::xFormDev(const QPointArray& pointArray) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xFormDev(pointArray);
+    }
+    return pointArray;
+}
+
+QPointArray KisCanvasPainter::xFormDev(const QPointArray& pointArray, int index, int npoints) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->xFormDev(pointArray, index, npoints);
+    }
+    return pointArray;
+}
+
+void KisCanvasPainter::setClipping(bool enable)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setClipping(enable);
+    }
+}
+
+bool KisCanvasPainter::hasClipping() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->hasClipping();
+    }
+    return true;
+}
+
+QRegion KisCanvasPainter::clipRegion(QPainter::CoordinateMode mode) const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->clipRegion(mode);
+    }
+    return QRegion();
+}
+
+void KisCanvasPainter::setClipRect(const QRect& r, QPainter::CoordinateMode mode)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setClipRect(r, mode);
+    }
+}
+
+void KisCanvasPainter::setClipRect(int x, int y, int w, int h, QPainter::CoordinateMode mode)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setClipRect(x, y, w, h, mode);
+    }
+}
+
+void KisCanvasPainter::setClipRegion(const QRegion& rgn, QPainter::CoordinateMode mode)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setClipRegion(rgn, mode);
+    }
+}
+
+void KisCanvasPainter::drawPoint(int x, int y)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPoint(x, y);
+    }
+}
+
+void KisCanvasPainter::drawPoint(const QPoint& point)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPoint(point);
+    }
+}
+
+void KisCanvasPainter::drawPoints(const QPointArray& pointArray, int index, int npoints)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPoints(pointArray, index, npoints);
+    }
+}
+
+void KisCanvasPainter::moveTo(int x, int y)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->moveTo(x, y);
+    }
+}
+
+void KisCanvasPainter::moveTo(const QPoint& point)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->moveTo(point);
+    }
+}
+
+void KisCanvasPainter::lineTo(int x, int y)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->lineTo(x, y);
+    }
+}
+
+void KisCanvasPainter::lineTo(const QPoint& point)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->lineTo(point);
+    }
+}
+
+void KisCanvasPainter::drawLine(int x1, int y1, int x2, int y2)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawLine(x1, y1, x2, y2);
+    }
+}
+
+void KisCanvasPainter::drawLine(const QPoint& start, const QPoint& end)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawLine(start, end);
+    }
+}
+
+void KisCanvasPainter::drawRect(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawRect(x, y, w, h);
+    }
+}
+
+void KisCanvasPainter::drawRect(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawRect(r);
+    }
+}
+
+void KisCanvasPainter::drawWinFocusRect(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawWinFocusRect(x, y, w, h);
+    }
+}
+
+void KisCanvasPainter::drawWinFocusRect(int x, int y, int w, int h, const QColor& bgColor)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawWinFocusRect(x, y, w, h, bgColor);
+    }
+}
+
+void KisCanvasPainter::drawWinFocusRect(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawWinFocusRect(r);
+    }
+}
+
+void KisCanvasPainter::drawWinFocusRect(const QRect& r, const QColor& bgColor)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawWinFocusRect(r, bgColor);
+    }
+}
+
+void KisCanvasPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawRoundRect(x, y, w, h, xRnd, yRnd);
+    }
+}
+
+void KisCanvasPainter::drawRoundRect(const QRect& r, int xRnd, int yRnd)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawRoundRect(r, xRnd, yRnd);
+    }
+}
+
+void KisCanvasPainter::drawEllipse(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawEllipse(x, y, w, h);
+    }
+}
+
+void KisCanvasPainter::drawEllipse(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawEllipse(r);
+    }
+}
+
+void KisCanvasPainter::drawArc(int x, int y, int w, int h, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawArc(x, y, w, h, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawArc(const QRect& r, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawArc(r, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawPie(int x, int y, int w, int h, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPie(x, y, w, h, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawPie(const QRect& r, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPie(r, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawChord(int x, int y, int w, int h, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawChord(x, y, w, h, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawChord(const QRect& r, int a, int alen)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawChord(r, a, alen);
+    }
+}
+
+void KisCanvasPainter::drawLineSegments(const QPointArray& pointArray, int index, int nlines)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawLineSegments(pointArray, index, nlines);
+    }
+}
+
+void KisCanvasPainter::drawPolyline(const QPointArray& pointArray, int index, int npoints)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPolyline(pointArray, index, npoints);
+    }
+}
+
+void KisCanvasPainter::drawPolygon(const QPointArray& pointArray, bool winding, int index, int npoints)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPolygon(pointArray, winding, index, npoints);
+    }
+}
+
+void KisCanvasPainter::drawConvexPolygon(const QPointArray& pointArray, int index, int npoints)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawConvexPolygon(pointArray, index, npoints);
+    }
+}
+
+void KisCanvasPainter::drawCubicBezier(const QPointArray& pointArray, int index)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawCubicBezier(pointArray, index);
+    }
+}
+
+void KisCanvasPainter::drawPixmap(int x, int y, const QPixmap& pixmap, int sx, int sy, int sw, int sh)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPixmap(x, y, pixmap, sx, sy, sw, sh);
+    }
+}
+
+void KisCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap, const QRect& sr)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPixmap(point, pixmap, sr);
+    }
+}
+
+void KisCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPixmap(point, pixmap);
+    }
+}
+
+void KisCanvasPainter::drawPixmap(const QRect& r, const QPixmap& pixmap)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawPixmap(r, pixmap);
+    }
+}
+
+void KisCanvasPainter::drawImage(int x, int y, const QImage& image, int sx, int sy, int sw, int sh, int conversionFlags)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawImage(x, y, image, sx, sy, sw, sh, conversionFlags);
+    }
+}
+
+void KisCanvasPainter::drawImage(const QPoint& point, const QImage& image, const QRect& sr, int conversionFlags)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawImage(point, image, sr, conversionFlags);
+    }
+}
+
+void KisCanvasPainter::drawImage(const QPoint& point, const QImage& image, int conversion_flags)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawImage(point, image, conversion_flags);
+    }
+}
+
+void KisCanvasPainter::drawImage(const QRect& r, const QImage& image)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawImage(r, image);
+    }
+}
+
+void KisCanvasPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap& pixmap, int sx, int sy)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawTiledPixmap(x, y, w, h, pixmap, sx, sy);
+    }
+}
+
+void KisCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap, const QPoint& point)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawTiledPixmap(r, pixmap, point);
+    }
+}
+
+void KisCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawTiledPixmap(r, pixmap);
+    }
+}
+
+void KisCanvasPainter::fillRect(int x, int y, int w, int h, const QBrush& brush)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->fillRect(x, y, w, h, brush);
+    }
+}
+
+void KisCanvasPainter::fillRect(const QRect& r, const QBrush& brush)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->fillRect(r, brush);
+    }
+}
+
+void KisCanvasPainter::eraseRect(int x, int y, int w, int h)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->eraseRect(x, y, w, h);
+    }
+}
+
+void KisCanvasPainter::eraseRect(const QRect& r)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->eraseRect(r);
+    }
+}
+
+void KisCanvasPainter::drawText(int x, int y, const QString& text, int len, QPainter::TextDirection dir)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(x, y, text, len, dir);
+    }
+}
+
+void KisCanvasPainter::drawText(const QPoint& point, const QString& text, int len, QPainter::TextDirection dir)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(point, text, len, dir);
+    }
+}
+
+void KisCanvasPainter::drawText(int x, int y, const QString& text, int pos, int len, QPainter::TextDirection dir)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(x, y, text, pos, len, dir);
+    }
+}
+
+void KisCanvasPainter::drawText(const QPoint& point, const QString& text, int pos, int len, QPainter::TextDirection dir)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(point, text, pos, len, dir);
+    }
+}
+
+void KisCanvasPainter::drawText(int x, int y, int w, int h, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(x, y, w, h, flags, text, len, br, intern);
+    }
+}
+
+void KisCanvasPainter::drawText(const QRect& r, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawText(r, flags, text, len, br, intern);
+    }
+}
+
+void KisCanvasPainter::drawTextItem(int x, int y, const QTextItem& ti, int textflags)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawTextItem(x, y, ti, textflags);
+    }
+}
+
+void KisCanvasPainter::drawTextItem(const QPoint& p, const QTextItem& ti, int textflags)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->drawTextItem(p, ti, textflags);
+    }
+}
+
+QRect KisCanvasPainter::boundingRect(int x, int y, int w, int h, int flags, const QString& text, int len, QTextParag **intern)
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->boundingRect(x, y, w, h, flags, text, len, intern);
+    }
+    return QRect();
+}
+
+QRect KisCanvasPainter::boundingRect(const QRect& r, int flags, const QString& text, int len, QTextParag **intern)
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->boundingRect(r, flags, text, len, intern);
+    }
+    return QRect();
+}
+
+int	KisCanvasPainter::tabStops() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->tabStops();
+    }
+    return 0;
+}
+
+void KisCanvasPainter::setTabStops(int ts)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setTabStops(ts);
+    }
+}
+
+int	*KisCanvasPainter::tabArray() const
+{
+    if (m_canvasWidgetPainter != 0) {
+        return m_canvasWidgetPainter->tabArray();
+    }
+    return 0;
+}
+
+void KisCanvasPainter::setTabArray(int *ts)
+{
+    if (m_canvasWidgetPainter != 0) {
+        m_canvasWidgetPainter->setTabArray(ts);
+    }
+}
+