krita

kis_canvas_painter.cc

00001 /*
00002  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.com>
00003  *
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU General Public License for more details.g
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00017  */
00018 
00019 #include "kis_canvas.h"
00020 #include "kis_canvas_painter.h"
00021 #include "kis_qpaintdevice_canvas_painter.h"
00022 
00023 KisCanvasWidgetPainter::KisCanvasWidgetPainter()
00024 {
00025 }
00026 
00027 KisCanvasWidgetPainter::~KisCanvasWidgetPainter()
00028 {
00029 }
00030 
00031 bool KisCanvasWidgetPainter::end()
00032 {
00033     return true;
00034 }
00035 
00036 void KisCanvasWidgetPainter::save()
00037 {
00038 }
00039 
00040 void KisCanvasWidgetPainter::restore()
00041 {
00042 }
00043 
00044 QFontMetrics KisCanvasWidgetPainter::fontMetrics() const
00045 {
00046     return QFontMetrics(QFont());
00047 }
00048 
00049 QFontInfo KisCanvasWidgetPainter::fontInfo() const
00050 {
00051     return QFontInfo(QFont());
00052 }
00053 
00054 const QFont& KisCanvasWidgetPainter::font() const
00055 {
00056     return m_defaultFont;
00057 }
00058 
00059 void KisCanvasWidgetPainter::setFont(const QFont& /*font*/)
00060 {
00061 }
00062 
00063 const QPen& KisCanvasWidgetPainter::pen() const
00064 {
00065     return m_defaultPen;
00066 }
00067 
00068 void KisCanvasWidgetPainter::setPen(const QPen& /*pen*/)
00069 {
00070 }
00071 
00072 void KisCanvasWidgetPainter::setPen(Qt::PenStyle /*penStyle*/)
00073 {
00074 }
00075 
00076 void KisCanvasWidgetPainter::setPen(const QColor& /*color*/)
00077 {
00078 }
00079 
00080 const QBrush& KisCanvasWidgetPainter::brush() const
00081 {
00082     return m_defaultBrush;
00083 }
00084 
00085 void KisCanvasWidgetPainter::setBrush(const QBrush& /*brush*/)
00086 {
00087 }
00088 
00089 void KisCanvasWidgetPainter::setBrush(Qt::BrushStyle /*brushStyle*/)
00090 {
00091 }
00092 
00093 void KisCanvasWidgetPainter::setBrush(const QColor& /*color*/)
00094 {
00095 }
00096 
00097 QPoint KisCanvasWidgetPainter::pos() const
00098 {
00099     return QPoint();
00100 }
00101 
00102 const QColor& KisCanvasWidgetPainter::backgroundColor() const
00103 {
00104     return m_defaultColor;
00105 }
00106 
00107 void KisCanvasWidgetPainter::setBackgroundColor(const QColor& /*color*/)
00108 {
00109 }
00110 
00111 Qt::Qt::BGMode KisCanvasWidgetPainter::backgroundMode() const
00112 {
00113     return Qt::TransparentMode;
00114 }
00115 
00116 void KisCanvasWidgetPainter::setBackgroundMode(Qt::Qt::BGMode /*bgMode*/)
00117 {
00118 }
00119 
00120 Qt::Qt::RasterOp KisCanvasWidgetPainter::rasterOp() const
00121 {
00122     return Qt::CopyROP;
00123 }
00124 
00125 void KisCanvasWidgetPainter::setRasterOp(Qt::RasterOp /*rasterOp*/)
00126 {
00127 }
00128 
00129 const QPoint& KisCanvasWidgetPainter::brushOrigin() const
00130 {
00131     return m_defaultBrushOrigin;
00132 }
00133 
00134 void KisCanvasWidgetPainter::setBrushOrigin(int /*x*/, int /*y*/)
00135 {
00136 }
00137 
00138 void KisCanvasWidgetPainter::setBrushOrigin(const QPoint& /*origin*/)
00139 {
00140 }
00141 
00142 bool KisCanvasWidgetPainter::hasViewXForm() const
00143 {
00144     return false;
00145 }
00146 
00147 bool KisCanvasWidgetPainter::hasWorldXForm() const
00148 {
00149     return false;
00150 }
00151 
00152 void KisCanvasWidgetPainter::setViewXForm(bool /*enable*/)
00153 {
00154 }
00155 
00156 QRect KisCanvasWidgetPainter::window() const
00157 {
00158     return QRect();
00159 }
00160 
00161 void KisCanvasWidgetPainter::setWindow(const QRect& /*r*/)
00162 {
00163 }
00164 
00165 void KisCanvasWidgetPainter::setWindow(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00166 {
00167 }
00168 
00169 QRect KisCanvasWidgetPainter::viewport() const
00170 {
00171     return QRect();
00172 }
00173 
00174 void KisCanvasWidgetPainter::setViewport(const QRect& /*r*/)
00175 {
00176 }
00177 
00178 void KisCanvasWidgetPainter::setViewport(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00179 {
00180 }
00181 
00182 
00183 void KisCanvasWidgetPainter::setWorldXForm(bool /*enable*/)
00184 {
00185 }
00186 
00187 const QWMatrix& KisCanvasWidgetPainter::worldMatrix() const
00188 {
00189     return m_defaultWorldMatrix;
00190 }
00191 
00192 void KisCanvasWidgetPainter::setWorldMatrix(const QWMatrix& /*matrix*/, bool /*combine*/)
00193 {
00194 }
00195 
00196 void KisCanvasWidgetPainter::saveWorldMatrix()
00197 {
00198 }
00199 
00200 void KisCanvasWidgetPainter::restoreWorldMatrix()
00201 {
00202 }
00203 
00204 void KisCanvasWidgetPainter::scale(double /*sx*/, double /*sy*/)
00205 {
00206 }
00207 
00208 void KisCanvasWidgetPainter::shear(double /*sh*/, double /*sv*/)
00209 {
00210 }
00211 
00212 void KisCanvasWidgetPainter::rotate(double /*a*/)
00213 {
00214 }
00215 
00216 void KisCanvasWidgetPainter::translate(double /*dx*/, double /*dy*/)
00217 {
00218 }
00219 
00220 void KisCanvasWidgetPainter::resetXForm()
00221 {
00222 }
00223 
00224 double KisCanvasWidgetPainter::translationX() const
00225 {
00226     return 0;
00227 }
00228 
00229 double KisCanvasWidgetPainter::translationY() const
00230 {
00231     return 0;
00232 }
00233 
00234 QPoint KisCanvasWidgetPainter::xForm(const QPoint& point) const
00235 {
00236     return point;
00237 }
00238 
00239 QRect KisCanvasWidgetPainter::xForm(const QRect& r) const
00240 {
00241     return r;
00242 }
00243 
00244 QPointArray KisCanvasWidgetPainter::xForm(const QPointArray& pointArray) const
00245 {
00246     return pointArray;
00247 }
00248 
00249 QPointArray KisCanvasWidgetPainter::xForm(const QPointArray& pointArray, int /*index*/, int /*npoints*/) const
00250 {
00251     return pointArray;
00252 }
00253 
00254 QPoint KisCanvasWidgetPainter::xFormDev(const QPoint& point) const
00255 {
00256     return point;
00257 }
00258 
00259 QRect KisCanvasWidgetPainter::xFormDev(const QRect& r) const
00260 {
00261     return r;
00262 }
00263 
00264 QPointArray KisCanvasWidgetPainter::xFormDev(const QPointArray& pointArray) const
00265 {
00266     return pointArray;
00267 }
00268 
00269 QPointArray KisCanvasWidgetPainter::xFormDev(const QPointArray& pointArray, int /*index*/, int /*npoints*/) const
00270 {
00271     return pointArray;
00272 }
00273 
00274 void KisCanvasWidgetPainter::setClipping(bool /*enable*/)
00275 {
00276 }
00277 
00278 bool KisCanvasWidgetPainter::hasClipping() const
00279 {
00280     return true;
00281 }
00282 
00283 QRegion KisCanvasWidgetPainter::clipRegion(QPainter::CoordinateMode /*mode*/) const
00284 {
00285     return QRegion();
00286 }
00287 
00288 void KisCanvasWidgetPainter::setClipRect(const QRect& /*r*/, QPainter::CoordinateMode /*mode*/)
00289 {
00290 }
00291 
00292 void KisCanvasWidgetPainter::setClipRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, QPainter::CoordinateMode /*mode*/)
00293 {
00294 }
00295 
00296 void KisCanvasWidgetPainter::setClipRegion(const QRegion& /*rgn*/, QPainter::CoordinateMode /*mode*/)
00297 {
00298 }
00299 
00300 void KisCanvasWidgetPainter::drawPoint(int /*x*/, int /*y*/)
00301 {
00302 }
00303 
00304 void KisCanvasWidgetPainter::drawPoint(const QPoint& /*point*/)
00305 {
00306 }
00307 
00308 void KisCanvasWidgetPainter::drawPoints(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
00309 {
00310 }
00311 
00312 void KisCanvasWidgetPainter::moveTo(int /*x*/, int /*y*/)
00313 {
00314 }
00315 
00316 void KisCanvasWidgetPainter::moveTo(const QPoint& /*point*/)
00317 {
00318 }
00319 
00320 void KisCanvasWidgetPainter::lineTo(int /*x*/, int /*y*/)
00321 {
00322 }
00323 
00324 void KisCanvasWidgetPainter::lineTo(const QPoint& /*point*/)
00325 {
00326 }
00327 
00328 void KisCanvasWidgetPainter::drawLine(int /*x1*/, int /*y1*/, int /*x2*/, int /*y2*/)
00329 {
00330 }
00331 
00332 void KisCanvasWidgetPainter::drawLine(const QPoint& /*start*/, const QPoint& /*end*/)
00333 {
00334 }
00335 
00336 void KisCanvasWidgetPainter::drawRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00337 {
00338 }
00339 
00340 void KisCanvasWidgetPainter::drawRect(const QRect& /*r*/)
00341 {
00342 }
00343 
00344 void KisCanvasWidgetPainter::drawWinFocusRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00345 {
00346 }
00347 
00348 void KisCanvasWidgetPainter::drawWinFocusRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QColor& /*bgColor*/)
00349 {
00350 }
00351 
00352 void KisCanvasWidgetPainter::drawWinFocusRect(const QRect& /*r*/)
00353 {
00354 }
00355 
00356 void KisCanvasWidgetPainter::drawWinFocusRect(const QRect& /*r*/, const QColor& /*bgColor*/)
00357 {
00358 }
00359 
00360 void KisCanvasWidgetPainter::drawRoundRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*xRnd*/, int /*yRnd*/)
00361 {
00362 }
00363 
00364 void KisCanvasWidgetPainter::drawRoundRect(const QRect& /*r*/, int /*xRnd*/, int /*yRnd*/)
00365 {
00366 }
00367 
00368 void KisCanvasWidgetPainter::drawEllipse(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00369 {
00370 }
00371 
00372 void KisCanvasWidgetPainter::drawEllipse(const QRect& /*r*/)
00373 {
00374 }
00375 
00376 void KisCanvasWidgetPainter::drawArc(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
00377 {
00378 }
00379 
00380 void KisCanvasWidgetPainter::drawArc(const QRect& /*r*/, int /*a*/, int /*alen*/)
00381 {
00382 }
00383 
00384 void KisCanvasWidgetPainter::drawPie(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
00385 {
00386 }
00387 
00388 void KisCanvasWidgetPainter::drawPie(const QRect& /*r*/, int /*a*/, int /*alen*/)
00389 {
00390 }
00391 
00392 void KisCanvasWidgetPainter::drawChord(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*a*/, int /*alen*/)
00393 {
00394 }
00395 
00396 void KisCanvasWidgetPainter::drawChord(const QRect& /*r*/, int /*a*/, int /*alen*/)
00397 {
00398 }
00399 
00400 void KisCanvasWidgetPainter::drawLineSegments(const QPointArray& /*pointArray*/, int /*index*/, int /*nlines*/)
00401 {
00402 }
00403 
00404 void KisCanvasWidgetPainter::drawPolyline(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
00405 {
00406 }
00407 
00408 void KisCanvasWidgetPainter::drawPolygon(const QPointArray& /*pointArray*/, bool /*winding*/, int /*index*/, int /*npoints*/)
00409 {
00410 }
00411 
00412 void KisCanvasWidgetPainter::drawConvexPolygon(const QPointArray& /*pointArray*/, int /*index*/, int /*npoints*/)
00413 {
00414 }
00415 
00416 void KisCanvasWidgetPainter::drawCubicBezier(const QPointArray& /*pointArray*/, int /*index*/)
00417 {
00418 }
00419 
00420 void KisCanvasWidgetPainter::drawPixmap(int /*x*/, int /*y*/, const QPixmap& /*pixmap*/, int /*sx*/, int /*sy*/, int /*sw*/, int /*sh*/)
00421 {
00422 }
00423 
00424 void KisCanvasWidgetPainter::drawPixmap(const QPoint& /*point*/, const QPixmap& /*pixmap*/, const QRect& /*sr*/)
00425 {
00426 }
00427 
00428 void KisCanvasWidgetPainter::drawPixmap(const QPoint& /*point*/, const QPixmap& /*pixmap*/)
00429 {
00430 }
00431 
00432 void KisCanvasWidgetPainter::drawPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/)
00433 {
00434 }
00435 
00436 void KisCanvasWidgetPainter::drawImage(int /*x*/, int /*y*/, const QImage& /*image*/, int /*sx*/, int /*sy*/, int /*sw*/, int /*sh*/, int /*conversionFlags*/)
00437 {
00438 }
00439 
00440 void KisCanvasWidgetPainter::drawImage(const QPoint& /*point*/, const QImage& /*image*/, const QRect& /*sr*/, int /*conversionFlags*/)
00441 {
00442 }
00443 
00444 void KisCanvasWidgetPainter::drawImage(const QPoint& /*point*/, const QImage& /*image*/, int /*conversion_flags*/)
00445 {
00446 }
00447 
00448 void KisCanvasWidgetPainter::drawImage(const QRect& /*r*/, const QImage& /*image*/)
00449 {
00450 }
00451 
00452 void KisCanvasWidgetPainter::drawTiledPixmap(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QPixmap& /*pixmap*/, int /*sx*/, int /*sy*/)
00453 {
00454 }
00455 
00456 void KisCanvasWidgetPainter::drawTiledPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/, const QPoint& /*point*/)
00457 {
00458 }
00459 
00460 void KisCanvasWidgetPainter::drawTiledPixmap(const QRect& /*r*/, const QPixmap& /*pixmap*/)
00461 {
00462 }
00463 
00464 void KisCanvasWidgetPainter::fillRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, const QBrush& /*brush*/)
00465 {
00466 }
00467 
00468 void KisCanvasWidgetPainter::fillRect(const QRect& /*r*/, const QBrush& /*brush*/)
00469 {
00470 }
00471 
00472 void KisCanvasWidgetPainter::eraseRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/)
00473 {
00474 }
00475 
00476 void KisCanvasWidgetPainter::eraseRect(const QRect& /*r*/)
00477 {
00478 }
00479 
00480 void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, const QString& /*text*/, int /*len*/, QPainter::TextDirection /*dir*/)
00481 {
00482 }
00483 
00484 void KisCanvasWidgetPainter::drawText(const QPoint& /*point*/, const QString& /*text*/, int /*len*/, QPainter::TextDirection /*dir*/)
00485 {
00486 }
00487 
00488 void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, const QString& /*text*/, int /*pos*/, int /*len*/, QPainter::TextDirection /*dir*/)
00489 {
00490 }
00491 
00492 void KisCanvasWidgetPainter::drawText(const QPoint& /*point*/, const QString& /*text*/, int /*pos*/, int /*len*/, QPainter::TextDirection /*dir*/)
00493 {
00494 }
00495 
00496 void KisCanvasWidgetPainter::drawText(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*flags*/, const QString& /*text*/, int /*len*/, QRect */*br*/, QTextParag **/*intern*/)
00497 {
00498 }
00499 
00500 void KisCanvasWidgetPainter::drawText(const QRect& /*r*/, int /*flags*/, const QString& /*text*/, int /*len*/, QRect */*br*/, QTextParag **/*intern*/)
00501 {
00502 }
00503 
00504 void KisCanvasWidgetPainter::drawTextItem(int /*x*/, int /*y*/, const QTextItem& /*ti*/, int /*textflags*/)
00505 {
00506 }
00507 
00508 void KisCanvasWidgetPainter::drawTextItem(const QPoint& /*p*/, const QTextItem& /*ti*/, int /*textflags*/)
00509 {
00510 }
00511 
00512 QRect KisCanvasWidgetPainter::boundingRect(int /*x*/, int /*y*/, int /*w*/, int /*h*/, int /*flags*/, const QString& /*text*/, int /*len*/, QTextParag **/*intern*/)
00513 {
00514     return QRect();
00515 }
00516 
00517 QRect KisCanvasWidgetPainter::boundingRect(const QRect& /*r*/, int /*flags*/, const QString& /*text*/, int /*len*/, QTextParag **/*intern*/)
00518 {
00519     return QRect();
00520 }
00521 
00522 int KisCanvasWidgetPainter::tabStops() const
00523 {
00524     return 0;
00525 }
00526 
00527 void KisCanvasWidgetPainter::setTabStops(int /*ts*/)
00528 {
00529 }
00530 
00531 int *KisCanvasWidgetPainter::tabArray() const
00532 {
00533     return 0;
00534 }
00535 
00536 void KisCanvasWidgetPainter::setTabArray(int */*ts*/)
00537 {
00538 }
00539 
00540 /*************************************************************************/
00541 
00542 KisCanvasPainter::KisCanvasPainter()
00543 {
00544     m_canvasWidgetPainter = 0;
00545 }
00546 
00547 KisCanvasPainter::KisCanvasPainter(KisCanvas *canvas)
00548 {
00549     m_canvasWidgetPainter = canvas->createPainter();
00550 }
00551 
00552 KisCanvasPainter::KisCanvasPainter(const QPaintDevice *paintDevice)
00553 {
00554     m_canvasWidgetPainter = new KisQPaintDeviceCanvasPainter(paintDevice);
00555 }
00556 
00557 KisCanvasPainter::~KisCanvasPainter()
00558 {
00559     delete m_canvasWidgetPainter;
00560 }
00561 
00562 bool KisCanvasPainter::begin(KisCanvas *canvas, bool unclipped)
00563 {
00564     delete m_canvasWidgetPainter;
00565     m_canvasWidgetPainter = canvas->createPainter();
00566     return m_canvasWidgetPainter->begin(canvas->canvasWidget(), unclipped);
00567 }
00568 
00569 bool KisCanvasPainter::begin(const QPaintDevice *paintDevice, bool unclipped)
00570 {
00571     delete m_canvasWidgetPainter;
00572     m_canvasWidgetPainter = new KisQPaintDeviceCanvasPainter();
00573     return static_cast<KisQPaintDeviceCanvasPainter *>(m_canvasWidgetPainter)->begin(paintDevice, unclipped);
00574 }
00575 
00576 bool KisCanvasPainter::end()
00577 {
00578     if (m_canvasWidgetPainter != 0) {
00579         return m_canvasWidgetPainter->end();
00580     }
00581     return false;
00582 }
00583 
00584 void KisCanvasPainter::save()
00585 {
00586     if (m_canvasWidgetPainter != 0) {
00587         m_canvasWidgetPainter->save();
00588     }
00589 }
00590 
00591 void KisCanvasPainter::restore()
00592 {
00593     if (m_canvasWidgetPainter != 0) {
00594         m_canvasWidgetPainter->restore();
00595     }
00596 }
00597 
00598 QFontMetrics KisCanvasPainter::fontMetrics() const
00599 {
00600     if (m_canvasWidgetPainter != 0) {
00601         return m_canvasWidgetPainter->fontMetrics();
00602     }
00603     return QFontMetrics(QFont());
00604 }
00605 
00606 QFontInfo KisCanvasPainter::fontInfo() const
00607 {
00608     if (m_canvasWidgetPainter != 0) {
00609         return m_canvasWidgetPainter->fontInfo();
00610     }
00611     return QFontInfo(QFont());
00612 }
00613 
00614 const QFont& KisCanvasPainter::font() const
00615 {
00616     if (m_canvasWidgetPainter != 0) {
00617         return m_canvasWidgetPainter->font();
00618     }
00619     return m_defaultFont;
00620 }
00621 
00622 void KisCanvasPainter::setFont(const QFont& font)
00623 {
00624     if (m_canvasWidgetPainter != 0) {
00625         m_canvasWidgetPainter->setFont(font);
00626     }
00627 }
00628 
00629 const QPen& KisCanvasPainter::pen() const
00630 {
00631     if (m_canvasWidgetPainter != 0) {
00632         return m_canvasWidgetPainter->pen();
00633     }
00634     return m_defaultPen;
00635 }
00636 
00637 void KisCanvasPainter::setPen(const QPen& pen)
00638 {
00639     if (m_canvasWidgetPainter != 0) {
00640         m_canvasWidgetPainter->setPen(pen);
00641     }
00642 }
00643 
00644 void KisCanvasPainter::setPen(Qt::PenStyle penStyle)
00645 {
00646     if (m_canvasWidgetPainter != 0) {
00647         m_canvasWidgetPainter->setPen(penStyle);
00648     }
00649 }
00650 
00651 void KisCanvasPainter::setPen(const QColor& color)
00652 {
00653     if (m_canvasWidgetPainter != 0) {
00654         m_canvasWidgetPainter->setPen(color);;
00655     }
00656 }
00657 
00658 const QBrush& KisCanvasPainter::brush() const
00659 {
00660     if (m_canvasWidgetPainter != 0) {
00661         return m_canvasWidgetPainter->brush();
00662     }
00663     return m_defaultBrush;
00664 }
00665 
00666 void KisCanvasPainter::setBrush(const QBrush& brush)
00667 {
00668     if (m_canvasWidgetPainter != 0) {
00669         m_canvasWidgetPainter->setBrush(brush);
00670     }
00671 }
00672 
00673 void KisCanvasPainter::setBrush(Qt::BrushStyle brushStyle)
00674 {
00675     if (m_canvasWidgetPainter != 0) {
00676         m_canvasWidgetPainter->setBrush(brushStyle);
00677     }
00678 }
00679 
00680 void KisCanvasPainter::setBrush(const QColor& color)
00681 {
00682     if (m_canvasWidgetPainter != 0) {
00683         m_canvasWidgetPainter->setBrush(color);
00684     }
00685 }
00686 
00687 QPoint KisCanvasPainter::pos() const
00688 {
00689     if (m_canvasWidgetPainter != 0) {
00690         return m_canvasWidgetPainter->pos();
00691     }
00692     return QPoint();
00693 }
00694 
00695 const QColor& KisCanvasPainter::backgroundColor() const
00696 {
00697     if (m_canvasWidgetPainter != 0) {
00698         return m_canvasWidgetPainter->backgroundColor();
00699     }
00700     return m_defaultColor;
00701 }
00702 
00703 void KisCanvasPainter::setBackgroundColor(const QColor& color)
00704 {
00705     if (m_canvasWidgetPainter != 0) {
00706         m_canvasWidgetPainter->setBackgroundColor(color);
00707     }
00708 }
00709 
00710 Qt::BGMode KisCanvasPainter::backgroundMode() const
00711 {
00712     if (m_canvasWidgetPainter != 0) {
00713         return m_canvasWidgetPainter->backgroundMode();
00714     }
00715     return Qt::TransparentMode;
00716 }
00717 
00718 void KisCanvasPainter::setBackgroundMode(Qt::BGMode bgMode)
00719 {
00720     if (m_canvasWidgetPainter != 0) {
00721         m_canvasWidgetPainter->setBackgroundMode(bgMode);
00722     }
00723 }
00724 
00725 Qt::RasterOp KisCanvasPainter::rasterOp() const
00726 {
00727     if (m_canvasWidgetPainter != 0) {
00728         return m_canvasWidgetPainter->rasterOp();
00729     }
00730     return Qt::CopyROP;
00731 }
00732 
00733 void KisCanvasPainter::setRasterOp(Qt::RasterOp rasterOp)
00734 {
00735     if (m_canvasWidgetPainter != 0) {
00736         m_canvasWidgetPainter->setRasterOp(rasterOp);
00737     }
00738 }
00739 
00740 const QPoint& KisCanvasPainter::brushOrigin() const
00741 {
00742     if (m_canvasWidgetPainter != 0) {
00743         return m_canvasWidgetPainter->brushOrigin();
00744     }
00745     return m_defaultBrushOrigin;
00746 }
00747 
00748 void KisCanvasPainter::setBrushOrigin(int x, int y)
00749 {
00750     if (m_canvasWidgetPainter != 0) {
00751         m_canvasWidgetPainter->setBrushOrigin(x, y);
00752     }
00753 }
00754 
00755 void KisCanvasPainter::setBrushOrigin(const QPoint& origin)
00756 {
00757     if (m_canvasWidgetPainter != 0) {
00758         m_canvasWidgetPainter->setBrushOrigin(origin);
00759     }
00760 }
00761 
00762 bool KisCanvasPainter::hasViewXForm() const
00763 {
00764     if (m_canvasWidgetPainter != 0) {
00765         return m_canvasWidgetPainter->hasViewXForm();
00766     }
00767     return false;
00768 }
00769 
00770 bool KisCanvasPainter::hasWorldXForm() const
00771 {
00772     if (m_canvasWidgetPainter != 0) {
00773         return m_canvasWidgetPainter->hasWorldXForm();
00774     }
00775     return false;
00776 }
00777 
00778 void KisCanvasPainter::setViewXForm(bool enable)
00779 {
00780     if (m_canvasWidgetPainter != 0) {
00781         m_canvasWidgetPainter->setViewXForm(enable);
00782     }
00783 }
00784 
00785 QRect KisCanvasPainter::window() const
00786 {
00787     if (m_canvasWidgetPainter != 0) {
00788         return m_canvasWidgetPainter->window();
00789     }
00790     return QRect();
00791 }
00792 
00793 void KisCanvasPainter::setWindow(const QRect& r)
00794 {
00795     if (m_canvasWidgetPainter != 0) {
00796         m_canvasWidgetPainter->setWindow(r);
00797     }
00798 }
00799 
00800 void KisCanvasPainter::setWindow(int x, int y, int w, int h)
00801 {
00802     if (m_canvasWidgetPainter != 0) {
00803         m_canvasWidgetPainter->setWindow(x, y, w, h);
00804     }
00805 }
00806 
00807 QRect KisCanvasPainter::viewport() const
00808 {
00809     if (m_canvasWidgetPainter != 0) {
00810         return m_canvasWidgetPainter->viewport();
00811     }
00812     return QRect();
00813 }
00814 
00815 void KisCanvasPainter::setViewport(const QRect& r)
00816 {
00817     if (m_canvasWidgetPainter != 0) {
00818         m_canvasWidgetPainter->setViewport(r);
00819     }
00820 }
00821 
00822 void KisCanvasPainter::setViewport(int x, int y, int w, int h)
00823 {
00824     if (m_canvasWidgetPainter != 0) {
00825         m_canvasWidgetPainter->setViewport(x, y, w, h);
00826     }
00827 }
00828 
00829 void KisCanvasPainter::setWorldXForm(bool enable)
00830 {
00831     if (m_canvasWidgetPainter != 0) {
00832         m_canvasWidgetPainter->setWorldXForm(enable);
00833     }
00834 }
00835 
00836 const QWMatrix& KisCanvasPainter::worldMatrix() const
00837 {
00838     if (m_canvasWidgetPainter != 0) {
00839         return m_canvasWidgetPainter->worldMatrix();
00840     }
00841     return m_defaultWorldMatrix;
00842 }
00843 
00844 void KisCanvasPainter::setWorldMatrix(const QWMatrix& matrix, bool combine)
00845 {
00846     if (m_canvasWidgetPainter != 0) {
00847         m_canvasWidgetPainter->setWorldMatrix(matrix, combine);
00848     }
00849 }
00850 
00851 void KisCanvasPainter::saveWorldMatrix()
00852 {
00853     if (m_canvasWidgetPainter != 0) {
00854         m_canvasWidgetPainter->saveWorldMatrix();
00855     }
00856 }
00857 
00858 void KisCanvasPainter::restoreWorldMatrix()
00859 {
00860     if (m_canvasWidgetPainter != 0) {
00861         m_canvasWidgetPainter->restoreWorldMatrix();
00862     }
00863 }
00864 
00865 void KisCanvasPainter::scale(double sx, double sy)
00866 {
00867     if (m_canvasWidgetPainter != 0) {
00868         m_canvasWidgetPainter->scale(sx, sy);
00869     }
00870 }
00871 
00872 void KisCanvasPainter::shear(double sh, double sv)
00873 {
00874     if (m_canvasWidgetPainter != 0) {
00875         m_canvasWidgetPainter->shear(sh, sv);
00876     }
00877 }
00878 
00879 void KisCanvasPainter::rotate(double a)
00880 {
00881     if (m_canvasWidgetPainter != 0) {
00882         m_canvasWidgetPainter->rotate(a);
00883     }
00884 }
00885 
00886 void KisCanvasPainter::translate(double dx, double dy)
00887 {
00888     if (m_canvasWidgetPainter != 0) {
00889         m_canvasWidgetPainter->translate(dx, dy);
00890     }
00891 }
00892 
00893 void KisCanvasPainter::resetXForm()
00894 {
00895     if (m_canvasWidgetPainter != 0) {
00896         m_canvasWidgetPainter->resetXForm();
00897     }
00898 }
00899 
00900 double KisCanvasPainter::translationX() const
00901 {
00902     if (m_canvasWidgetPainter != 0) {
00903         return m_canvasWidgetPainter->translationX();
00904     }
00905     return 0;
00906 }
00907 
00908 double KisCanvasPainter::translationY() const
00909 {
00910     if (m_canvasWidgetPainter != 0) {
00911         return m_canvasWidgetPainter->translationY();
00912     }
00913     return 0;
00914 }
00915 
00916 QPoint KisCanvasPainter::xForm(const QPoint& point) const
00917 {
00918     if (m_canvasWidgetPainter != 0) {
00919         return m_canvasWidgetPainter->xForm(point);
00920     }
00921     return point;
00922 }
00923 
00924 QRect KisCanvasPainter::xForm(const QRect& r) const
00925 {
00926     if (m_canvasWidgetPainter != 0) {
00927         return m_canvasWidgetPainter->xForm(r);
00928     }
00929     return r;
00930 }
00931 
00932 QPointArray KisCanvasPainter::xForm(const QPointArray& pointArray) const
00933 {
00934     if (m_canvasWidgetPainter != 0) {
00935         return m_canvasWidgetPainter->xForm(pointArray);
00936     }
00937     return pointArray;
00938 }
00939 
00940 QPointArray KisCanvasPainter::xForm(const QPointArray& pointArray, int index, int npoints) const
00941 {
00942     if (m_canvasWidgetPainter != 0) {
00943         return m_canvasWidgetPainter->xForm(pointArray, index, npoints);
00944     }
00945     return pointArray;
00946 }
00947 
00948 QPoint KisCanvasPainter::xFormDev(const QPoint& point) const
00949 {
00950     if (m_canvasWidgetPainter != 0) {
00951         return m_canvasWidgetPainter->xFormDev(point);
00952     }
00953     return point;
00954 }
00955 
00956 QRect KisCanvasPainter::xFormDev(const QRect& r) const
00957 {
00958     if (m_canvasWidgetPainter != 0) {
00959         return m_canvasWidgetPainter->xFormDev(r);
00960     }
00961     return r;
00962 }
00963 
00964 QPointArray KisCanvasPainter::xFormDev(const QPointArray& pointArray) const
00965 {
00966     if (m_canvasWidgetPainter != 0) {
00967         return m_canvasWidgetPainter->xFormDev(pointArray);
00968     }
00969     return pointArray;
00970 }
00971 
00972 QPointArray KisCanvasPainter::xFormDev(const QPointArray& pointArray, int index, int npoints) const
00973 {
00974     if (m_canvasWidgetPainter != 0) {
00975         return m_canvasWidgetPainter->xFormDev(pointArray, index, npoints);
00976     }
00977     return pointArray;
00978 }
00979 
00980 void KisCanvasPainter::setClipping(bool enable)
00981 {
00982     if (m_canvasWidgetPainter != 0) {
00983         m_canvasWidgetPainter->setClipping(enable);
00984     }
00985 }
00986 
00987 bool KisCanvasPainter::hasClipping() const
00988 {
00989     if (m_canvasWidgetPainter != 0) {
00990         return m_canvasWidgetPainter->hasClipping();
00991     }
00992     return true;
00993 }
00994 
00995 QRegion KisCanvasPainter::clipRegion(QPainter::CoordinateMode mode) const
00996 {
00997     if (m_canvasWidgetPainter != 0) {
00998         return m_canvasWidgetPainter->clipRegion(mode);
00999     }
01000     return QRegion();
01001 }
01002 
01003 void KisCanvasPainter::setClipRect(const QRect& r, QPainter::CoordinateMode mode)
01004 {
01005     if (m_canvasWidgetPainter != 0) {
01006         m_canvasWidgetPainter->setClipRect(r, mode);
01007     }
01008 }
01009 
01010 void KisCanvasPainter::setClipRect(int x, int y, int w, int h, QPainter::CoordinateMode mode)
01011 {
01012     if (m_canvasWidgetPainter != 0) {
01013         m_canvasWidgetPainter->setClipRect(x, y, w, h, mode);
01014     }
01015 }
01016 
01017 void KisCanvasPainter::setClipRegion(const QRegion& rgn, QPainter::CoordinateMode mode)
01018 {
01019     if (m_canvasWidgetPainter != 0) {
01020         m_canvasWidgetPainter->setClipRegion(rgn, mode);
01021     }
01022 }
01023 
01024 void KisCanvasPainter::drawPoint(int x, int y)
01025 {
01026     if (m_canvasWidgetPainter != 0) {
01027         m_canvasWidgetPainter->drawPoint(x, y);
01028     }
01029 }
01030 
01031 void KisCanvasPainter::drawPoint(const QPoint& point)
01032 {
01033     if (m_canvasWidgetPainter != 0) {
01034         m_canvasWidgetPainter->drawPoint(point);
01035     }
01036 }
01037 
01038 void KisCanvasPainter::drawPoints(const QPointArray& pointArray, int index, int npoints)
01039 {
01040     if (m_canvasWidgetPainter != 0) {
01041         m_canvasWidgetPainter->drawPoints(pointArray, index, npoints);
01042     }
01043 }
01044 
01045 void KisCanvasPainter::moveTo(int x, int y)
01046 {
01047     if (m_canvasWidgetPainter != 0) {
01048         m_canvasWidgetPainter->moveTo(x, y);
01049     }
01050 }
01051 
01052 void KisCanvasPainter::moveTo(const QPoint& point)
01053 {
01054     if (m_canvasWidgetPainter != 0) {
01055         m_canvasWidgetPainter->moveTo(point);
01056     }
01057 }
01058 
01059 void KisCanvasPainter::lineTo(int x, int y)
01060 {
01061     if (m_canvasWidgetPainter != 0) {
01062         m_canvasWidgetPainter->lineTo(x, y);
01063     }
01064 }
01065 
01066 void KisCanvasPainter::lineTo(const QPoint& point)
01067 {
01068     if (m_canvasWidgetPainter != 0) {
01069         m_canvasWidgetPainter->lineTo(point);
01070     }
01071 }
01072 
01073 void KisCanvasPainter::drawLine(int x1, int y1, int x2, int y2)
01074 {
01075     if (m_canvasWidgetPainter != 0) {
01076         m_canvasWidgetPainter->drawLine(x1, y1, x2, y2);
01077     }
01078 }
01079 
01080 void KisCanvasPainter::drawLine(const QPoint& start, const QPoint& end)
01081 {
01082     if (m_canvasWidgetPainter != 0) {
01083         m_canvasWidgetPainter->drawLine(start, end);
01084     }
01085 }
01086 
01087 void KisCanvasPainter::drawRect(int x, int y, int w, int h)
01088 {
01089     if (m_canvasWidgetPainter != 0) {
01090         m_canvasWidgetPainter->drawRect(x, y, w, h);
01091     }
01092 }
01093 
01094 void KisCanvasPainter::drawRect(const QRect& r)
01095 {
01096     if (m_canvasWidgetPainter != 0) {
01097         m_canvasWidgetPainter->drawRect(r);
01098     }
01099 }
01100 
01101 void KisCanvasPainter::drawWinFocusRect(int x, int y, int w, int h)
01102 {
01103     if (m_canvasWidgetPainter != 0) {
01104         m_canvasWidgetPainter->drawWinFocusRect(x, y, w, h);
01105     }
01106 }
01107 
01108 void KisCanvasPainter::drawWinFocusRect(int x, int y, int w, int h, const QColor& bgColor)
01109 {
01110     if (m_canvasWidgetPainter != 0) {
01111         m_canvasWidgetPainter->drawWinFocusRect(x, y, w, h, bgColor);
01112     }
01113 }
01114 
01115 void KisCanvasPainter::drawWinFocusRect(const QRect& r)
01116 {
01117     if (m_canvasWidgetPainter != 0) {
01118         m_canvasWidgetPainter->drawWinFocusRect(r);
01119     }
01120 }
01121 
01122 void KisCanvasPainter::drawWinFocusRect(const QRect& r, const QColor& bgColor)
01123 {
01124     if (m_canvasWidgetPainter != 0) {
01125         m_canvasWidgetPainter->drawWinFocusRect(r, bgColor);
01126     }
01127 }
01128 
01129 void KisCanvasPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
01130 {
01131     if (m_canvasWidgetPainter != 0) {
01132         m_canvasWidgetPainter->drawRoundRect(x, y, w, h, xRnd, yRnd);
01133     }
01134 }
01135 
01136 void KisCanvasPainter::drawRoundRect(const QRect& r, int xRnd, int yRnd)
01137 {
01138     if (m_canvasWidgetPainter != 0) {
01139         m_canvasWidgetPainter->drawRoundRect(r, xRnd, yRnd);
01140     }
01141 }
01142 
01143 void KisCanvasPainter::drawEllipse(int x, int y, int w, int h)
01144 {
01145     if (m_canvasWidgetPainter != 0) {
01146         m_canvasWidgetPainter->drawEllipse(x, y, w, h);
01147     }
01148 }
01149 
01150 void KisCanvasPainter::drawEllipse(const QRect& r)
01151 {
01152     if (m_canvasWidgetPainter != 0) {
01153         m_canvasWidgetPainter->drawEllipse(r);
01154     }
01155 }
01156 
01157 void KisCanvasPainter::drawArc(int x, int y, int w, int h, int a, int alen)
01158 {
01159     if (m_canvasWidgetPainter != 0) {
01160         m_canvasWidgetPainter->drawArc(x, y, w, h, a, alen);
01161     }
01162 }
01163 
01164 void KisCanvasPainter::drawArc(const QRect& r, int a, int alen)
01165 {
01166     if (m_canvasWidgetPainter != 0) {
01167         m_canvasWidgetPainter->drawArc(r, a, alen);
01168     }
01169 }
01170 
01171 void KisCanvasPainter::drawPie(int x, int y, int w, int h, int a, int alen)
01172 {
01173     if (m_canvasWidgetPainter != 0) {
01174         m_canvasWidgetPainter->drawPie(x, y, w, h, a, alen);
01175     }
01176 }
01177 
01178 void KisCanvasPainter::drawPie(const QRect& r, int a, int alen)
01179 {
01180     if (m_canvasWidgetPainter != 0) {
01181         m_canvasWidgetPainter->drawPie(r, a, alen);
01182     }
01183 }
01184 
01185 void KisCanvasPainter::drawChord(int x, int y, int w, int h, int a, int alen)
01186 {
01187     if (m_canvasWidgetPainter != 0) {
01188         m_canvasWidgetPainter->drawChord(x, y, w, h, a, alen);
01189     }
01190 }
01191 
01192 void KisCanvasPainter::drawChord(const QRect& r, int a, int alen)
01193 {
01194     if (m_canvasWidgetPainter != 0) {
01195         m_canvasWidgetPainter->drawChord(r, a, alen);
01196     }
01197 }
01198 
01199 void KisCanvasPainter::drawLineSegments(const QPointArray& pointArray, int index, int nlines)
01200 {
01201     if (m_canvasWidgetPainter != 0) {
01202         m_canvasWidgetPainter->drawLineSegments(pointArray, index, nlines);
01203     }
01204 }
01205 
01206 void KisCanvasPainter::drawPolyline(const QPointArray& pointArray, int index, int npoints)
01207 {
01208     if (m_canvasWidgetPainter != 0) {
01209         m_canvasWidgetPainter->drawPolyline(pointArray, index, npoints);
01210     }
01211 }
01212 
01213 void KisCanvasPainter::drawPolygon(const QPointArray& pointArray, bool winding, int index, int npoints)
01214 {
01215     if (m_canvasWidgetPainter != 0) {
01216         m_canvasWidgetPainter->drawPolygon(pointArray, winding, index, npoints);
01217     }
01218 }
01219 
01220 void KisCanvasPainter::drawConvexPolygon(const QPointArray& pointArray, int index, int npoints)
01221 {
01222     if (m_canvasWidgetPainter != 0) {
01223         m_canvasWidgetPainter->drawConvexPolygon(pointArray, index, npoints);
01224     }
01225 }
01226 
01227 void KisCanvasPainter::drawCubicBezier(const QPointArray& pointArray, int index)
01228 {
01229     if (m_canvasWidgetPainter != 0) {
01230         m_canvasWidgetPainter->drawCubicBezier(pointArray, index);
01231     }
01232 }
01233 
01234 void KisCanvasPainter::drawPixmap(int x, int y, const QPixmap& pixmap, int sx, int sy, int sw, int sh)
01235 {
01236     if (m_canvasWidgetPainter != 0) {
01237         m_canvasWidgetPainter->drawPixmap(x, y, pixmap, sx, sy, sw, sh);
01238     }
01239 }
01240 
01241 void KisCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap, const QRect& sr)
01242 {
01243     if (m_canvasWidgetPainter != 0) {
01244         m_canvasWidgetPainter->drawPixmap(point, pixmap, sr);
01245     }
01246 }
01247 
01248 void KisCanvasPainter::drawPixmap(const QPoint& point, const QPixmap& pixmap)
01249 {
01250     if (m_canvasWidgetPainter != 0) {
01251         m_canvasWidgetPainter->drawPixmap(point, pixmap);
01252     }
01253 }
01254 
01255 void KisCanvasPainter::drawPixmap(const QRect& r, const QPixmap& pixmap)
01256 {
01257     if (m_canvasWidgetPainter != 0) {
01258         m_canvasWidgetPainter->drawPixmap(r, pixmap);
01259     }
01260 }
01261 
01262 void KisCanvasPainter::drawImage(int x, int y, const QImage& image, int sx, int sy, int sw, int sh, int conversionFlags)
01263 {
01264     if (m_canvasWidgetPainter != 0) {
01265         m_canvasWidgetPainter->drawImage(x, y, image, sx, sy, sw, sh, conversionFlags);
01266     }
01267 }
01268 
01269 void KisCanvasPainter::drawImage(const QPoint& point, const QImage& image, const QRect& sr, int conversionFlags)
01270 {
01271     if (m_canvasWidgetPainter != 0) {
01272         m_canvasWidgetPainter->drawImage(point, image, sr, conversionFlags);
01273     }
01274 }
01275 
01276 void KisCanvasPainter::drawImage(const QPoint& point, const QImage& image, int conversion_flags)
01277 {
01278     if (m_canvasWidgetPainter != 0) {
01279         m_canvasWidgetPainter->drawImage(point, image, conversion_flags);
01280     }
01281 }
01282 
01283 void KisCanvasPainter::drawImage(const QRect& r, const QImage& image)
01284 {
01285     if (m_canvasWidgetPainter != 0) {
01286         m_canvasWidgetPainter->drawImage(r, image);
01287     }
01288 }
01289 
01290 void KisCanvasPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap& pixmap, int sx, int sy)
01291 {
01292     if (m_canvasWidgetPainter != 0) {
01293         m_canvasWidgetPainter->drawTiledPixmap(x, y, w, h, pixmap, sx, sy);
01294     }
01295 }
01296 
01297 void KisCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap, const QPoint& point)
01298 {
01299     if (m_canvasWidgetPainter != 0) {
01300         m_canvasWidgetPainter->drawTiledPixmap(r, pixmap, point);
01301     }
01302 }
01303 
01304 void KisCanvasPainter::drawTiledPixmap(const QRect& r, const QPixmap& pixmap)
01305 {
01306     if (m_canvasWidgetPainter != 0) {
01307         m_canvasWidgetPainter->drawTiledPixmap(r, pixmap);
01308     }
01309 }
01310 
01311 void KisCanvasPainter::fillRect(int x, int y, int w, int h, const QBrush& brush)
01312 {
01313     if (m_canvasWidgetPainter != 0) {
01314         m_canvasWidgetPainter->fillRect(x, y, w, h, brush);
01315     }
01316 }
01317 
01318 void KisCanvasPainter::fillRect(const QRect& r, const QBrush& brush)
01319 {
01320     if (m_canvasWidgetPainter != 0) {
01321         m_canvasWidgetPainter->fillRect(r, brush);
01322     }
01323 }
01324 
01325 void KisCanvasPainter::eraseRect(int x, int y, int w, int h)
01326 {
01327     if (m_canvasWidgetPainter != 0) {
01328         m_canvasWidgetPainter->eraseRect(x, y, w, h);
01329     }
01330 }
01331 
01332 void KisCanvasPainter::eraseRect(const QRect& r)
01333 {
01334     if (m_canvasWidgetPainter != 0) {
01335         m_canvasWidgetPainter->eraseRect(r);
01336     }
01337 }
01338 
01339 void KisCanvasPainter::drawText(int x, int y, const QString& text, int len, QPainter::TextDirection dir)
01340 {
01341     if (m_canvasWidgetPainter != 0) {
01342         m_canvasWidgetPainter->drawText(x, y, text, len, dir);
01343     }
01344 }
01345 
01346 void KisCanvasPainter::drawText(const QPoint& point, const QString& text, int len, QPainter::TextDirection dir)
01347 {
01348     if (m_canvasWidgetPainter != 0) {
01349         m_canvasWidgetPainter->drawText(point, text, len, dir);
01350     }
01351 }
01352 
01353 void KisCanvasPainter::drawText(int x, int y, const QString& text, int pos, int len, QPainter::TextDirection dir)
01354 {
01355     if (m_canvasWidgetPainter != 0) {
01356         m_canvasWidgetPainter->drawText(x, y, text, pos, len, dir);
01357     }
01358 }
01359 
01360 void KisCanvasPainter::drawText(const QPoint& point, const QString& text, int pos, int len, QPainter::TextDirection dir)
01361 {
01362     if (m_canvasWidgetPainter != 0) {
01363         m_canvasWidgetPainter->drawText(point, text, pos, len, dir);
01364     }
01365 }
01366 
01367 void KisCanvasPainter::drawText(int x, int y, int w, int h, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
01368 {
01369     if (m_canvasWidgetPainter != 0) {
01370         m_canvasWidgetPainter->drawText(x, y, w, h, flags, text, len, br, intern);
01371     }
01372 }
01373 
01374 void KisCanvasPainter::drawText(const QRect& r, int flags, const QString& text, int len, QRect *br, QTextParag **intern)
01375 {
01376     if (m_canvasWidgetPainter != 0) {
01377         m_canvasWidgetPainter->drawText(r, flags, text, len, br, intern);
01378     }
01379 }
01380 
01381 void KisCanvasPainter::drawTextItem(int x, int y, const QTextItem& ti, int textflags)
01382 {
01383     if (m_canvasWidgetPainter != 0) {
01384         m_canvasWidgetPainter->drawTextItem(x, y, ti, textflags);
01385     }
01386 }
01387 
01388 void KisCanvasPainter::drawTextItem(const QPoint& p, const QTextItem& ti, int textflags)
01389 {
01390     if (m_canvasWidgetPainter != 0) {
01391         m_canvasWidgetPainter->drawTextItem(p, ti, textflags);
01392     }
01393 }
01394 
01395 QRect KisCanvasPainter::boundingRect(int x, int y, int w, int h, int flags, const QString& text, int len, QTextParag **intern)
01396 {
01397     if (m_canvasWidgetPainter != 0) {
01398         return m_canvasWidgetPainter->boundingRect(x, y, w, h, flags, text, len, intern);
01399     }
01400     return QRect();
01401 }
01402 
01403 QRect KisCanvasPainter::boundingRect(const QRect& r, int flags, const QString& text, int len, QTextParag **intern)
01404 {
01405     if (m_canvasWidgetPainter != 0) {
01406         return m_canvasWidgetPainter->boundingRect(r, flags, text, len, intern);
01407     }
01408     return QRect();
01409 }
01410 
01411 int KisCanvasPainter::tabStops() const
01412 {
01413     if (m_canvasWidgetPainter != 0) {
01414         return m_canvasWidgetPainter->tabStops();
01415     }
01416     return 0;
01417 }
01418 
01419 void KisCanvasPainter::setTabStops(int ts)
01420 {
01421     if (m_canvasWidgetPainter != 0) {
01422         m_canvasWidgetPainter->setTabStops(ts);
01423     }
01424 }
01425 
01426 int *KisCanvasPainter::tabArray() const
01427 {
01428     if (m_canvasWidgetPainter != 0) {
01429         return m_canvasWidgetPainter->tabArray();
01430     }
01431     return 0;
01432 }
01433 
01434 void KisCanvasPainter::setTabArray(int *ts)
01435 {
01436     if (m_canvasWidgetPainter != 0) {
01437         m_canvasWidgetPainter->setTabArray(ts);
01438     }
01439 }
01440 
KDE Home | KDE Accessibility Home | Description of Access Keys