src/luaapi/imaging.cpp

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