image.c

   1 /*
   2  * image.c - image object
   3  *
   4  * Copyright © 2008-2009 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <xcb/xcb_image.h>
  23
  24 #include <Imlib2.h>
  25
  26 #include "globalconf.h"
  27 #include "config.h"
  28 #include "luaa.h"
  29 #include "common/luaobject.h"
  30
  31 struct image
  32 {
  33     LUA_OBJECT_HEADER
  34     /** Imlib2 image */
  35     Imlib_Image image;
  36     /** Image data */
  37     uint8_t *data;
  38     /** Flag telling if the image is up to date or needs computing before
  39      * drawing */
  40     bool isupdated;
  41 };
  42
  43 LUA_OBJECT_FUNCS(image_class, image_t, image)
  44
  45 static int
  46 luaA_image_gc(lua_State *L)
  47 {
  48     image_t *p = luaA_checkudata(L, 1, &image_class);
  49     imlib_context_set_image(p->image);
  50     imlib_free_image();
  51     p_delete(&p->data);
  52     return luaA_object_gc(L);
  53 }
  54
  55 static const char *
  56 image_imlib_load_strerror(Imlib_Load_Error e)
  57 {
  58     switch(e)
  59     {
  60       case IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST:
  61         return "no such file or directory";
  62       case IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY:
  63         return "file is a directory";
  64       case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ:
  65         return "read permission denied";
  66       case IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT:
  67         return "no loader for file format";
  68       case IMLIB_LOAD_ERROR_PATH_TOO_LONG:
  69         return "path too long";
  70       case IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT:
  71         return "path component non existent";
  72       case IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY:
  73         return "path component not a directory";
  74       case IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE:
  75         return "path points outside address space";
  76       case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS:
  77         return "too many symbolic links";
  78       case IMLIB_LOAD_ERROR_OUT_OF_MEMORY:
  79         return "out of memory";
  80       case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS:
  81         return "out of file descriptors";
  82       case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE:
  83         return "write permission denied";
  84       case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE:
  85         return "out of disk space";
  86       case IMLIB_LOAD_ERROR_UNKNOWN:
  87         return "unknown error, that's really bad";
  88       case IMLIB_LOAD_ERROR_NONE:
  89         return "no error, oops";
  90     }
  91
  92     return "unknown error";
  93 }
  94
  95 /** Get image width.
  96  * \param image The image.
  97  * \return The image width in pixel.
  98  */
  99 int
 100 image_getwidth(image_t *image)
 101 {
 102     imlib_context_set_image(image->image);
 103     return imlib_image_get_width();
 104 }
 105
 106 /** Get image height.
 107  * \param image The image.
 108  * \return The image height in pixel.
 109  */
 110 int
 111 image_getheight(image_t *image)
 112 {
 113     imlib_context_set_image(image->image);
 114     return imlib_image_get_height();
 115 }
 116
 117 /** Get the ARGB32 data from an image.
 118  * \param image The image.
 119  * \return Data.
 120  */
 121 uint8_t *
 122 image_getdata(image_t *image)
 123 {
 124     int size, i;
 125     uint32_t *data;
 126     double alpha;
 127     uint8_t *dataimg;
 128 #if AWESOME_IS_BIG_ENDIAN
 129     const int index_a = 0, index_r = 1, index_g = 2, index_b = 3;
 130 #else
 131     const int index_a = 3, index_r = 2, index_g = 1, index_b = 0;
 132 #endif
 133
 134     if(image->isupdated)
 135         return image->data;
 136
 137     imlib_context_set_image(image->image);
 138
 139     data = imlib_image_get_data_for_reading_only();
 140
 141     size = imlib_image_get_width() * imlib_image_get_height();
 142
 143     p_realloc(&image->data, size * 4);
 144     dataimg = image->data;
 145
 146     for(i = 0; i < size; i++, dataimg += 4)
 147     {
 148         dataimg[index_a] = (data[i] >> 24) & 0xff;           /* A */
 149         /* cairo wants pre-multiplied alpha */
 150         alpha = dataimg[index_a] / 255.0;
 151         dataimg[index_r] = ((data[i] >> 16) & 0xff) * alpha; /* R */
 152         dataimg[index_g] = ((data[i] >>  8) & 0xff) * alpha; /* G */
 153         dataimg[index_b] = (data[i]         & 0xff) * alpha; /* B */
 154     }
 155
 156     image->isupdated = true;
 157
 158     return image->data;
 159
 160 }
 161
 162 static void
 163 image_draw_to_1bit_ximage(image_t *image, xcb_image_t *img)
 164 {
 165     imlib_context_set_image(image->image);
 166
 167     uint32_t *data = imlib_image_get_data_for_reading_only();
 168
 169     int width = imlib_image_get_width();
 170     int height = imlib_image_get_height();
 171
 172     for(int y = 0; y < height; y++)
 173         for(int x = 0; x < width; x++)
 174         {
 175             int i, pixel, tmp;
 176
 177             i = y * width + x;
 178
 179             // Sum up all color components ignoring alpha
 180             tmp  = (data[i] >> 16) & 0xff;
 181             tmp += (data[i] >>  8) & 0xff;
 182             tmp +=  data[i]        & 0xff;
 183
 184             pixel = (tmp / 3 < 127) ? 0 : 1;
 185
 186             xcb_image_put_pixel(img, x, y, pixel);
 187         }
 188 }
 189
 190 // Convert an image to a 1bit pixmap
 191 xcb_pixmap_t
 192 image_to_1bit_pixmap(image_t *image, xcb_drawable_t d)
 193 {
 194     xcb_pixmap_t pixmap;
 195     xcb_gcontext_t gc;
 196     xcb_image_t *img;
 197     uint16_t width, height;
 198
 199     width = image_getwidth(image);
 200     height = image_getheight(image);
 201
 202     /* Prepare the pixmap and gc */
 203     pixmap = xcb_generate_id(globalconf.connection);
 204     xcb_create_pixmap(globalconf.connection, 1, pixmap, d, width, height);
 205
 206     gc = xcb_generate_id(globalconf.connection);
 207     xcb_create_gc(globalconf.connection, gc, pixmap, 0, NULL);
 208
 209     /* Prepare the image */
 210     img = xcb_image_create_native(globalconf.connection, width, height,
 211             XCB_IMAGE_FORMAT_XY_BITMAP, 1, NULL, 0, NULL);
 212     image_draw_to_1bit_ximage(image, img);
 213
 214     /* Paint the image to the pixmap */
 215     xcb_image_put(globalconf.connection, pixmap, gc, img, 0, 0, 0);
 216
 217     xcb_free_gc(globalconf.connection, gc);
 218
 219     xcb_image_destroy(img);
 220
 221     return pixmap;
 222 }
 223
 224 /** Create a new image from ARGB32 data.
 225  * \param width The image width.
 226  * \param height The image height.
 227  * \param data The image data.
 228  * \return 1 if an image has been pushed on stack, 0 otherwise.
 229  */
 230 int
 231 image_new_from_argb32(int width, int height, uint32_t *data)
 232 {
 233     Imlib_Image imimage;
 234
 235     if((imimage = imlib_create_image_using_copied_data(width, height, data)))
 236     {
 237         imlib_context_set_image(imimage);
 238         imlib_image_set_has_alpha(true);
 239         image_t *image = image_new(globalconf.L);
 240         image->image = imimage;
 241         return 1;
 242     }
 243
 244     return 0;
 245 }
 246
 247 /** Create a new, completely black image.
 248  * \param width The image width.
 249  * \param height The image height.
 250  * \return 1 if an image has been pushed on stack, 0 otherwise.
 251  */
 252 static int
 253 image_new_blank(int width, int height)
 254 {
 255     Imlib_Image imimage;
 256
 257     if((imimage = imlib_create_image(width, height)))
 258     {
 259         imlib_context_set_image(imimage);
 260         imlib_image_set_has_alpha(true);
 261         /* After creation, an image has undefined content. Fix that up. */
 262         imlib_context_set_color(0, 0, 0, 0xff);
 263         imlib_image_fill_rectangle(0, 0, width, height);
 264         image_t *image = image_new(globalconf.L);
 265         image->image = imimage;
 266         return 1;
 267     }
 268
 269     return 0;
 270 }
 271
 272 /** Load an image from filename.
 273  * \param filename The image file to load.
 274  * \return 1 if image is loaded and on stack, 0 otherwise.
 275  */
 276 static int
 277 image_new_from_file(const char *filename)
 278 {
 279     Imlib_Image imimage;
 280     Imlib_Load_Error e = IMLIB_LOAD_ERROR_NONE;
 281     image_t *image;
 282
 283     if(!filename)
 284         return 0;
 285
 286     if(!(imimage = imlib_load_image_with_error_return(filename, &e)))
 287     {
 288         warn("cannot load image %s: %s", filename, image_imlib_load_strerror(e));
 289         return 0;
 290     }
 291
 292     /* Make imlib check if the file changed on disk if it's later opened by the
 293      * same file name again before using its cache.
 294      */
 295     imlib_context_set_image(imimage);
 296     imlib_image_set_changes_on_disk();
 297
 298     image = image_new(globalconf.L);
 299     image->image = imimage;
 300
 301     return 1;
 302 }
 303
 304 /** Create a new image object.
 305  * \param L The Lua stack.
 306  * \return The number of elements pushed on stack.
 307  * \luastack
 308  * \lparam The image path.
 309  * \lreturn An image object.
 310  */
 311 static int
 312 luaA_image_new(lua_State *L)
 313 {
 314     const char *filename;
 315
 316     if((filename = lua_tostring(L, 2)))
 317         return image_new_from_file(filename);
 318     return 0;
 319 }
 320
 321 /** Create a new image object from ARGB32 data.
 322  * \param L The Lua stack.
 323  * \return The number of elements pushed on stack.
 324  * \luastack
 325  * \lparam The image width.
 326  * \lparam The image height.
 327  * \lparam The image data as a string in ARGB32 format, or nil to create an
 328  * empty image.
 329  * \lreturn An image object.
 330  */
 331 static int
 332 luaA_image_argb32_new(lua_State *L)
 333 {
 334     size_t len;
 335     unsigned int width = luaL_checknumber(L, 1);
 336     unsigned int height = luaL_checknumber(L, 2);
 337
 338     if (width == 0)
 339         luaL_error(L, "image.argb32() called with zero width");
 340     if (height == 0)
 341         luaL_error(L, "image.argb32() called with zero height");
 342
 343     if(lua_isnil(L, 3))
 344     {
 345         return image_new_blank(width, height);
 346     }
 347
 348     const char *data = luaL_checklstring(L, 3, &len);
 349
 350     if(width * height * 4 != len)
 351         luaL_error(L, "string size does not match image size");
 352
 353     return image_new_from_argb32(width, height, (uint32_t *) data);
 354 }
 355
 356 /** Performs 90 degree rotations on the current image. Passing 0 orientation
 357  * does not rotate, 1 rotates clockwise by 90 degree, 2, rotates clockwise by
 358  * 180 degrees, 3 rotates clockwise by 270 degrees.
 359  * \param L The Lua VM state.
 360  * \return The number of elements pushed on stack.
 361  * \luastack
 362  * \lvalue An image.
 363  * \lparam The rotation to perform.
 364  */
 365 static int
 366 luaA_image_orientate(lua_State *L)
 367 {
 368     image_t *image = luaA_checkudata(L, 1, &image_class);
 369     int orientation = luaL_checknumber(L, 2);
 370
 371     imlib_context_set_image(image->image);
 372     imlib_image_orientate(orientation);
 373
 374     image->isupdated = false;
 375
 376     return 0;
 377 }
 378
 379 /** Rotate an image with specified angle radians and return a new image.
 380  * \param L The Lua VM state.
 381  * \return The number of elements pushed on stack.
 382  * \luastack
 383  * \lvalue An image.
 384  * \lparam The angle in radians.
 385  * \lreturn A rotated image.
 386  */
 387 static int
 388 luaA_image_rotate(lua_State *L)
 389 {
 390     image_t *image = luaA_checkudata(L, 1, &image_class), *new;
 391     double angle = luaL_checknumber(L, 2);
 392
 393     new = image_new(L);
 394
 395     imlib_context_set_image(image->image);
 396     new->image = imlib_create_rotated_image(angle);
 397
 398     return 1;
 399 }
 400
 401 /** Crop an image to the given rectangle.
 402  * \return The number of elements pushed on stack.
 403  * \luastack
 404  * \lvalue An image.
 405  * \lparam The top left x coordinate of the rectangle.
 406  * \lparam The top left y coordinate of the rectangle.
 407  * \lparam The width of the rectangle.
 408  * \lparam The height of the rectangle.
 409  * \lreturn A cropped image.
 410  */
 411 static int
 412 luaA_image_crop(lua_State *L)
 413 {
 414     image_t *image = luaA_checkudata(L, 1, &image_class), *new;
 415     int x = luaL_checkint(L, 2);
 416     int y = luaL_checkint(L, 3);
 417     int w = luaL_checkint(L, 4);
 418     int h = luaL_checkint(L, 5);
 419
 420     new = image_new(L);
 421
 422     imlib_context_set_image(image->image);
 423     new->image = imlib_create_cropped_image(x, y, w, h);
 424
 425     return 1;
 426 }
 427
 428 /** Crop the image to the given rectangle and scales it.
 429  * \param L The Lua VM state.
 430  * \return The number of elements pushed on stack.
 431  * \luastack
 432  * \lvalue An image.
 433  * \lparam The top left x coordinate of the source rectangle.
 434  * \lparam The top left y coordinate of the source rectangle.
 435  * \lparam The width of the source rectangle.
 436  * \lparam The height of the source rectangle.
 437  * \lparam The width of the destination rectangle.
 438  * \lparam The height of the destination rectangle.
 439  * \lreturn A cropped image.
 440  */
 441 static int
 442 luaA_image_crop_and_scale(lua_State *L)
 443 {
 444     image_t *image = luaA_checkudata(L, 1, &image_class), *new;
 445     int source_x = luaL_checkint(L, 2);
 446     int source_y = luaL_checkint(L, 3);
 447     int w = luaL_checkint(L, 4);
 448     int h = luaL_checkint(L, 5);
 449     int dest_w = luaL_checkint(L, 6);
 450     int dest_h = luaL_checkint(L, 7);
 451
 452     new = image_new(L);
 453
 454     imlib_context_set_image(image->image);
 455     new->image = imlib_create_cropped_scaled_image(source_x,
 456                                                    source_y,
 457                                                    w, h,
 458                                                    dest_w, dest_h);
 459
 460     return 1;
 461 }
 462
 463 /** Draw a pixel in an image
 464  * \param L The Lua VM state
 465  * \luastack
 466  * \lvalue An image.
 467  * \lparam The x coordinate of the pixel to draw
 468  * \lparam The y coordinate of the pixel to draw
 469  * \lparam The color to draw the pixel in
 470  */
 471 static int
 472 luaA_image_draw_pixel(lua_State *L)
 473 {
 474     size_t len;
 475     color_t color;
 476     color_init_cookie_t cookie;
 477     image_t *image = luaA_checkudata(L, 1, &image_class);
 478     int x = luaL_checkint(L, 2);
 479     int y = luaL_checkint(L, 3);
 480     const char *buf = luaL_checklstring(L, 4, &len);
 481
 482     cookie = color_init_unchecked(&color, buf, len);
 483     imlib_context_set_image(image->image);
 484     color_init_reply(cookie);
 485
 486     if((x > imlib_image_get_width()) || (y > imlib_image_get_height()))
 487         return 0;
 488
 489     imlib_context_set_color(color.red, color.green, color.blue, color.alpha);
 490     imlib_image_draw_pixel(x, y, 1);
 491     image->isupdated = false;
 492     return 0;
 493 }
 494
 495 /** Draw a line in an image
 496  * \param L The Lua VM state
 497  * \luastack
 498  * \lvalue An image.
 499  * \lparam The x1 coordinate of the line to draw
 500  * \lparam The y1 coordinate of the line to draw
 501  * \lparam The x2 coordinate of the line to draw
 502  * \lparam The y2 coordinate of the line to draw
 503  * \lparam The color to draw the line in
 504  */
 505 static int
 506 luaA_image_draw_line(lua_State *L)
 507 {
 508     size_t len;
 509     color_t color;
 510     color_init_cookie_t cookie;
 511     image_t *image = luaA_checkudata(L, 1, &image_class);
 512     int x1 = luaL_checkint(L, 2);
 513     int y1 = luaL_checkint(L, 3);
 514     int x2 = luaL_checkint(L, 4);
 515     int y2 = luaL_checkint(L, 5);
 516     const char *buf = luaL_checklstring(L, 6, &len);
 517
 518     cookie = color_init_unchecked(&color, buf, len);
 519     imlib_context_set_image(image->image);
 520     color_init_reply(cookie);
 521
 522     imlib_context_set_color(color.red, color.green, color.blue, color.alpha);
 523     imlib_image_draw_line(x1, y1, x2, y2, 0);
 524     image->isupdated = false;
 525     return 0;
 526 }
 527
 528 /** Draw a rectangle in an image
 529  * \param L The Lua VM state
 530  * \luastack
 531  * \lvalue An image.
 532  * \lparam The x coordinate of the rectangles top left corner
 533  * \lparam The y coordinate of the rectangles top left corner
 534  * \lparam The width of the rectangle
 535  * \lparam The height of the rectangle
 536  * \lparam True if the rectangle should be filled, False otherwise
 537  * \lparam The color to draw the rectangle in
 538  */
 539 static int
 540 luaA_image_draw_rectangle(lua_State *L)
 541 {
 542     size_t len;
 543     color_t color;
 544     color_init_cookie_t cookie;
 545     image_t *image = luaA_checkudata(L, 1, &image_class);
 546     int x = luaL_checkint(L, 2);
 547     int y = luaL_checkint(L, 3);
 548     int width  = luaL_checkint(L, 4);
 549     int height = luaL_checkint(L, 5);
 550     int fill = luaA_checkboolean(L, 6);
 551     const char *buf = luaL_checklstring(L, 7, &len);
 552
 553     cookie = color_init_unchecked(&color, buf, len);
 554     imlib_context_set_image(image->image);
 555     color_init_reply(cookie);
 556
 557     imlib_context_set_color(color.red, color.green, color.blue, color.alpha);
 558     if(!fill)
 559         imlib_image_draw_rectangle(x, y, width, height);
 560     else
 561         imlib_image_fill_rectangle(x, y, width, height);
 562     image->isupdated = false;
 563     return 0;
 564 }
 565
 566 /** Convert a table to a color range and set it as current color range.
 567  * \param L The Lua VM state.
 568  * \param ud The index of the table.
 569  * \return A color range that you are responsible to free.
 570  */
 571 static Imlib_Color_Range
 572 luaA_table_to_color_range(lua_State *L, int ud)
 573 {
 574     Imlib_Color_Range range = imlib_create_color_range();
 575
 576     imlib_context_set_color_range(range);
 577
 578     for(size_t i = 1; i <= lua_objlen(L, ud); i++)
 579     {
 580         /* get t[i] */
 581         lua_pushnumber(L, i);
 582         lua_gettable(L, ud);
 583
 584         size_t len;
 585         const char *colstr = lua_tolstring(L, -1, &len);
 586
 587         if(colstr)
 588         {
 589             color_t color;
 590
 591             color_init_cookie_t cookie = color_init_unchecked(&color, colstr, len);
 592
 593             /* get value with colstr as key in table */
 594             lua_pushvalue(L, -1);
 595             lua_gettable(L, ud);
 596
 597             /* convert the distance, if any, to number, or set 1 */
 598             int distance = lua_tonumber(L, -1);
 599             /* remove distance */
 600             lua_pop(L, 1);
 601
 602             color_init_reply(cookie);
 603
 604             imlib_context_set_color(color.red, color.green, color.blue, color.alpha);
 605
 606             imlib_add_color_to_color_range(distance);
 607         }
 608
 609         /* remove color string (value) */
 610         lua_pop(L, 1);
 611     }
 612
 613     return range;
 614 }
 615
 616 /** Draw a rectangle in an image with gradient color.
 617  * \param L The Lua VM state.
 618  * \return The number of elements pushed on stack.
 619  * \luastack
 620  * \lvalue An image.
 621  * \lparam The x coordinate of the rectangles top left corner.
 622  * \lparam The y coordinate of the rectangles top left corner.
 623  * \lparam The width of the rectangle.
 624  * \lparam The height of the rectangle.
 625  * \lparam A table with the color to draw the rectangle. You can specified the
 626  * color distance from the previous one by setting t[color] = distance.
 627  * \lparam The angle of gradient.
 628  */
 629 static int
 630 luaA_image_draw_rectangle_gradient(lua_State *L)
 631 {
 632     image_t *image = luaA_checkudata(L, 1, &image_class);
 633     int x = luaL_checkint(L, 2);
 634     int y = luaL_checkint(L, 3);
 635     int width  = luaL_checkint(L, 4);
 636     int height = luaL_checkint(L, 5);
 637     luaA_checktable(L, 6);
 638     double angle = luaL_checknumber(L, 7);
 639
 640     imlib_context_set_image(image->image);
 641
 642     luaA_table_to_color_range(L, 6);
 643
 644     imlib_image_fill_color_range_rectangle(x, y, width, height, angle);
 645
 646     imlib_free_color_range();
 647
 648     image->isupdated = false;
 649
 650     return 0;
 651 }
 652
 653 /** Draw a circle in an image
 654  * \param L The Lua VM state
 655  * \luastack
 656  * \lvalue An image.
 657  * \lparam The x coordinate of the center of the circle
 658  * \lparam The y coordinate of the center of the circle
 659  * \lparam The horizontal amplitude (width)
 660  * \lparam The vertical amplitude (height)
 661  * \lparam True if the circle should be filled, False otherwise
 662  * \lparam The color to draw the circle in
 663  */
 664 static int
 665 luaA_image_draw_circle(lua_State *L)
 666 {
 667     size_t len;
 668     color_t color;
 669     color_init_cookie_t cookie;
 670     image_t *image = luaA_checkudata(L, 1, &image_class);
 671     int x = luaL_checkint(L, 2);
 672     int y = luaL_checkint(L, 3);
 673     int ah = luaL_checkint(L, 4);
 674     int av = luaL_checkint(L, 5);
 675     int fill = luaA_checkboolean(L, 6);
 676     const char *buf = luaL_checklstring(L, 7, &len);
 677
 678     cookie = color_init_unchecked(&color, buf, len);
 679     imlib_context_set_image(image->image);
 680     color_init_reply(cookie);
 681
 682     imlib_context_set_color(color.red, color.green, color.blue, color.alpha);
 683     if(!fill)
 684         imlib_image_draw_ellipse(x, y, ah, av);
 685     else
 686         imlib_image_fill_ellipse(x, y, ah, av);
 687     image->isupdated = false;
 688     return 0;
 689 }
 690
 691 /** Saves the image to the given path. The file extension (e.g. .png or .jpg)
 692  * will affect the output format.
 693  * \param L The Lua VM state.
 694  * \return The number of elements pushed on stack.
 695  * \luastack
 696  * \lvalue An image.
 697  * \lparam The image path.
 698  */
 699 static int
 700 luaA_image_save(lua_State *L)
 701 {
 702     image_t *image = luaA_checkudata(L, 1, &image_class);
 703     const char *path = luaL_checkstring(L, 2);
 704     Imlib_Load_Error err;
 705
 706     imlib_context_set_image(image->image);
 707     imlib_save_image_with_error_return(path, &err);
 708
 709     if(err != IMLIB_LOAD_ERROR_NONE)
 710         warn("cannot save image %s: %s", path, image_imlib_load_strerror(err));
 711
 712     return 0;
 713 }
 714
 715 /** Insert one image into another.
 716  * \param L The Lua VM state.
 717  * \return The number of elements pushed on stack.
 718  * \luastack
 719  * \lvalue An image.
 720  * \lparam The image to insert.
 721  * \lparam The X offset of the image to insert (optional).
 722  * \lparam The Y offset of the image to insert (optional).
 723  * \lparam The horizontal offset of the upper right image corner (optional).
 724  * \lparam The vertical offset of the upper right image corner (optional).
 725  * \lparam The horizontal offset of the lower left image corner (optional).
 726  * \lparam The vertical offset of the lower left image corner (optional).
 727  * \lparam The X coordinate of the source rectangle (optional).
 728  * \lparam The Y coordinate of the source rectangle (optional).
 729  * \lparam The width of the source rectangle (optional).
 730  * \lparam The height of the source rectangle (optional).
 731  */
 732 static int
 733 luaA_image_insert(lua_State *L)
 734 {
 735     image_t *image_target = luaA_checkudata(L, 1, &image_class);
 736     image_t *image_source = luaA_checkudata(L, 2, &image_class);
 737     int xoff = luaL_optnumber(L, 3, 0);
 738     int yoff = luaL_optnumber(L, 4, 0);
 739
 740     int xsrc = luaL_optnumber(L, 5, 0);
 741     int ysrc = luaL_optnumber(L, 6, 0);
 742     int wsrc = luaL_optnumber(L, 7, image_getwidth(image_source));
 743     int hsrc = luaL_optnumber(L, 8, image_getheight(image_source));
 744
 745     int hxoff = luaL_optnumber(L, 9, image_getwidth(image_source));
 746     int hyoff = luaL_optnumber(L, 10, 0);
 747
 748     int vxoff = luaL_optnumber(L, 11, 0);
 749     int vyoff = luaL_optnumber(L, 12, image_getheight(image_source));
 750
 751     imlib_context_set_image(image_target->image);
 752
 753     imlib_blend_image_onto_image_skewed(image_source->image, 0,
 754                                         /* source rectangle */
 755                                         xsrc, ysrc, wsrc, hsrc,
 756                                         /* position of the source image in the target image */
 757                                         xoff, yoff,
 758                                         /* axis offsets for the source image, (w|0|0|h)
 759                                          * is the default */
 760                                         hxoff, hyoff, vxoff, vyoff);
 761
 762     image_target->isupdated = false;
 763
 764     return 0;
 765 }
 766
 767 static int
 768 luaA_image_get_width(lua_State *L, image_t *image)
 769 {
 770     lua_pushnumber(L, image_getwidth(image));
 771     return 1;
 772 }
 773
 774 static int
 775 luaA_image_get_height(lua_State *L, image_t *image)
 776 {
 777     lua_pushnumber(L, image_getheight(image));
 778     return 1;
 779 }
 780
 781 static int
 782 luaA_image_get_alpha(lua_State *L, image_t *image)
 783 {
 784     imlib_context_set_image(image->image);
 785     lua_pushboolean(L, imlib_image_has_alpha());
 786     return 1;
 787 }
 788
 789 void
 790 image_class_setup(lua_State *L)
 791 {
 792     static const struct luaL_reg image_methods[] =
 793     {
 794         LUA_CLASS_METHODS(image)
 795         { "__call", luaA_image_new },
 796         { "argb32", luaA_image_argb32_new },
 797         { NULL, NULL }
 798     };
 799
 800     static const struct luaL_reg image_meta[] =
 801     {
 802         LUA_OBJECT_META(image)
 803         LUA_CLASS_META
 804         { "rotate", luaA_image_rotate },
 805         { "orientate", luaA_image_orientate },
 806         { "crop", luaA_image_crop },
 807         { "crop_and_scale", luaA_image_crop_and_scale },
 808         { "save", luaA_image_save },
 809         { "insert", luaA_image_insert },
 810         /* draw on images, whee! */
 811         { "draw_pixel", luaA_image_draw_pixel },
 812         { "draw_line",  luaA_image_draw_line  },
 813         { "draw_rectangle", luaA_image_draw_rectangle },
 814         { "draw_rectangle_gradient", luaA_image_draw_rectangle_gradient },
 815         { "draw_circle", luaA_image_draw_circle },
 816         { "__gc", luaA_image_gc },
 817         { NULL, NULL }
 818     };
 819
 820     luaA_class_setup(L, &image_class, "image", (lua_class_allocator_t) image_new,
 821                      luaA_class_index_miss_property, luaA_class_newindex_miss_property,
 822                      image_methods, image_meta);
 823     luaA_class_add_property(&image_class, A_TK_WIDTH,
 824                             NULL,
 825                             (lua_class_propfunc_t) luaA_image_get_width,
 826                             NULL);
 827     luaA_class_add_property(&image_class, A_TK_HEIGHT,
 828                             NULL,
 829                             (lua_class_propfunc_t) luaA_image_get_height,
 830                             NULL);
 831     luaA_class_add_property(&image_class, A_TK_ALPHA,
 832                             NULL,
 833                             (lua_class_propfunc_t) luaA_image_get_alpha,
 834                             NULL);
 835 }
 836
 837 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80