00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
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
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
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
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
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
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
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
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
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
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
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
00303 self->drawLine(qscriptvalue_cast<QPointF>(ctx->argument(0)),
00304 qscriptvalue_cast<QPointF>(ctx->argument(1)));
00305 } else if (ctx->argumentCount() == 1) {
00306
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
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
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
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
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
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
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
00407 self->drawPoint(ctx->argument(0).toInt32(),
00408 ctx->argument(1).toInt32());
00409 } else if (ctx->argumentCount() == 1) {
00410
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
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
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
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
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
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
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
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
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
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
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
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
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
00795 if (ctx->argumentCount() >= 4) {
00796
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
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
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
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
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
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
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
01022 self->translate(ctx->argument(0).toNumber(),
01023 ctx->argument(1).toNumber());
01024 } else if (ctx->argumentCount() == 1) {
01025
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 }