src/luaapi/imaging.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@gmail.com>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #include <cmath>
  12 #include <QApplication>
  13 #include "luaapi/imaging.h"
  14
  15
  16 using namespace Loader;
  17
  18 namespace LuaApi {
  19
  20 //BEGIN Wrapper<QRectF> -------------------------------------------------------
  21
  22 const char* Wrapper<QRectF>::class_name() {
  23   return "Rect";
  24 }
  25
  26 int Wrapper<QRectF>::translate(lua_State* l) {
  27   QRectF *r = retrieve(l, 1, AssertOk);
  28   QPointF *p = Wrapper<QPointF>::retrieve(l, 2, AssertOk);
  29   r->translate(*p);
  30   return 0;
  31 }
  32
  33 int Wrapper<QRectF>::to_string(lua_State* l) {
  34   QRectF *r = retrieve(l, 1, AssertOk);
  35   lua_pushfstring(l, "(%f, %f, %f, %f)", r->x(), r->y(), r->width(), r->height() );
  36   return 1;
  37 }
  38
  39 void Wrapper<QRectF>::create_index_table(lua_State* l) {
  40   SET_PROPERTY_RW(l, x);
  41   SET_PROPERTY_RW(l, y);
  42   SET_PROPERTY_RW(l, width);
  43   SET_PROPERTY_RW(l, height);
  44
  45   SET_PROPERTY_RO(l, left);
  46   SET_PROPERTY_RO(l, right);
  47   SET_PROPERTY_RO(l, top);
  48   SET_PROPERTY_RO(l, bottom);
  49
  50   set_method(l, &translate, "translate");
  51   set_meta_method(l, &to_string, "__tostring");
  52
  53   Comparable<QRectF>::register_in_index_table(l);
  54 }
  55
  56 int Wrapper<QRectF>::constructor(lua_State* l) {
  57   const int n = lua_gettop(l);
  58
  59   switch (n) {
  60   case 0:
  61     create(l);
  62     break;
  63   case 1:
  64     {
  65       QRectF res = *retrieve(l, 1, AssertOk);
  66       lua_pop(l, 1);
  67       create(l,res);
  68       break;
  69     }
  70   case 4:
  71     {
  72       double x = lua_tonumber(l, 1);
  73       double y = lua_tonumber(l, 2);
  74       double width = lua_tonumber(l, 3);
  75       double height = lua_tonumber(l, 4);
  76
  77       lua_pop(l, 4);
  78       create(l, x, y, width, height);
  79     }
  80     break;
  81   default:
  82     luaL_error(l, "Wrong parameter list for Rect constructor");
  83   }
  84
  85   return 1;
  86 }
  87
  88 //END Wrapper<QRectF> ---------------------------------------------------------
  89
  90
  91 //BEGIN Wrapper<QPointF> ------------------------------------------------------
  92
  93 const char* Wrapper<QPointF>::class_name() {
  94   return "Point";
  95 }
  96
  97 int Wrapper<QPointF>::to_string(lua_State* l) {
  98   QPointF *p = retrieve(l, 1, AssertOk);
  99   lua_pushfstring(l, "(%f, %f)", p->x(), p->y() );
 100   return 1;
 101 }
 102
 103 void Wrapper<QPointF>::create_index_table(lua_State* l) {
 104   SET_PROPERTY_RW(l, x);
 105   SET_PROPERTY_RW(l, y);
 106   SET_PROPERTY_RO(l, length);
 107
 108   set_meta_method(l, &to_string, "__tostring");
 109   set_meta_method(l, &get_length, "__len");
 110
 111   Comparable<QPointF>::register_in_index_table(l);
 112   Summable<QPointF>::register_in_index_table(l);
 113 }
 114
 115 int Wrapper<QPointF>::constructor(lua_State* l) {
 116   const int n = lua_gettop(l);
 117
 118   switch(n) {
 119   case 0:
 120     create(l);
 121     break;
 122   case 1: {
 123       QPointF res = *retrieve(l, 1, AssertOk);
 124       lua_pop(l,1);
 125       create(l, res);
 126       break;
 127     }
 128   case 2: {
 129     double x = lua_tonumber(l, 1);
 130     double y = lua_tonumber(l, 2);
 131     lua_pop(l,2);
 132     create(l, x, y);
 133     }
 134     break;
 135   default:
 136     luaL_error(l, "Wrong argument count for Point constructor");
 137     break;
 138   }
 139
 140   return 1;
 141 }
 142
 143 int Wrapper<QPointF>::get_length(lua_State* l) {
 144   QPointF *p = retrieve(l, 1, DontCheck);
 145   lua_pushnumber(l, sqrt(p->x()*p->x() + p->y()*p->y()) );
 146   return 1;
 147 }
 148
 149 //END Wrapper<QPointF> --------------------------------------------------------
 150
 151
 152 //BEGIN Wrapper<QColor>--------------------------------------------------------
 153
 154
 155 const char* Wrapper<QColor>::class_name() {
 156   return "Color";
 157 }
 158
 159 int Wrapper<QColor>::to_string(lua_State* l) {
 160   QColor *r = retrieve(l, 1, AssertOk);
 161   char buf[32];
 162   snprintf(buf, 32, "#%08x", r->rgba());
 163   lua_pushstring(l, buf);
 164   return 1;
 165 }
 166
 167 void Wrapper<QColor>::create_index_table(lua_State* l) {
 168   SET_PROPERTY_RW(l, r);
 169   SET_PROPERTY_RW(l, g);
 170   SET_PROPERTY_RW(l, b);
 171   SET_PROPERTY_RW(l, a);
 172
 173   set_meta_method(l, &to_string, "__tostring");
 174 }
 175
 176 QColor Wrapper<QColor>::get(lua_State* l, int index) {
 177   if(lua_isstring(l, index)) {
 178     QColor retv(lua_tostring(l, index));
 179     if(!retv.isValid())
 180       luaL_error(l, "Wrong color string \"%s\"", lua_tostring(l, index));
 181     return retv;
 182   }
 183   else
 184     return *retrieve(l, index, AssertOk);
 185 }
 186
 187 int Wrapper<QColor>::constructor(lua_State* l) {
 188   const int n = lua_gettop(l);
 189
 190   switch (n) {
 191   case 0:
 192     create(l);
 193     break;
 194   case 1:
 195     {
 196       QColor c = get(l, 1);
 197       lua_pop(l, 1);
 198       create(l, c);
 199       break;
 200     }
 201   case 3:
 202   case 4:
 203     {
 204       int r = int(lua_tonumber(l, 1));
 205       int g = int(lua_tonumber(l, 2));
 206       int b = int(lua_tonumber(l, 3));
 207       int a = (n == 3) ? 255 : int(lua_tonumber(l, 4));
 208
 209       lua_pop(l, n);
 210       create(l, r, g, b, a);
 211     }
 212     break;
 213   default:
 214     luaL_error(l, "Wrong parameter list for Color constructor");
 215   }
 216
 217   return 1;
 218 }
 219
 220 //END Wrapper<QColor>----------------------------------------------------------
 221
 222 template<typename T>
 223 int GradientWrapper<T>::index_event(lua_State* l) {
 224   if(!lua_isnumber(l, -1))
 225     return GenericWrapperBase::object_meta_index_event(l);
 226
 227   T *g = Wrapper<T>::retrieve(l, -2, AssertOk);
 228   double stopnum = lua_tonumber(l, -1);
 229   lua_pop(l, 1);
 230
 231   QGradientStops s = g->stops();
 232   int retv;
 233   if(s.size()) {
 234     int min = 0;
 235     int max = s.size();
 236     while(min < max-1) {
 237       int mid = (min+max)/2;
 238       if(stopnum > s[(min+max)/2].first)
 239         min = mid;
 240       else
 241         max = mid;
 242     }
 243     if(qAbs(s[max].first-stopnum) < qAbs(s[min].first-stopnum))
 244       retv = max;
 245     else
 246       retv = min;
 247   }
 248   Wrapper<QColor>::create(l, s[retv].second);
 249   lua_pushnumber(l, s[retv].first);
 250
 251   return 2;
 252 }
 253
 254 template<typename T>
 255 int GradientWrapper<T>::newindex_event(lua_State* l) {
 256   if(!lua_isnumber(l, -2))
 257     return GenericWrapperBase::object_meta_newindex_event(l);
 258
 259   T *g = Wrapper<T>::retrieve(l, -3, AssertOk);
 260   double stopnum = lua_tonumber(l, -2);
 261   QColor col = Wrapper<QColor>::get(l, -1);
 262   lua_pop(l, 3);
 263
 264   g->setColorAt(stopnum, col);
 265   return 0;
 266 }
 267
 268
 269 //BEGIN Wrapper<QLinearGradient>--------------------------------------------------------
 270
 271 const char* Wrapper<QLinearGradient>::class_name() {
 272   return "LinearGradient";
 273 }
 274
 275 void Wrapper<QLinearGradient>::create_index_table(lua_State* l) {
 276   SET_PROPERTY_RW(l, start);
 277   SET_PROPERTY_RW(l, finish);
 278
 279   //set_meta_method(l, &index_event, "__index");
 280   set_meta_method(l, &newindex_event, "__newindex");
 281 }
 282
 283 int Wrapper<QLinearGradient>::constructor(lua_State* l) {
 284   const int n = lua_gettop(l);
 285
 286   switch(n) {
 287     case 0:
 288       create(l);
 289       break;
 290     case 2: {
 291       QPointF* start = Wrapper<QPointF>::retrieve(l, 1, AssertOk);
 292       QPointF* final = Wrapper<QPointF>::retrieve(l, 2, AssertOk);
 293       lua_pop(l, 2);
 294       create(l, *start, *final);
 295       break;
 296     }
 297     default:
 298       luaL_error(l, "Wrong parameter list for LinearGradient constructor");
 299       break;
 300   }
 301
 302   return 1;
 303 }
 304
 305 //END Wrapper<QLinearGradient>----------------------------------------------------------
 306
 307
 308 //BEGIN Wrapper<QRadialGradient>--------------------------------------------------------
 309
 310 const char* Wrapper<QRadialGradient>::class_name() {
 311   return "RadialGradient";
 312 }
 313
 314 void Wrapper<QRadialGradient>::create_index_table(lua_State* l) {
 315   SET_PROPERTY_RW(l, center);
 316   SET_PROPERTY_RW(l, radius);
 317   SET_PROPERTY_RW(l, focus);
 318
 319   //set_meta_method(l, &index_event, "__index");
 320   set_meta_method(l, &newindex_event, "__newindex");
 321 }
 322
 323 int Wrapper<QRadialGradient>::constructor(lua_State* l) {
 324   const int n = lua_gettop(l);
 325
 326   switch(n) {
 327     case 0:
 328       create(l);
 329       break;
 330     case 2: {
 331       QPointF* center = Wrapper<QPointF>::retrieve(l, 1, AssertOk);
 332       double radius = lua_tonumber(l, 2);
 333       lua_pop(l, 2);
 334       create(l, *center, radius);
 335       break;
 336     }
 337     case 3: {
 338       QPointF* center = Wrapper<QPointF>::retrieve(l, 1, AssertOk);
 339       double radius = lua_tonumber(l, 2);
 340       QPointF* focus = Wrapper<QPointF>::retrieve(l, 3, AssertOk);
 341       lua_pop(l, 3);
 342       create(l, *center, radius, *focus);
 343       break;
 344     }
 345     default:
 346       luaL_error(l, "Wrong parameter list for RadialGradient constructor");
 347       break;
 348   }
 349
 350   return 1;
 351 }
 352
 353 //END Wrapper<QRadialGradient>----------------------------------------------------------
 354
 355 //BEGIN Wrapper<QConicalGradient>--------------------------------------------------------
 356
 357 const char* Wrapper<QConicalGradient>::class_name() {
 358   return "ConicalGradient";
 359 }
 360
 361 void Wrapper<QConicalGradient>::create_index_table(lua_State* l) {
 362   SET_PROPERTY_RW(l, center);
 363   SET_PROPERTY_RW(l, angle);
 364
 365   //set_meta_method(l, &index_event, "__index");
 366   set_meta_method(l, &newindex_event, "__newindex");
 367 }
 368
 369 int Wrapper<QConicalGradient>::constructor(lua_State* l) {
 370   const int n = lua_gettop(l);
 371
 372   switch(n) {
 373     case 0:
 374       create(l);
 375       break;
 376     case 2: {
 377       QPointF* center = Wrapper<QPointF>::retrieve(l, 1, AssertOk);
 378       double angle = lua_tonumber(l, 2);
 379       lua_pop(l, 2);
 380       create(l, *center, angle);
 381       break;
 382     }
 383     default:
 384       luaL_error(l, "Wrong parameter list for Color constructor");
 385       break;
 386   }
 387
 388   return 1;
 389 }
 390
 391 //END Wrapper<QConicalGradient>----------------------------------------------------------
 392
 393 //BEGIN Wrapper<QBrush>--------------------------------------------------------
 394
 395 const char* Wrapper<QBrush>::class_name() {
 396   return "Brush";
 397 }
 398
 399 void Wrapper<QBrush>::create_index_table(lua_State* l) {
 400
 401   //set_meta_method(l, &to_string, "__tostring");
 402   set_method(l, &translate, "translate");
 403   set_method(l, &rotate, "rotate");
 404   set_method(l, &scale, "scale");
 405 }
 406
 407 QBrush Wrapper<QBrush>::get(lua_State* l, int index) {
 408   if(QBrush *b = retrieve(l, index))
 409     return *b;
 410   else if(QLinearGradient* g = Wrapper<QLinearGradient>::retrieve(l, index))
 411     return QBrush(*g);
 412   else if(QRadialGradient* g = Wrapper<QRadialGradient>::retrieve(l, index))
 413     return QBrush(*g);
 414   else if(QConicalGradient* g = Wrapper<QConicalGradient>::retrieve(l, index))
 415     return QBrush(*g);
 416   else if(Loader::Image* img = Wrapper<Image>::retrieve(l, index))
 417     return QBrush(img->image());
 418   else
 419     return QBrush(Wrapper<QColor>::get(l, index));
 420 }
 421
 422 int Wrapper<QBrush>::constructor(lua_State* l) {
 423   const int n = lua_gettop(l);
 424
 425   switch (n) {
 426   case 0:
 427     create(l, Qt::NoBrush);
 428     break;
 429   case 1: {
 430       QBrush b = get(l, 1);
 431       lua_pop(l, 1);
 432       create(l, b);
 433       break;
 434     }
 435   default:
 436     luaL_error(l, "Wrong parameter list for Brush constructor");
 437   }
 438
 439   return 1;
 440 }
 441
 442 int Wrapper<QBrush>::rotate(lua_State* l) {
 443   const int n = lua_gettop(l);
 444   if (n != 2) luaL_error(l, "Wrong argument count for Brush::rotate");
 445
 446   QBrush* brush = retrieve(l, 1, AssertOk);
 447   double r = lua_tonumber(l, 2);
 448   lua_pop(l, n);
 449
 450   QMatrix m = brush->matrix();
 451   m = m * QMatrix().rotate(r);
 452   brush->setMatrix(m);
 453   return 0;
 454 }
 455
 456 int Wrapper<QBrush>::scale(lua_State* l) {
 457   const int n = lua_gettop(l);
 458   if (n != 3) luaL_error(l, "Wrong argument count for Brush::scale");
 459
 460   QBrush* brush = retrieve(l, 1, AssertOk);
 461   double x = lua_tonumber(l, 2);
 462   double y = lua_tonumber(l, 3);
 463   lua_pop(l, n);
 464
 465   QMatrix m = brush->matrix();
 466   m = m * QMatrix().scale(x, y);
 467   brush->setMatrix(m);
 468   return 0;
 469 }
 470
 471 int Wrapper<QBrush>::translate(lua_State* l) {
 472   const int n = lua_gettop(l);
 473   if (n < 2 || n > 3) luaL_error(l, "Wrong argument count for Brush::translate");
 474
 475   QBrush* brush = retrieve(l, 1, AssertOk);
 476   if(n == 3) {
 477     double x = lua_tonumber(l, 2);
 478     double y = lua_tonumber(l, 3);
 479     lua_pop(l, n);
 480
 481     QMatrix m = brush->matrix();
 482     m = m * QMatrix().translate(x, y);
 483     brush->setMatrix(m);
 484   }
 485   else {
 486     QPointF* point = Wrapper<QPointF>::retrieve(l, 2, AssertOk);
 487     lua_pop(l, n);
 488
 489     QMatrix m = brush->matrix();
 490     m = m * QMatrix().translate(point->x(), point->y());
 491     brush->setMatrix(m);
 492   }
 493   return 0;
 494 }
 495
 496 //END Wrapper<QBrush>----------------------------------------------------------
 497
 498
 499 //BEGIN Wrapper<QFont>--------------------------------------------------------
 500
 501 const char* Wrapper<QFont>::class_name() {
 502   return "Font";
 503 }
 504
 505 void Wrapper<QFont>::create_index_table(lua_State* l) {
 506   set_meta_method(l, &to_string, "__tostring");
 507 }
 508
 509 int Wrapper<QFont>::constructor(lua_State* l) {
 510   const int n = lua_gettop(l);
 511
 512   switch (n) {
 513   case 0:
 514     create(l, QApplication::font());
 515     break;
 516   case 1: {
 517       QFont *b = retrieve(l, 1, AssertOk);
 518       lua_pop(l, 1);
 519       create(l, *b);
 520       break;
 521     }
 522   case 3: {
 523       QString family = lua_tostring(l, 1);
 524       bool bold = lua_toboolean(l, 2);
 525       bool italic = lua_toboolean(l, 3);
 526       lua_pop(l, 3);
 527       create(l, family, 12, bold ? QFont::Bold : QFont::Normal, italic);
 528       break;
 529     }
 530   default:
 531     luaL_error(l, "Wrong parameter list for Font constructor");
 532   }
 533
 534   return 1;
 535 }
 536
 537 int Wrapper<QFont>::to_string(lua_State* l) {
 538   QFont *r = retrieve(l, 1, AssertOk);
 539   lua_pushstring(l, r->rawName().toAscii().constData());
 540   return 1;
 541 }
 542
 543 //END Wrapper<QFont>----------------------------------------------------------
 544
 545 //BEGIN Wrapper<Image> --------------------------------------------------------
 546
 547 const char* Wrapper<Image>::class_name() {
 548   return "Image";
 549 }
 550
 551 void Wrapper<Image>::create_index_table(lua_State* l) {
 552   SET_PROPERTY_RO(l, width);
 553   SET_PROPERTY_RO(l, height);
 554   SET_PROPERTY_RW(l, opacity);
 555
 556   set_method(l, &resetMatrix, "reset_matrix");
 557   set_method(l, &rotate, "rotate");
 558   set_method(l, &scale, "scale");
 559   set_method(l, &translate, "translate");
 560   set_method(l, &setPaintOver, "set_paint_over");
 561   set_method(l, &clear, "clear");
 562   set_method(l, &fillRect, "fill_rect");
 563   set_method(l, &drawLine, "draw_line");
 564   set_method(l, &drawImage, "draw_image");
 565   set_method(l, &drawSVG, "draw_svg");
 566   set_method(l, &drawGlyph, "draw_glyph");
 567   set_method(l, &expBlur, "exp_blur");
 568   set_method(l, &createShadow, "create_shadow");
 569 }
 570
 571 int Wrapper<Image>::constructor(lua_State* l) {
 572   const int n = lua_gettop(l);
 573
 574   switch (n) {
 575   case 1: {
 576       if(lua_isstring(l, 1)) {
 577         QString path = file_path(l, lua_tostring(l, 1));
 578         Context* context = retrieve_context(l);
 579         lua_pop(l, 1);
 580         create(l, context, path );
 581       }
 582       else {
 583         Image *res = retrieve(l, 1, AssertOk);
 584         lua_pop(l, 1);
 585         create(l, *res );
 586       }
 587     }
 588     break;
 589   case 2: {
 590       if(lua_isnumber(l, 1)) {
 591         int width = static_cast<int>(lua_tonumber(l, 1));
 592         int height = static_cast<int>(lua_tonumber(l, 2));
 593         lua_pop(l, 2);
 594         create(l, width, height);
 595       }
 596       else {
 597         QString path = file_path(l, lua_tostring(l, 1));
 598         bool use_cache = lua_toboolean(l, 2);
 599         Context* context = retrieve_context(l);
 600         lua_pop(l, 2);
 601         create(l, context, path, use_cache );
 602       }
 603     }
 604     break;
 605   default:
 606     luaL_error(l, "Wrong argument count for Image constructor");
 607   }
 608
 609   return 1;
 610 }
 611
 612 int Wrapper<Image>::resetMatrix(lua_State* l) {
 613   const int n = lua_gettop(l);
 614   if (n != 1) luaL_error(l, "Wrong argument count for Image::reset_matrix");
 615
 616   Image* img = retrieve(l, 1, AssertOk);
 617   lua_pop(l, n);
 618
 619   img->resetMatrix();
 620   return 0;
 621 }
 622
 623 int Wrapper<Image>::rotate(lua_State* l) {
 624   const int n = lua_gettop(l);
 625   if (n != 2) luaL_error(l, "Wrong argument count for Image::rotate");
 626
 627   Image* img = retrieve(l, 1, AssertOk);
 628   double r = lua_tonumber(l, 2);
 629   lua_pop(l, n);
 630
 631   img->rotate(r);
 632   return 0;
 633 }
 634
 635 int Wrapper<Image>::scale(lua_State* l) {
 636   const int n = lua_gettop(l);
 637   if (n != 3) luaL_error(l, "Wrong argument count for Image::scale");
 638
 639   Image* img = retrieve(l, 1, AssertOk);
 640   double x = lua_tonumber(l, 2);
 641   double y = lua_tonumber(l, 3);
 642   lua_pop(l, n);
 643
 644   img->scale(x, y);
 645   return 0;
 646 }
 647
 648 int Wrapper<Image>::translate(lua_State* l) {
 649   const int n = lua_gettop(l);
 650   if (n < 2 || n > 3) luaL_error(l, "Wrong argument count for Image::translate");
 651
 652   Image* img = retrieve(l, 1, AssertOk);
 653   if(n == 3) {
 654     double x = lua_tonumber(l, 2);
 655     double y = lua_tonumber(l, 3);
 656     lua_pop(l, n);
 657
 658     img->translate(x, y);
 659   }
 660   else {
 661     QPointF* point = Wrapper<QPointF>::retrieve(l, 2, AssertOk);
 662     lua_pop(l, n);
 663
 664     img->translate(point->x(), point->y());
 665   }
 666   return 0;
 667 }
 668
 669 int Wrapper<Image>::clear(lua_State* l) {
 670   const int n = lua_gettop(l);
 671   if (n < 1 || n > 2) luaL_error(l, "Wrong argument count for Image::clear");
 672
 673   Image* img = retrieve(l, 1, AssertOk);
 674
 675   if(n == 2) {
 676     QColor col = Wrapper<QColor>::get(l, 2);
 677     lua_pop(l, n);
 678     img->clear(col);
 679   }
 680   else {
 681     lua_pop(l, n);
 682     img->clear();
 683   }
 684   return 0;
 685 }
 686
 687 int Wrapper<Image>::setPaintOver(lua_State* l) {
 688   const int n = lua_gettop(l);
 689   if (n != 2) luaL_error(l, "Wrong argument count for Image::set_paint_over");
 690
 691   Image* img = retrieve(l, 1, AssertOk);
 692   bool p = lua_toboolean(l, 2);
 693   lua_pop(l, n);
 694
 695   img->setPaintOver(p);
 696   return 0;
 697 }
 698
 699 int Wrapper<Image>::fillRect(lua_State* l) {
 700   const int n = lua_gettop(l);
 701   if (n != 3) luaL_error(l, "Wrong argument count for Image::fill_rect");
 702
 703   Image* img = retrieve(l, 1, AssertOk);
 704   QRectF* rect = Wrapper<QRectF>::retrieve(l, 2, AssertOk);
 705   QBrush brush = Wrapper<QBrush>::get(l, 3);
 706   lua_pop(l, n);
 707
 708   img->fillRect(*rect, brush);
 709   return 0;
 710 }
 711
 712 int Wrapper<Image>::drawLine(lua_State* l) {
 713   const int n = lua_gettop(l);
 714   if (n > 5 || n < 4) luaL_error(l, "Wrong argument count for Image::draw_line");
 715
 716   Image* img = retrieve(l, 1, AssertOk);
 717   QPointF* from = Wrapper<QPointF>::retrieve(l, 2, AssertOk);
 718   QPointF* to = Wrapper<QPointF>::retrieve(l, 3, AssertOk);
 719   QColor color = Wrapper<QColor>::get(l, 4);
 720   double width = (n==5) ? lua_tonumber(l, 5) : 0.0;
 721   lua_pop(l, n);
 722
 723   img->drawLine(*from, *to, color, width);
 724   return 0;
 725 }
 726
 727 int Wrapper<Image>::drawImage(lua_State* l) {
 728   const int n = lua_gettop(l);
 729   if (n < 3 || n > 5) luaL_error(l, "Wrong argument count for Image::draw_image");
 730
 731   Image* img = retrieve(l, 1, AssertOk);
 732   QRectF* dest = Wrapper<QRectF>::retrieve(l, 2, AssertOk);
 733   if (lua_isstring(l, 3)) {
 734     Context* context = retrieve_context(l);
 735     const char* image_path = lua_tostring(l, 3);
 736     bool res;
 737     if (n >= 4) {
 738       QRectF* src = Wrapper<QRectF>::retrieve(l, 4, AssertOk);
 739       bool use_cache = n == 5 ? lua_toboolean(l, 5) : true;
 740       res = img->drawImage(context, *dest, file_path(l, image_path), *src, use_cache);
 741     }
 742     else
 743       res = img->drawImage(context, *dest, file_path(l, image_path) );
 744
 745     lua_pop(l, n);
 746     lua_pushboolean(l, res);
 747     return 1;
 748   }
 749   else {
 750     if (n == 5) luaL_error(l, "Wrong argument count for Image::draw_image");
 751
 752     Image* image = retrieve(l, 3, AssertOk);
 753     if (n == 4) {
 754       QRectF* src = Wrapper<QRectF>::retrieve(l, 4, AssertOk);
 755       img->drawImage(*dest, *image, *src);
 756     }
 757     else
 758       img->drawImage(*dest, *image);
 759
 760     lua_pop(l, n);
 761     return 0;
 762   }
 763 }
 764
 765 int Wrapper<Image>::drawSVG(lua_State* l) {
 766   const int n = lua_gettop(l);
 767   if (n != 3) luaL_error(l, "Wrong argument count for Image::draw_svg");
 768
 769   Image* img = retrieve(l, 1, AssertOk);
 770   QRectF* rect = Wrapper<QRectF>::retrieve(l, 2, AssertOk);
 771   const char* file = lua_tostring(l, 3);
 772   Context* context = retrieve_context(l);
 773   lua_pop(l, n);
 774
 775   bool res = img->drawSVG(context, *rect, file_path(l, file) );
 776   lua_pushboolean(l, res);
 777   return 1;
 778 }
 779
 780 int Wrapper<Image>::drawGlyph(lua_State* l) {
 781   int n = lua_gettop(l);
 782   if (n < 4 || n > 8) luaL_error(l, "Wrong argument count for Image::draw_glyph");
 783
 784   Image* img = retrieve(l, 1, AssertOk);
 785   QRectF* rect = Wrapper<QRectF>::retrieve(l, 2, AssertOk);
 786   const char* font = lua_tostring(l, 3);
 787   const char* glyph_str = lua_tostring(l, 4);
 788   if(!font || !glyph_str)
 789     luaL_error(l, "Null arguments for Image::draw_glyph");
 790
 791   unsigned int glyph = strtoul(glyph_str, NULL, 0);
 792   bool draw_inner_bg = true;
 793   double border = 0.0;
 794   QBrush fg = Qt::black;
 795   QBrush bg = Qt::white;
 796
 797   switch (n) {
 798   case 8:
 799     draw_inner_bg = lua_toboolean(l, 8);
 800   case 7:
 801     border = lua_tonumber(l, 7);
 802   case 6:
 803     bg = Wrapper<QBrush>::get(l, 6);
 804   case 5:
 805     fg = Wrapper<QBrush>::get(l, 5);
 806   default:
 807     break;
 808   }
 809   lua_pop(l, n);
 810
 811   Context* context = retrieve_context(l);
 812
 813   bool res = img->drawGlyph(context, *rect, file_path(l, font), glyph,
 814                                           fg, bg, border, draw_inner_bg);
 815   lua_pushboolean(l, res);
 816   return 1;
 817 }
 818
 819 int Wrapper<Image>::expBlur(lua_State* l) {
 820   int n = lua_gettop(l);
 821   if (n != 2) luaL_error(l, "Wrong argument count for Image::exp_blur");
 822
 823   Image* img = retrieve(l, 1, AssertOk);
 824   double radius = lua_tonumber(l, 2);
 825
 826   img->expBlur(radius);
 827
 828   lua_pop(l, n);
 829   return 0;
 830 }
 831
 832 int Wrapper<Image>::createShadow(lua_State* l) {
 833   int n = lua_gettop(l);
 834   if (n < 3 || n > 5) luaL_error(l, "Wrong argument count for Image::create_shadow");
 835
 836   Image* img = retrieve(l, 1, AssertOk);
 837   double radius = lua_tonumber(l, 2);
 838   QColor color = Wrapper<QColor>::get(l, 3);
 839
 840   QPoint grow;
 841   QPointF offset;
 842
 843   switch (n) {
 844   case 5:
 845     offset = *Wrapper<QPointF>::retrieve(l, 5, AssertOk);
 846   case 4:
 847     grow = Wrapper<QPointF>::retrieve(l, 4, AssertOk)->toPoint();
 848   default:
 849     break;
 850   }
 851   lua_pop(l, n);
 852
 853   create(l, img->createShadow(radius, color, grow, offset));
 854   return 1;
 855 }
 856
 857 //END Wrapper<Image> ----------------------------------------------------------
 858
 859 //BEGIN Wrapper<Glyph> ------------------------------------------------------
 860
 861 const char* Wrapper<Glyph>::class_name() {
 862   return "Glyph";
 863 }
 864
 865 void Wrapper<Glyph>::create_index_table(lua_State* /*l*/) {
 866
 867 }
 868
 869 int Wrapper<Glyph>::constructor(lua_State* l) {
 870   const int n = lua_gettop(l);
 871
 872   switch(n) {
 873   case 1: {
 874       unsigned int c = strtoul(lua_tostring(l, 1), NULL, 0);
 875       lua_pop(l, 1);
 876       create(l, c);
 877     }
 878     break;
 879   case 2: {
 880       Context* context = retrieve_context(l);
 881       QString path = file_path(l, lua_tostring(l, 1));
 882       unsigned int c = strtoul(lua_tostring(l, 2), NULL, 0);
 883       lua_pop(l, 2);
 884       create(l, context, path, c);
 885     }
 886     break;
 887   case 3: {
 888       Context* context = retrieve_context(l);
 889       if (lua_isnil(l, 1)) {
 890         // no font path, just load the string
 891         QString str(lua_tostring(l, 2));
 892         int d = static_cast<int>(lua_tonumber(l, 3));
 893         lua_pop(l, 3);
 894         create(l, str, d);
 895       }
 896       else {
 897         QString path = file_path(l, lua_tostring(l, 1));
 898         unsigned int c = strtoul(lua_tostring(l, 2), NULL, 0);
 899         int d = int(lua_tonumber(l, 3));
 900         lua_pop(l, 3);
 901         create(l, context, path, c, d);
 902       }
 903     }
 904     break;
 905   default:
 906     luaL_error(l, "Wrong argument count for Glyph constructor");
 907     break;
 908   }
 909
 910   return 1;
 911 }
 912
 913 //END Wrapper<QPointF> --------------------------------------------------------
 914
 915 } //end namespace LuaApi
 916