• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

Plasma

painter.cpp

Go to the documentation of this file.
00001 /*
00002  *   Copyright 2007 Richard J. Moore <rich@kde.org>
00003  *
00004  *   This program is free software; you can redistribute it and/or modify
00005  *   it under the terms of the GNU Library General Public License version 2 as
00006  *   published by the Free Software Foundation
00007  *
00008  *   This program is distributed in the hope that it will be useful,
00009  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00010  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00011  *   GNU General Public License for more details
00012  *
00013  *   You should have received a copy of the GNU Library General Public
00014  *   License along with this program; if not, write to the
00015  *   Free Software Foundation, Inc.,
00016  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00017  */
00018 
00019 #include <QtScript/QScriptValue>
00020 #include <QtScript/QScriptEngine>
00021 #include <QtScript/QScriptContext>
00022 
00023 #include <QtGui/QPainter>
00024 #include <QtGui/QPicture>
00025 #include <QtGui/QPolygonF>
00026 #include <QtGui/QWidget>
00027 
00028 #include <QtCore/qdebug.h>
00029 
00030 #include "../backportglobal.h"
00031 
00032 Q_DECLARE_METATYPE(QPolygonF)
00033 Q_DECLARE_METATYPE(QPainterPath)
00034 Q_DECLARE_METATYPE(QPainterPath*)
00035 Q_DECLARE_METATYPE(QPicture)
00036 Q_DECLARE_METATYPE(QVector<QRectF>)
00037 Q_DECLARE_METATYPE(QPaintDevice*)
00038 Q_DECLARE_METATYPE(QPaintEngine*)
00039 
00040 DECLARE_POINTER_METATYPE(QPainter)
00041 
00042 static QScriptValue newPainter(QScriptEngine *eng, QPainter *p)
00043 {
00044     return QScript::wrapPointer(eng, p);
00045 }
00046 
00048 
00049 static QScriptValue ctor(QScriptContext *ctx, QScriptEngine *eng)
00050 {
00051     if (ctx->argumentCount() > 0) {
00052         QPaintDevice *device = qscriptvalue_cast<QPaintDevice*>(ctx->argument(0));
00053         return newPainter(eng, new QPainter(device));
00054     } else {
00055         return newPainter(eng, new QPainter());
00056     }
00057 }
00058 
00060 
00061 static QScriptValue background(QScriptContext *ctx, QScriptEngine *eng)
00062 {
00063     DECLARE_SELF(QPainter, background);
00064     return qScriptValueFromValue(eng, self->background());
00065 }
00066 
00068 
00069 static QScriptValue backgroundMode(QScriptContext *ctx, QScriptEngine *eng)
00070 {
00071     DECLARE_SELF(QPainter, backgroundMode);
00072     return QScriptValue(eng, static_cast<int>(self->backgroundMode()));
00073 }
00074 
00076 
00077 static QScriptValue begin(QScriptContext *ctx, QScriptEngine *eng)
00078 {
00079     DECLARE_SELF(QPainter, begin);
00080     QWidget *device = qscriptvalue_cast<QWidget*>(ctx->argument(0));
00081     if (!device) {
00082         return ctx->throwError(QScriptContext::TypeError,
00083                                "QPainter.prototype.begin: argument is not a QWidget");
00084     }
00085     return QScriptValue(eng, self->begin(device));
00086 }
00087 
00089 
00090 static QScriptValue boundingRect(QScriptContext *ctx, QScriptEngine *eng)
00091 {
00092     DECLARE_SELF(QPainter, boundingRect);
00093     QRect result;
00094     if (ctx->argumentCount() == 3) {
00095         result = self->boundingRect(qscriptvalue_cast<QRect>(ctx->argument(0)),
00096                                     ctx->argument(1).toInt32(),
00097                                     ctx->argument(2).toString());
00098     } else if (ctx->argumentCount() == 6) {
00099         result = self->boundingRect(ctx->argument(0).toInt32(),
00100                                     ctx->argument(1).toInt32(),
00101                                     ctx->argument(2).toInt32(),
00102                                     ctx->argument(3).toInt32(),
00103                                     ctx->argument(4).toInt32(),
00104                                     ctx->argument(5).toString());
00105     }
00106     return qScriptValueFromValue(eng, result);
00107 }
00108 
00110 
00111 static QScriptValue brush(QScriptContext *ctx, QScriptEngine *eng)
00112 {
00113     DECLARE_SELF(QPainter, brush);
00114     return qScriptValueFromValue(eng, self->brush());
00115 }
00116 
00118 
00119 static QScriptValue brushOrigin(QScriptContext *ctx, QScriptEngine *eng)
00120 {
00121     DECLARE_SELF(QPainter, brushOrigin);
00122     return qScriptValueFromValue(eng, self->brushOrigin());
00123 }
00124 
00126 
00127 static QScriptValue clipPath(QScriptContext *ctx, QScriptEngine *eng)
00128 {
00129     DECLARE_SELF(QPainter, clipPath);
00130     return qScriptValueFromValue(eng, self->clipPath());
00131 }
00132 
00134 
00135 static QScriptValue clipRegion(QScriptContext *ctx, QScriptEngine *eng)
00136 {
00137     DECLARE_SELF(QPainter, clipRegion);
00138     return qScriptValueFromValue(eng, self->clipRegion());
00139 }
00140 
00142 
00143 static QScriptValue combinedMatrix(QScriptContext *ctx, QScriptEngine *eng)
00144 {
00145     DECLARE_SELF(QPainter, combinedMatrix);
00146     return qScriptValueFromValue(eng, self->combinedMatrix());
00147 }
00148 
00150 
00151 static QScriptValue combinedTransform(QScriptContext *ctx, QScriptEngine *eng)
00152 {
00153     DECLARE_SELF(QPainter, combinedTransform);
00154     return qScriptValueFromValue(eng, self->combinedTransform());
00155 }
00156 
00158 
00159 static QScriptValue compositionMode(QScriptContext *ctx, QScriptEngine *eng)
00160 {
00161     DECLARE_SELF(QPainter, compositionMode);
00162     return QScriptValue(eng, static_cast<int>(self->compositionMode()));
00163 }
00164 
00166 
00167 static QScriptValue device(QScriptContext *ctx, QScriptEngine *eng)
00168 {
00169     DECLARE_SELF(QPainter, device);
00170     return qScriptValueFromValue(eng, self->device());
00171 }
00172 
00174 
00175 static QScriptValue deviceMatrix(QScriptContext *ctx, QScriptEngine *eng)
00176 {
00177     DECLARE_SELF(QPainter, deviceMatrix);
00178     return qScriptValueFromValue(eng, self->deviceMatrix());
00179 }
00180 
00182 
00183 static QScriptValue deviceTransform(QScriptContext *ctx, QScriptEngine *eng)
00184 {
00185     DECLARE_SELF(QPainter, deviceTransform);
00186     return qScriptValueFromValue(eng, self->deviceTransform());
00187 }
00188 
00190 
00191 static QScriptValue drawArc(QScriptContext *ctx, QScriptEngine *eng)
00192 {
00193     DECLARE_SELF(QPainter, drawArc);
00194     if (ctx->argumentCount() == 6) {
00195         // drawArc(x, y, height, width, startAngle, spanAngle)
00196         self->drawArc(ctx->argument(0).toInt32(),
00197                       ctx->argument(1).toInt32(),
00198                       ctx->argument(2).toInt32(),
00199                       ctx->argument(3).toInt32(),
00200                       ctx->argument(4).toInt32(),
00201                       ctx->argument(5).toInt32());
00202     } else if (ctx->argumentCount() == 3) {
00203         // drawArc(rectangle, startAngle, spanAngle)
00204         self->drawArc(qscriptvalue_cast<QRectF>(ctx->argument(0)),
00205                       ctx->argument(1).toInt32(),
00206                       ctx->argument(2).toInt32());
00207     }
00208     return eng->undefinedValue();
00209 }
00210 
00212 
00213 static QScriptValue drawChord(QScriptContext *ctx, QScriptEngine *eng)
00214 {
00215     DECLARE_SELF(QPainter, drawChord);
00216     if (ctx->argumentCount() == 6) {
00217         // x, y, height, width, startAngle, spanAngle
00218         self->drawChord(ctx->argument(0).toInt32(),
00219                         ctx->argument(1).toInt32(),
00220                         ctx->argument(2).toInt32(),
00221                         ctx->argument(3).toInt32(),
00222                         ctx->argument(4).toInt32(),
00223                         ctx->argument(5).toInt32());
00224     } else if (ctx->argumentCount() == 3) {
00225         // rectangle, startAngle, spanAngle
00226         self->drawChord(qscriptvalue_cast<QRectF>(ctx->argument(0)),
00227                         ctx->argument(1).toInt32(),
00228                         ctx->argument(2).toInt32());
00229     }
00230     return eng->undefinedValue();
00231 }
00232 
00234 
00235 static QScriptValue drawConvexPolygon(QScriptContext *ctx, QScriptEngine *eng)
00236 {
00237     DECLARE_SELF(QPainter, drawConvexPolygon);
00238     self->drawConvexPolygon(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
00239     return eng->undefinedValue();
00240 }
00241 
00243 
00244 static QScriptValue drawEllipse(QScriptContext *ctx, QScriptEngine *eng)
00245 {
00246     DECLARE_SELF(QPainter, drawEllipse);
00247     if (ctx->argumentCount() == 4) {
00248         // drawEllipse(x, y, width, height)
00249         self->drawEllipse(ctx->argument(0).toInt32(),
00250                           ctx->argument(1).toInt32(),
00251                           ctx->argument(2).toInt32(),
00252                           ctx->argument(3).toInt32());
00253     } else if (ctx->argumentCount() == 1) {
00254         // drawEllipse(rect)
00255         self->drawEllipse(qscriptvalue_cast<QRectF>(ctx->argument(0)));
00256     }
00257     return eng->undefinedValue();
00258 }
00259 
00261 
00262 static QScriptValue drawImage(QScriptContext *ctx, QScriptEngine *eng)
00263 {
00264     DECLARE_SELF(QPainter, drawImage);
00265     if (ctx->argumentCount() == 2) {
00266         // target, image
00267         QScriptValue arg0 = ctx->argument(0);
00268         QImage image = qscriptvalue_cast<QImage>(ctx->argument(1));
00269         if (arg0.property("width").isValid()) {
00270             self->drawImage(qscriptvalue_cast<QRectF>(arg0), image);
00271         } else {
00272             self->drawImage(qscriptvalue_cast<QPointF>(arg0), image);
00273         }
00274     } else if (ctx->argumentCount() == 3) {
00275         // x, y, image
00276         self->drawImage(ctx->argument(0).toInt32(),
00277                         ctx->argument(1).toInt32(),
00278                         qscriptvalue_cast<QImage>(ctx->argument(2)));
00279     } else if (ctx->argumentCount() == 5) {
00280         // x, y, width, height, image
00281         self->drawImage(QRect(ctx->argument(0).toInt32(),
00282                               ctx->argument(1).toInt32(),
00283                               ctx->argument(2).toInt32(),
00284                               ctx->argument(3).toInt32()),
00285                         qscriptvalue_cast<QImage>(ctx->argument(4)));
00286     }
00287     return eng->undefinedValue();
00288 }
00289 
00291 
00292 static QScriptValue drawLine(QScriptContext *ctx, QScriptEngine *eng)
00293 {
00294     DECLARE_SELF(QPainter, drawLine);
00295     if (ctx->argumentCount() == 4) {
00296         // x1, y1, x2, y2
00297         self->drawLine(ctx->argument(0).toInt32(),
00298                        ctx->argument(1).toInt32(),
00299                        ctx->argument(2).toInt32(),
00300                        ctx->argument(3).toInt32());
00301     } else if (ctx->argumentCount() == 2) {
00302         // p1, p2
00303         self->drawLine(qscriptvalue_cast<QPointF>(ctx->argument(0)),
00304                        qscriptvalue_cast<QPointF>(ctx->argument(1)));
00305     } else if (ctx->argumentCount() == 1) {
00306         // line
00307         self->drawLine(qscriptvalue_cast<QLineF>(ctx->argument(0)));
00308     }
00309     return eng->undefinedValue();
00310 }
00311 
00313 
00314 static QScriptValue drawLines(QScriptContext *ctx, QScriptEngine *eng)
00315 {
00316     DECLARE_SELF(QPainter, drawLines);
00317     return ctx->throwError("QPainter.prototype.drawLines is not implemented");
00318 //    self->drawLines(qscriptvalue_cast<QVector<QLineF> >(ctx->argument(0)));
00319     return eng->undefinedValue();
00320 }
00321 
00323 
00324 static QScriptValue drawPath(QScriptContext *ctx, QScriptEngine *eng)
00325 {
00326     DECLARE_SELF(QPainter, drawPath);
00327     self->drawPath(qscriptvalue_cast<QPainterPath>(ctx->argument(0)));
00328     return eng->undefinedValue();
00329 }
00330 
00332 
00333 static QScriptValue drawPicture(QScriptContext *ctx, QScriptEngine *eng)
00334 {
00335     DECLARE_SELF(QPainter, drawPicture);
00336     if (ctx->argumentCount() == 2) {
00337         self->drawPicture(qscriptvalue_cast<QPointF>(ctx->argument(0)),
00338                           qscriptvalue_cast<QPicture>(ctx->argument(1)));
00339     } else if (ctx->argumentCount() == 3) {
00340         self->drawPicture(ctx->argument(0).toInt32(),
00341                           ctx->argument(1).toInt32(),
00342                           qscriptvalue_cast<QPicture>(ctx->argument(2)));
00343     }
00344     return eng->undefinedValue();
00345 }
00346 
00348 
00349 static QScriptValue drawPie(QScriptContext *ctx, QScriptEngine *eng)
00350 {
00351     DECLARE_SELF(QPainter, drawPie);
00352     if (ctx->argumentCount() == 6) {
00353         // x, y, height, width, startAngle, spanAngle
00354         self->drawPie(ctx->argument(0).toInt32(),
00355                       ctx->argument(1).toInt32(),
00356                       ctx->argument(2).toInt32(),
00357                       ctx->argument(3).toInt32(),
00358                       ctx->argument(4).toInt32(),
00359                       ctx->argument(5).toInt32());
00360     } else if (ctx->argumentCount() == 3) {
00361         // rectangle, startAngle, spanAngle
00362         self->drawPie(qscriptvalue_cast<QRectF>(ctx->argument(0)),
00363                       ctx->argument(1).toInt32(),
00364                       ctx->argument(2).toInt32());
00365     }
00366     return eng->undefinedValue();
00367 }
00368 
00370 
00371 static QScriptValue drawPixmap(QScriptContext *ctx, QScriptEngine *eng)
00372 {
00373     DECLARE_SELF(QPainter, drawPixmap);
00374     if (ctx->argumentCount() == 2) {
00375         // target, pixmap
00376         QScriptValue arg0 = ctx->argument(0);
00377         QPixmap pixmap = qscriptvalue_cast<QPixmap>(ctx->argument(1));
00378         if (arg0.property("width").isValid()) {
00379             self->drawPixmap(qscriptvalue_cast<QRectF>(arg0), pixmap,
00380                              QRectF(0, 0, pixmap.width(), pixmap.height()));
00381         } else {
00382             self->drawPixmap(qscriptvalue_cast<QPointF>(arg0), pixmap);
00383         }
00384     } else if (ctx->argumentCount() == 3) {
00385         // x, y, pixmap
00386         self->drawPixmap(ctx->argument(0).toInt32(),
00387                          ctx->argument(1).toInt32(),
00388                          qscriptvalue_cast<QPixmap>(ctx->argument(2)));
00389     } else if (ctx->argumentCount() == 5) {
00390         // x, y, width, height, pixmap
00391         self->drawPixmap(ctx->argument(0).toInt32(),
00392                          ctx->argument(1).toInt32(),
00393                          ctx->argument(2).toInt32(),
00394                          ctx->argument(3).toInt32(),
00395                          qscriptvalue_cast<QPixmap>(ctx->argument(4)));
00396     }
00397     return eng->undefinedValue();
00398 }
00399 
00401 
00402 static QScriptValue drawPoint(QScriptContext *ctx, QScriptEngine *eng)
00403 {
00404     DECLARE_SELF(QPainter, drawPoint);
00405     if (ctx->argumentCount() == 2) {
00406         // drawPoint(x, y)
00407         self->drawPoint(ctx->argument(0).toInt32(),
00408                         ctx->argument(1).toInt32());
00409     } else if (ctx->argumentCount() == 1) {
00410         // drawPoint(point)
00411         self->drawPoint(qscriptvalue_cast<QPointF>(ctx->argument(0)));
00412     }
00413     return eng->undefinedValue();
00414 }
00415 
00417 
00418 static QScriptValue drawPoints(QScriptContext *ctx, QScriptEngine *eng)
00419 {
00420     DECLARE_SELF(QPainter, drawPoints);
00421     self->drawPoints(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
00422     return eng->undefinedValue();
00423 }
00424 
00426 
00427 static QScriptValue drawPolygon(QScriptContext *ctx, QScriptEngine *eng)
00428 {
00429     DECLARE_SELF(QPainter, drawPolygon);
00430     // ### fillRule (2nd argument)
00431     self->drawPolygon(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
00432     return eng->undefinedValue();
00433 }
00434 
00436 
00437 static QScriptValue drawPolyline(QScriptContext *ctx, QScriptEngine *eng)
00438 {
00439     DECLARE_SELF(QPainter, drawPolyline);
00440     self->drawPolyline(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
00441     return eng->undefinedValue();
00442 }
00443 
00445 
00446 static QScriptValue drawRect(QScriptContext *ctx, QScriptEngine *eng)
00447 {
00448     DECLARE_SELF(QPainter, drawRect);
00449     if (ctx->argumentCount() == 4) {
00450         // x, y, width, height
00451         self->drawRect(ctx->argument(0).toInt32(),
00452                        ctx->argument(1).toInt32(),
00453                        ctx->argument(2).toInt32(),
00454                        ctx->argument(3).toInt32());
00455     } else if (ctx->argumentCount() == 1) {
00456         // rect
00457         self->drawRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
00458     }
00459     return eng->undefinedValue();
00460 }
00461 
00463 
00464 static QScriptValue drawRects(QScriptContext *ctx, QScriptEngine *eng)
00465 {
00466     DECLARE_SELF(QPainter, drawRects);
00467     self->drawRects(qscriptvalue_cast<QVector<QRectF> >(ctx->argument(0)));
00468     return eng->undefinedValue();
00469 }
00470 
00472 
00473 static QScriptValue drawRoundRect(QScriptContext *ctx, QScriptEngine *eng)
00474 {
00475     DECLARE_SELF(QPainter, drawRoundRect);
00476     // ### xRnd, yRnd
00477     if (ctx->argumentCount() >= 4) {
00478         self->drawRoundRect(ctx->argument(0).toInt32(),
00479                             ctx->argument(1).toInt32(),
00480                             ctx->argument(2).toInt32(),
00481                             ctx->argument(3).toInt32());
00482     } else {
00483         self->drawRoundRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
00484     }
00485     return eng->undefinedValue();
00486 }
00487 
00489 
00490 static QScriptValue drawText(QScriptContext *ctx, QScriptEngine *eng)
00491 {
00492     DECLARE_SELF(QPainter, drawText);
00493     if (ctx->argumentCount() == 3) {
00494         // x, y, text
00495         self->drawText(ctx->argument(0).toInt32(),
00496                        ctx->argument(1).toInt32(),
00497                        ctx->argument(2).toString());
00498     } else if (ctx->argumentCount() == 2) {
00499         QScriptValue arg0 = ctx->argument(0);
00500         if (arg0.property("width").isValid()) {
00501             self->drawText(qscriptvalue_cast<QRectF>(arg0),
00502                            ctx->argument(1).toString());
00503         } else {
00504             self->drawText(qscriptvalue_cast<QPointF>(arg0),
00505                            ctx->argument(1).toString());
00506         }
00507     }
00508     return eng->undefinedValue();
00509 }
00510 
00512 
00513 static QScriptValue drawTiledPixmap(QScriptContext *ctx, QScriptEngine *eng)
00514 {
00515     DECLARE_SELF(QPainter, drawTiledPixmap);
00516     if (ctx->argumentCount() >= 5) {
00517         // x, y, width, height, pixmap, sx, sy
00518         self->drawTiledPixmap(ctx->argument(0).toInt32(),
00519                               ctx->argument(1).toInt32(),
00520                               ctx->argument(2).toInt32(),
00521                               ctx->argument(3).toInt32(),
00522                               qscriptvalue_cast<QPixmap>(ctx->argument(4)),
00523                               ctx->argument(5).toInt32(),
00524                               ctx->argument(6).toInt32());
00525     } else {
00526         // rect, pixmap, position
00527         self->drawTiledPixmap(qscriptvalue_cast<QRectF>(ctx->argument(0)),
00528                               qscriptvalue_cast<QPixmap>(ctx->argument(1)),
00529                               qscriptvalue_cast<QPointF>(ctx->argument(2)));
00530     }
00531     return eng->undefinedValue();
00532 }
00533 
00535 
00536 static QScriptValue end(QScriptContext *ctx, QScriptEngine *eng)
00537 {
00538     DECLARE_SELF(QPainter, end);
00539     return QScriptValue(eng, self->end());
00540 }
00541 
00543 
00544 static QScriptValue eraseRect(QScriptContext *ctx, QScriptEngine *eng)
00545 {
00546     DECLARE_SELF(QPainter, eraseRect);
00547     if (ctx->argumentCount() == 4) {
00548         // x, y, width, height
00549         self->eraseRect(ctx->argument(0).toInt32(),
00550                         ctx->argument(1).toInt32(),
00551                         ctx->argument(2).toInt32(),
00552                         ctx->argument(3).toInt32());
00553     } else if (ctx->argumentCount() == 1) {
00554         // rect
00555         self->eraseRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
00556     }
00557     return eng->undefinedValue();
00558 }
00559 
00561 
00562 static QScriptValue fillPath(QScriptContext *ctx, QScriptEngine *eng)
00563 {
00564     DECLARE_SELF(QPainter, fillPath);
00565     QPainterPath *path = qscriptvalue_cast<QPainterPath*>(ctx->argument(0));
00566     if (!path) {
00567         return ctx->throwError(QScriptContext::TypeError,
00568                                "QPainter.prototype.fillPath: argument is not a PainterPath");
00569     }
00570     self->fillPath(*path, qscriptvalue_cast<QBrush>(ctx->argument(1)));
00571     return eng->undefinedValue();
00572 }
00573 
00575 
00576 static QScriptValue fillRect(QScriptContext *ctx, QScriptEngine *eng)
00577 {
00578     DECLARE_SELF(QPainter, fillRect);
00579     if (ctx->argumentCount() == 5) {
00580         // x, y, width, height, brush
00581         self->fillRect(ctx->argument(0).toInt32(),
00582                        ctx->argument(1).toInt32(),
00583                        ctx->argument(2).toInt32(),
00584                        ctx->argument(3).toInt32(),
00585                        qscriptvalue_cast<QBrush>(ctx->argument(4)));
00586     } else if (ctx->argumentCount() == 2) {
00587         // rect, brush
00588         self->fillRect(qscriptvalue_cast<QRectF>(ctx->argument(0)),
00589                        qscriptvalue_cast<QBrush>(ctx->argument(1)));
00590     }
00591     return eng->undefinedValue();
00592 }
00593 
00595 
00596 static QScriptValue font(QScriptContext *ctx, QScriptEngine *eng)
00597 {
00598     DECLARE_SELF(QPainter, font);
00599     return qScriptValueFromValue(eng, self->font());
00600 }
00601 
00603 
00604 static QScriptValue fontInfo(QScriptContext *ctx, QScriptEngine *)
00605 {
00606     DECLARE_SELF(QPainter, fontInfo);
00607     return ctx->throwError("QPainter.prototype.fontInfo is not implemented");
00608 }
00609 
00611 
00612 static QScriptValue fontMetrics(QScriptContext *ctx, QScriptEngine *)
00613 {
00614     DECLARE_SELF(QPainter, fontMetrics);
00615     return ctx->throwError("QPainter.prototype.fontMetrics is not implemented");
00616 }
00617 
00619 
00620 static QScriptValue hasClipping(QScriptContext *ctx, QScriptEngine *eng)
00621 {
00622     DECLARE_SELF(QPainter, hasClipping);
00623     return QScriptValue(eng, self->hasClipping());
00624 }
00625 
00627 
00628 static QScriptValue initFrom(QScriptContext *ctx, QScriptEngine *eng)
00629 {
00630     DECLARE_SELF(QPainter, initFrom);
00631     QWidget *widget = qscriptvalue_cast<QWidget*>(ctx->argument(0));
00632     if (!widget) {
00633         return ctx->throwError(QScriptContext::TypeError,
00634                                "QPainter.prototype.initFrom: argument is not a Widget");
00635     }
00636     self->initFrom(widget);
00637     return eng->undefinedValue();
00638 }
00639 
00641 
00642 static QScriptValue isActive(QScriptContext *ctx, QScriptEngine *eng)
00643 {
00644     DECLARE_SELF(QPainter, isActive);
00645     return QScriptValue(eng, self->isActive());
00646 }
00647 
00649 
00650 static QScriptValue layoutDirection(QScriptContext *ctx, QScriptEngine *eng)
00651 {
00652     DECLARE_SELF(QPainter, layoutDirection);
00653     return QScriptValue(eng, static_cast<int>(self->layoutDirection()));
00654 }
00655 
00657 
00658 static QScriptValue opacity(QScriptContext *ctx, QScriptEngine *eng)
00659 {
00660     DECLARE_SELF(QPainter, opacity);
00661     return QScriptValue(eng, self->opacity());
00662 }
00663 
00665 
00666 static QScriptValue paintEngine(QScriptContext *ctx, QScriptEngine *eng)
00667 {
00668     DECLARE_SELF(QPainter, paintEngine);
00669     return qScriptValueFromValue(eng, self->paintEngine());
00670 }
00671 
00673 
00674 static QScriptValue pen(QScriptContext *ctx, QScriptEngine *eng)
00675 {
00676     DECLARE_SELF(QPainter, pen);
00677     return qScriptValueFromValue(eng, self->pen());
00678 }
00679 
00681 
00682 static QScriptValue renderHints(QScriptContext *ctx, QScriptEngine *eng)
00683 {
00684     DECLARE_SELF(QPainter, renderHints);
00685     return QScriptValue(eng, static_cast<int>(self->renderHints()));
00686 }
00687 
00689 
00690 static QScriptValue resetMatrix(QScriptContext *ctx, QScriptEngine *eng)
00691 {
00692     DECLARE_SELF(QPainter, resetMatrix);
00693     self->resetMatrix();
00694     return eng->undefinedValue();
00695 }
00696 
00698 
00699 static QScriptValue resetTransform(QScriptContext *ctx, QScriptEngine *eng)
00700 {
00701     DECLARE_SELF(QPainter, resetTransform);
00702     self->resetTransform();
00703     return eng->undefinedValue();
00704 }
00705 
00707 
00708 static QScriptValue restore(QScriptContext *ctx, QScriptEngine *eng)
00709 {
00710     DECLARE_SELF(QPainter, restore);
00711     self->restore();
00712     return eng->undefinedValue();
00713 }
00714 
00716 
00717 static QScriptValue rotate(QScriptContext *ctx, QScriptEngine *eng)
00718 {
00719     DECLARE_SELF(QPainter, rotate);
00720     self->rotate(ctx->argument(0).toNumber());
00721     return eng->undefinedValue();
00722 }
00723 
00725 
00726 static QScriptValue save(QScriptContext *ctx, QScriptEngine *eng)
00727 {
00728     DECLARE_SELF(QPainter, save);
00729     self->save();
00730     return eng->undefinedValue();
00731 }
00732 
00734 
00735 static QScriptValue scale(QScriptContext *ctx, QScriptEngine *eng)
00736 {
00737     DECLARE_SELF(QPainter, scale);
00738     self->scale(ctx->argument(0).toNumber(),
00739                 ctx->argument(1).toNumber());
00740     return eng->undefinedValue();
00741 }
00742 
00744 
00745 static QScriptValue setBackground(QScriptContext *ctx, QScriptEngine *eng)
00746 {
00747     DECLARE_SELF(QPainter, setBackground);
00748     self->setBackground(qscriptvalue_cast<QBrush>(ctx->argument(0)));
00749     return eng->undefinedValue();
00750 }
00751 
00753 
00754 static QScriptValue setBackgroundMode(QScriptContext *ctx, QScriptEngine *eng)
00755 {
00756     DECLARE_SELF(QPainter, setBackgroundMode);
00757     self->setBackgroundMode(static_cast<Qt::BGMode>(ctx->argument(0).toInt32()));
00758     return eng->undefinedValue();
00759 }
00760 
00762 
00763 static QScriptValue setBrush(QScriptContext *ctx, QScriptEngine *eng)
00764 {
00765     DECLARE_SELF(QPainter, setBrush);
00766     self->setBrush(qscriptvalue_cast<QBrush>(ctx->argument(0)));
00767     return eng->undefinedValue();
00768 }
00769 
00771 
00772 static QScriptValue setBrushOrigin(QScriptContext *ctx, QScriptEngine *eng)
00773 {
00774     DECLARE_SELF(QPainter, setBrushOrigin);
00775     self->setBrushOrigin(qscriptvalue_cast<QPointF>(ctx->argument(0)));
00776     return eng->undefinedValue();
00777 }
00778 
00780 
00781 static QScriptValue setClipPath(QScriptContext *ctx, QScriptEngine *eng)
00782 {
00783     DECLARE_SELF(QPainter, setClipPath);
00784     // ### ClipOperation
00785     self->setClipPath(qscriptvalue_cast<QPainterPath>(ctx->argument(0)));
00786     return eng->undefinedValue();
00787 }
00788 
00790 
00791 static QScriptValue setClipRect(QScriptContext *ctx, QScriptEngine *eng)
00792 {
00793     DECLARE_SELF(QPainter, setClipRect);
00794     // ### ClipOperation
00795     if (ctx->argumentCount() >= 4) {
00796         // x, y, width, height [, operation]
00797         self->setClipRect(ctx->argument(0).toInt32(),
00798                           ctx->argument(1).toInt32(),
00799                           ctx->argument(2).toInt32(),
00800                           ctx->argument(3).toInt32());
00801     } else if (ctx->argumentCount() >= 1) {
00802         // rect [, operation]
00803         self->setClipRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
00804     }
00805     return eng->undefinedValue();
00806 }
00807 
00809 
00810 static QScriptValue setClipRegion(QScriptContext *ctx, QScriptEngine *eng)
00811 {
00812     DECLARE_SELF(QPainter, setClipRegion);
00813     // ### ClipOperation
00814     self->setClipRegion(qscriptvalue_cast<QRegion>(ctx->argument(0)));
00815     return eng->undefinedValue();
00816 }
00817 
00819 
00820 static QScriptValue setClipping(QScriptContext *ctx, QScriptEngine *eng)
00821 {
00822     DECLARE_SELF(QPainter, setClipping);
00823     self->setClipping(ctx->argument(0).toBoolean());
00824     return eng->undefinedValue();
00825 }
00826 
00828 
00829 static QScriptValue setCompositionMode(QScriptContext *ctx, QScriptEngine *eng)
00830 {
00831     DECLARE_SELF(QPainter, setCompositionMode);
00832     self->setCompositionMode(static_cast<QPainter::CompositionMode>(ctx->argument(0).toInt32()));
00833     return eng->undefinedValue();
00834 }
00835 
00837 
00838 static QScriptValue setFont(QScriptContext *ctx, QScriptEngine *eng)
00839 {
00840     DECLARE_SELF(QPainter, setFont);
00841     self->setFont(qscriptvalue_cast<QFont>(ctx->argument(0)));
00842     return eng->undefinedValue();
00843 }
00844 
00846 
00847 static QScriptValue setLayoutDirection(QScriptContext *ctx, QScriptEngine *eng)
00848 {
00849     DECLARE_SELF(QPainter, setLayoutDirection);
00850     self->setLayoutDirection(static_cast<Qt::LayoutDirection>(ctx->argument(0).toInt32()));
00851     return eng->undefinedValue();
00852 }
00853 
00855 
00856 static QScriptValue setOpacity(QScriptContext *ctx, QScriptEngine *eng)
00857 {
00858     DECLARE_SELF(QPainter, setOpacity);
00859     self->setOpacity(ctx->argument(0).toNumber());
00860     return eng->undefinedValue();
00861 }
00862 
00864 
00865 static QScriptValue setPen(QScriptContext *ctx, QScriptEngine *eng)
00866 {
00867     DECLARE_SELF(QPainter, setPen);
00868     self->setPen(qscriptvalue_cast<QPen>(ctx->argument(0)));
00869     return eng->undefinedValue();
00870 }
00871 
00873 
00874 static QScriptValue setRenderHint(QScriptContext *ctx, QScriptEngine *eng)
00875 {
00876     DECLARE_SELF(QPainter, setRenderHint);
00877     self->setRenderHint(static_cast<QPainter::RenderHint>(ctx->argument(0).toInt32()),
00878                         ctx->argument(1).toBoolean());
00879     return eng->undefinedValue();
00880 }
00881 
00883 
00884 static QScriptValue setRenderHints(QScriptContext *ctx, QScriptEngine *eng)
00885 {
00886     DECLARE_SELF(QPainter, setRenderHints);
00887     self->setRenderHints(static_cast<QPainter::RenderHints>(ctx->argument(0).toInt32()),
00888                          ctx->argument(1).toBoolean());
00889     return eng->undefinedValue();
00890 }
00891 
00893 
00894 static QScriptValue setTransform(QScriptContext *ctx, QScriptEngine *eng)
00895 {
00896     DECLARE_SELF(QPainter, setTransform);
00897     self->setTransform(qscriptvalue_cast<QTransform>(ctx->argument(0)));
00898     return eng->undefinedValue();
00899 }
00900 
00902 
00903 static QScriptValue setViewTransformEnabled(QScriptContext *ctx, QScriptEngine *eng)
00904 {
00905     DECLARE_SELF(QPainter, setViewTransformEnabled);
00906     self->setViewTransformEnabled(ctx->argument(0).toBoolean());
00907     return eng->undefinedValue();
00908 }
00909 
00911 
00912 static QScriptValue setViewport(QScriptContext *ctx, QScriptEngine *eng)
00913 {
00914     DECLARE_SELF(QPainter, setViewport);
00915     if (ctx->argumentCount() == 4) {
00916         // x, y, width, height
00917         self->setViewport(ctx->argument(0).toInt32(),
00918                           ctx->argument(1).toInt32(),
00919                           ctx->argument(2).toInt32(),
00920                           ctx->argument(3).toInt32());
00921     } else if (ctx->argumentCount() == 1) {
00922         // rect
00923         self->setViewport(qscriptvalue_cast<QRect>(ctx->argument(0)));
00924     }
00925     return eng->undefinedValue();
00926 }
00927 
00929 
00930 static QScriptValue setWindow(QScriptContext *ctx, QScriptEngine *eng)
00931 {
00932     DECLARE_SELF(QPainter, setWindow);
00933     if (ctx->argumentCount() == 4) {
00934         // x, y, width, height
00935         self->setWindow(ctx->argument(0).toInt32(),
00936                         ctx->argument(1).toInt32(),
00937                         ctx->argument(2).toInt32(),
00938                         ctx->argument(3).toInt32());
00939     } else if (ctx->argumentCount() == 1) {
00940         // rect
00941         self->setWindow(qscriptvalue_cast<QRect>(ctx->argument(0)));
00942     }
00943     return eng->undefinedValue();
00944 }
00945 
00947 
00948 static QScriptValue setWorldMatrix(QScriptContext *ctx, QScriptEngine *eng)
00949 {
00950     DECLARE_SELF(QPainter, setWorldMatrix);
00951     self->setWorldMatrix(qscriptvalue_cast<QMatrix>(ctx->argument(0)),
00952                          ctx->argument(1).toBoolean());
00953     return eng->undefinedValue();
00954 }
00955 
00957 
00958 static QScriptValue setWorldMatrixEnabled(QScriptContext *ctx, QScriptEngine *eng)
00959 {
00960     DECLARE_SELF(QPainter, setWorldMatrixEnabled);
00961     self->setWorldMatrixEnabled(ctx->argument(0).toBoolean());
00962     return eng->undefinedValue();
00963 }
00964 
00966 
00967 static QScriptValue setWorldTransform(QScriptContext *ctx, QScriptEngine *eng)
00968 {
00969     DECLARE_SELF(QPainter, setWorldTransform);
00970     self->setWorldTransform(qscriptvalue_cast<QTransform>(ctx->argument(0)),
00971                             ctx->argument(1).toBoolean());
00972     return eng->undefinedValue();
00973 }
00974 
00976 
00977 static QScriptValue shear(QScriptContext *ctx, QScriptEngine *eng)
00978 {
00979     DECLARE_SELF(QPainter, shear);
00980     self->shear(ctx->argument(0).toNumber(),
00981                      ctx->argument(1).toNumber());
00982     return eng->undefinedValue();
00983 }
00984 
00986 
00987 static QScriptValue strokePath(QScriptContext *ctx, QScriptEngine *eng)
00988 {
00989     DECLARE_SELF(QPainter, strokePath);
00990     QPainterPath *path = qscriptvalue_cast<QPainterPath*>(ctx->argument(0));
00991     if (!path) {
00992         return ctx->throwError(QScriptContext::TypeError,
00993                                "QPainter.prototype.strokePath: argument is not a PainterPath");
00994     }
00995     self->strokePath(*path, qscriptvalue_cast<QPen>(ctx->argument(1)));
00996     return eng->undefinedValue();
00997 }
00998 
01000 
01001 static QScriptValue testRenderHint(QScriptContext *ctx, QScriptEngine *eng)
01002 {
01003     DECLARE_SELF(QPainter, testRenderHint);
01004     return QScriptValue(eng, self->testRenderHint(static_cast<QPainter::RenderHint>(ctx->argument(0).toInt32())));
01005 }
01006 
01008 
01009 static QScriptValue transform(QScriptContext *ctx, QScriptEngine *eng)
01010 {
01011     DECLARE_SELF(QPainter, transform);
01012     return qScriptValueFromValue(eng, self->transform());
01013 }
01014 
01016 
01017 static QScriptValue translate(QScriptContext *ctx, QScriptEngine *eng)
01018 {
01019     DECLARE_SELF(QPainter, translate);
01020     if (ctx->argumentCount() == 2) {
01021         // dx, dy
01022         self->translate(ctx->argument(0).toNumber(),
01023                              ctx->argument(1).toNumber());
01024     } else if (ctx->argumentCount() == 1) {
01025         // offset
01026         self->translate(qscriptvalue_cast<QPointF>(ctx->argument(0)));
01027     }
01028     return eng->undefinedValue();
01029 }
01030 
01032 
01033 static QScriptValue viewTransformEnabled(QScriptContext *ctx, QScriptEngine *eng)
01034 {
01035     DECLARE_SELF(QPainter, viewTransformEnabled);
01036     return QScriptValue(eng, self->viewTransformEnabled());
01037 }
01038 
01040 
01041 static QScriptValue viewport(QScriptContext *ctx, QScriptEngine *eng)
01042 {
01043     DECLARE_SELF(QPainter, viewport);
01044     return qScriptValueFromValue(eng, self->viewport());
01045 }
01046 
01048 
01049 static QScriptValue window(QScriptContext *ctx, QScriptEngine *eng)
01050 {
01051     DECLARE_SELF(QPainter, window);
01052     return qScriptValueFromValue(eng, self->window());
01053 }
01054 
01056 
01057 static QScriptValue worldMatrix(QScriptContext *ctx, QScriptEngine *eng)
01058 {
01059     DECLARE_SELF(QPainter, worldMatrix);
01060     return qScriptValueFromValue(eng, self->worldMatrix());
01061 }
01062 
01064 
01065 static QScriptValue worldMatrixEnabled(QScriptContext *ctx, QScriptEngine *eng)
01066 {
01067     DECLARE_SELF(QPainter, worldMatrixEnabled);
01068     return QScriptValue(eng, self->worldMatrixEnabled());
01069 }
01070 
01072 
01073 static QScriptValue worldTransform(QScriptContext *ctx, QScriptEngine *eng)
01074 {
01075     DECLARE_SELF(QPainter, worldTransform);
01076     return qScriptValueFromValue(eng, self->worldTransform());
01077 }
01078 
01080 
01081 static QScriptValue toString(QScriptContext *ctx, QScriptEngine *eng)
01082 {
01083     DECLARE_SELF(QPainter, toString);
01084     return QScriptValue(eng, "QPainter");
01085 }
01086 
01088 
01089 QScriptValue constructPainterClass(QScriptEngine *eng)
01090 {
01091     QScriptValue proto = newPainter(eng, new QPainter());
01092     ADD_METHOD(proto, background);
01093     ADD_METHOD(proto, backgroundMode);
01094     ADD_METHOD(proto, begin);
01095     ADD_METHOD(proto, boundingRect);
01096     ADD_METHOD(proto, brush);
01097     ADD_METHOD(proto, brushOrigin);
01098     ADD_METHOD(proto, clipPath);
01099     ADD_METHOD(proto, clipRegion);
01100     ADD_METHOD(proto, combinedMatrix);
01101     ADD_METHOD(proto, combinedTransform);
01102     ADD_METHOD(proto, compositionMode);
01103     ADD_METHOD(proto, device);
01104     ADD_METHOD(proto, deviceMatrix);
01105     ADD_METHOD(proto, deviceTransform);
01106     ADD_METHOD(proto, drawChord);
01107     ADD_METHOD(proto, drawConvexPolygon);
01108     ADD_METHOD(proto, drawArc);
01109     ADD_METHOD(proto, drawEllipse);
01110     ADD_METHOD(proto, drawImage);
01111     ADD_METHOD(proto, drawLine);
01112     ADD_METHOD(proto, drawLines);
01113     ADD_METHOD(proto, drawPath);
01114     ADD_METHOD(proto, drawPicture);
01115     ADD_METHOD(proto, drawPie);
01116     ADD_METHOD(proto, drawPixmap);
01117     ADD_METHOD(proto, drawPoint);
01118     ADD_METHOD(proto, drawPoints);
01119     ADD_METHOD(proto, drawPolygon);
01120     ADD_METHOD(proto, drawPolyline);
01121     ADD_METHOD(proto, drawRect);
01122     ADD_METHOD(proto, drawRects);
01123     ADD_METHOD(proto, drawRoundRect);
01124     ADD_METHOD(proto, drawText);
01125     ADD_METHOD(proto, drawTiledPixmap);
01126     ADD_METHOD(proto, end);
01127     ADD_METHOD(proto, eraseRect);
01128     ADD_METHOD(proto, fillPath);
01129     ADD_METHOD(proto, fillRect);
01130     ADD_METHOD(proto, font);
01131     ADD_METHOD(proto, fontInfo);
01132     ADD_METHOD(proto, fontMetrics);
01133     ADD_METHOD(proto, hasClipping);
01134     ADD_METHOD(proto, initFrom);
01135     ADD_METHOD(proto, isActive);
01136     ADD_METHOD(proto, layoutDirection);
01137     ADD_METHOD(proto, opacity);
01138     ADD_METHOD(proto, paintEngine);
01139     ADD_METHOD(proto, pen);
01140     ADD_METHOD(proto, renderHints);
01141     ADD_METHOD(proto, resetMatrix);
01142     ADD_METHOD(proto, resetTransform);
01143     ADD_METHOD(proto, restore);
01144     ADD_METHOD(proto, rotate);
01145     ADD_METHOD(proto, save);
01146     ADD_METHOD(proto, scale);
01147     ADD_METHOD(proto, setBackground);
01148     ADD_METHOD(proto, setBackgroundMode);
01149     ADD_METHOD(proto, setBrush);
01150     ADD_METHOD(proto, setBrushOrigin);
01151     ADD_METHOD(proto, setClipPath);
01152     ADD_METHOD(proto, setClipRect);
01153     ADD_METHOD(proto, setClipRegion);
01154     ADD_METHOD(proto, setClipping);
01155     ADD_METHOD(proto, setCompositionMode);
01156     ADD_METHOD(proto, setFont);
01157     ADD_METHOD(proto, setLayoutDirection);
01158     ADD_METHOD(proto, setOpacity);
01159     ADD_METHOD(proto, setPen);
01160     ADD_METHOD(proto, setRenderHint);
01161     ADD_METHOD(proto, setRenderHints);
01162     ADD_METHOD(proto, setTransform);
01163     ADD_METHOD(proto, setViewTransformEnabled);
01164     ADD_METHOD(proto, setViewport);
01165     ADD_METHOD(proto, setWindow);
01166     ADD_METHOD(proto, setWorldMatrix);
01167     ADD_METHOD(proto, setWorldMatrixEnabled);
01168     ADD_METHOD(proto, setWorldTransform);
01169     ADD_METHOD(proto, shear);
01170     ADD_METHOD(proto, strokePath);
01171     ADD_METHOD(proto, testRenderHint);
01172     ADD_METHOD(proto, toString);
01173     ADD_METHOD(proto, transform);
01174     ADD_METHOD(proto, translate);
01175     ADD_METHOD(proto, viewTransformEnabled);
01176     ADD_METHOD(proto, viewport);
01177     ADD_METHOD(proto, window);
01178     ADD_METHOD(proto, worldMatrix);
01179     ADD_METHOD(proto, worldMatrixEnabled);
01180     ADD_METHOD(proto, worldTransform);
01181 
01182     QScript::registerPointerMetaType<QPainter>(eng, proto);
01183 
01184     qScriptRegisterSequenceMetaType<QVector<QRectF> >(eng);
01185 
01186     QScriptValue ctorFun = eng->newFunction(ctor, proto);
01187     ADD_ENUM_VALUE(ctorFun, QPainter, Antialiasing);
01188     ADD_ENUM_VALUE(ctorFun, QPainter, TextAntialiasing);
01189     ADD_ENUM_VALUE(ctorFun, QPainter, SmoothPixmapTransform);
01190     ADD_ENUM_VALUE(ctorFun, QPainter, HighQualityAntialiasing);
01191 
01192     eng->setDefaultPrototype(qMetaTypeId<QPainter*>(), proto);
01193 
01194     return ctorFun;
01195 }

Plasma

Skip menu "Plasma"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members

API Reference

Skip menu "API Reference"
  • KWin
  •   KWin Libraries
  • Libraries
  •   libkworkspace
  •   libplasma
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal