#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "ppport.h"
#include <Imlib2.h>
#include <stdio.h>
#include <string.h>
typedef Imlib_Image Image__Imlib2;
typedef ImlibPolygon Image__Imlib2__Polygon;
typedef Imlib_Color_Range Image__Imlib2__ColorRange;
bool colours_equal(Imlib_Color col1, Imlib_Color col2) {
return col1.red == col2.red &&
col1.green == col2.green &&
col1.blue == col2.blue;
}
static double
TEXT_TO_RIGHT(void)
{
return IMLIB_TEXT_TO_RIGHT;
}
static double
TEXT_TO_LEFT(void)
{
return IMLIB_TEXT_TO_LEFT;
}
static double
TEXT_TO_UP(void)
{
return IMLIB_TEXT_TO_UP;
}
static double
TEXT_TO_DOWN(void)
{
return IMLIB_TEXT_TO_DOWN;
}
static double
TEXT_TO_ANGLE(void)
{
return IMLIB_TEXT_TO_ANGLE;
}
MODULE = Image::Imlib2 PACKAGE = Image::Imlib2
double
TEXT_TO_RIGHT()
double
TEXT_TO_LEFT()
double
TEXT_TO_UP()
double
TEXT_TO_DOWN()
double
TEXT_TO_ANGLE()
MODULE = Image::Imlib2 PACKAGE = Image::Imlib2 PREFIX= Imlib2_
Image::Imlib2
Imlib2_new(packname="Image::Imlib2", x=256, y=256)
char * packname
int x
int y
PROTOTYPE: $;$$
CODE:
{
Imlib_Image image;
image = imlib_create_image(x, y);
imlib_context_set_image(image);
imlib_image_set_has_alpha(1);
RETVAL = image;
}
OUTPUT:
RETVAL
Image::Imlib2
Imlib2__new_using_data(packname="Image::Imlib2", x=256, y=256, data)
char * packname
int x
int y
DATA32 * data
PROTOTYPE: $;$$$
CODE:
{
Imlib_Image image;
image = imlib_create_image_using_copied_data(x, y, data);
imlib_context_set_image(image);
imlib_image_set_has_alpha(1);
RETVAL = image;
}
OUTPUT:
RETVAL
char
Imlib2_will_blend(packname="Image::Imlib2", ...)
char * packname
PREINIT:
char value;
PROTOTYPE: $;$
CODE:
{
if (items > 1) {
value = SvTRUE(ST(1))?1:0;
imlib_context_set_blend(value);
}
RETVAL = imlib_context_get_blend();
}
OUTPUT:
RETVAL
void
Imlib2_DESTROY(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
imlib_free_image();
}
Image::Imlib2
Imlib2_load(packname="Image::Imlib2", filename)
char * packname
char * filename
PROTOTYPE: $$
CODE:
{
Imlib_Image image;
Imlib_Load_Error err;
image = imlib_load_image_with_error_return (filename, &err);
if (err == IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST) {
Perl_croak(aTHX_ "Image::Imlib2 load error: File does not exist");
}
if (err == IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY) {
Perl_croak(aTHX_ "Image::Imlib2 load error: File is directory");
}
if (err == IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ) {
Perl_croak(aTHX_ "Image::Imlib2 load error: Permission denied");
}
if (err == IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT) {
Perl_croak(aTHX_ "Image::Imlib2 load error: No loader for file format");
}
RETVAL = image;
}
OUTPUT:
RETVAL
void
Imlib2_save(image, filename)
Image::Imlib2 image
char * filename
PROTOTYPE: $$
CODE:
{
Imlib_Load_Error err;
imlib_context_set_image(image);
imlib_save_image_with_error_return(filename, &err);
if (err != IMLIB_LOAD_ERROR_NONE) {
Perl_croak(aTHX_ "Image::Imlib2 save error: Unknown error");
}
}
int
Imlib2_get_width(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
RETVAL = imlib_image_get_width();
}
OUTPUT:
RETVAL
int
Imlib2_width(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
RETVAL = imlib_image_get_width();
}
OUTPUT:
RETVAL
int
Imlib2_get_height(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
RETVAL = imlib_image_get_height();
}
OUTPUT:
RETVAL
int
Imlib2_height(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
RETVAL = imlib_image_get_height();
}
OUTPUT:
RETVAL
void
Imlib2_set_color(image, r, g, b, a)
Image::Imlib2 image
int r
int g
int b
int a
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_context_set_color(r, g, b, a);
}
void
Imlib2_set_colour(image, r, g, b, a)
Image::Imlib2 image
int r
int g
int b
int a
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_context_set_color(r, g, b, a);
}
void
Imlib2_draw_point(image, x, y)
Image::Imlib2 image
int x
int y
PROTOTYPE: $$$
CODE:
{
imlib_context_set_image(image);
imlib_image_draw_pixel(x, y, 0);
}
void
Imlib2_draw_line(image, x1, y1, x2, y2)
Image::Imlib2 image
int x1
int y1
int x2
int y2
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_image_draw_line(x1, y1, x2, y2, 0);
}
void
Imlib2_query_pixel(image, x, y)
Image::Imlib2 image
int x
int y
PROTOTYPE: $$
PREINIT:
Imlib_Color color_return;
PPCODE:
imlib_context_set_image(image);
imlib_image_query_pixel(x, y, &color_return);
XPUSHs(sv_2mortal(newSViv(color_return.red)));
XPUSHs(sv_2mortal(newSViv(color_return.green)));
XPUSHs(sv_2mortal(newSViv(color_return.blue)));
XPUSHs(sv_2mortal(newSViv(color_return.alpha)));
void
Imlib2_autocrop_dimensions(image)
Image::Imlib2 image
PROTOTYPE: $$
PREINIT:
Imlib_Color c, bg, tl, tr, bl, br;
int width, height;
int cx = 0;
int cy = 0;
int cw, ch;
int x1, y1, x2, y2;
int i;
bool abort;
PPCODE:
imlib_context_set_image(image);
width = imlib_image_get_width();
height = imlib_image_get_height();
cw = width;
ch = height;
/* guess the background colour
algorithm from gimp's autocrop.c, originally pinched from
pnmcrop: first see if three corners are equal, then if two are equal,
otherwise give up */
imlib_image_query_pixel(0, 0, &tl);
imlib_image_query_pixel(width - 1, 0, &tr);
imlib_image_query_pixel(0, height - 1, &bl);
imlib_image_query_pixel(width -1 , height - 1, &br);
if (colours_equal(tr, bl) && colours_equal(tr, br)) {
bg = tr;
} else if (colours_equal(tl, bl) && colours_equal(tl, br)) {
bg = tl;
} else if (colours_equal(tl, tr) && colours_equal(tl, br)) {
bg = tl;
} else if (colours_equal(tl, tr) && colours_equal(tl, bl)) {
bg = tl;
} else if (colours_equal(tl, tr) || colours_equal(tl, bl) || colours_equal(tl, br)) {
bg = tl;
} else if (colours_equal(tr, bl) || colours_equal(tr, bl)) {
bg = tr;
} else if (colours_equal(br, bl)) {
bg = br;
} else {
/* all different? give up */
XPUSHs(sv_2mortal(newSViv(cx)));
XPUSHs(sv_2mortal(newSViv(cy)));
XPUSHs(sv_2mortal(newSViv(cw)));
XPUSHs(sv_2mortal(newSViv(ch)));
return;
}
/* warn ("Have background colour: %i, %i, %i", bg.red, bg.green, bg.blue); */
/* check how many of the bottom lines are uniform */
abort = FALSE;
for (y2 = height - 1; y2 >= 0 && !abort; y2--) {
for (i = 0; i < width && !abort; i++) {
imlib_image_query_pixel(i, y2, &c);
abort = !colours_equal (c, bg);
}
}
/* warn("x1 %i, y1 %i, x2 %i, y2 %i", x1, y1, x2, y2); */
if (y2 == -1) {
/* plain colour */
XPUSHs(sv_2mortal(newSViv(cx)));
XPUSHs(sv_2mortal(newSViv(cy)));
XPUSHs(sv_2mortal(newSViv(cw)));
XPUSHs(sv_2mortal(newSViv(ch)));
return;
}
/* since now we don't need to check for the upper boundary
of the outer loops as there is at least one pixel of different colour */
/* check how many of the top lines are uniform */
abort = FALSE;
for (y1 = 0; !abort; y1++) {
for (i = 0; i < width && !abort; i++) {
imlib_image_query_pixel(i, y1, &c);
abort = !colours_equal (c, bg);
}
}
y2 += 1; /* to make y2 - y1 == height */
/* warn("x1 %i, y1 %i, x2 %i, y2 %i", x1, y1, x2, y2); */
/* the coordinates are now the first rows which DON'T match
* the colour - crop instead to one row larger:
*/
if (y1 > 0) --y1;
if (y2 < height-1) ++y2;
/* check how many of the left lines are uniform */
abort = FALSE;
for (x1 = 0; !abort; x1++) {
for (i = y1; i < y2 && !abort; i++) {
imlib_image_query_pixel(x1, i, &c);
abort = !colours_equal (c, bg);
}
}
/* warn("x1 %i, y1 %i, x2 %i, y2 %i", x1, y1, x2, y2); */
/* check how many of the right lines are uniform */
abort = FALSE;
for (x2 = width - 1; !abort; x2--) {
for (i = y1; i < y2 && !abort; i++) {
imlib_image_query_pixel(x2, i, &c);
abort = !colours_equal (c, bg);
}
}
x2 += 1; /* to make x2 - x1 == width */
/* the coordinates are now the first columns which DON'T match
* the color - crop instead to one column larger:
*/
if (x1 > 0) --x1;
if (x2 < width-1) ++x2;
/* warn("x1 %i, y1 %i, x2 %i, y2 %i", x1, y1, x2, y2); */
cx = x1;
cy = y1;
cw = x2 - x1;
ch = y2 - y1;
XPUSHs(sv_2mortal(newSViv(cx)));
XPUSHs(sv_2mortal(newSViv(cy)));
XPUSHs(sv_2mortal(newSViv(cw)));
XPUSHs(sv_2mortal(newSViv(ch)));
void
Imlib2_find_colour(image)
Image::Imlib2 image
PROTOTYPE: $$
PREINIT:
Imlib_Color c;
int r, g, b, a;
int width, height;
int x = 0;
int y = 0;
bool abort;
PPCODE:
imlib_context_set_image(image);
width = imlib_image_get_width();
height = imlib_image_get_height();
imlib_context_get_color(&r, &g, &b, &a);
// warn("pr = %i, pg = %i, pb = %i", r, g, b);
abort = FALSE;
for (y = 0; y < height && !abort; y++) {
for (x = 0; x < width && !abort; x++) {
imlib_image_query_pixel(x, y, &c);
abort = c.red == r && c.green == g && c.blue == b;
}
}
if (abort) {
XPUSHs(sv_2mortal(newSViv(x)));
XPUSHs(sv_2mortal(newSViv(y)));
} else {
XPUSHs(newSV(0));
XPUSHs(newSV(0));
}
void
Imlib2_fill(image, x, y, newimage=NULL)
Image::Imlib2 image
Image::Imlib2 newimage
int x
int y
PROTOTYPE: $$$$;$
PREINIT:
Imlib_Color c;
int r, g, b, a;
int or, og, ob, oa;
int width, height, px, py, west, east;
AV* coords;
SV* sv;
int length;
bool abort;
PPCODE:
imlib_context_set_image(image);
width = imlib_image_get_width();
height = imlib_image_get_height();
imlib_image_query_pixel(x, y, &c);
or = c.red; og = c.green; ob = c.blue;
imlib_context_get_color(&r, &g, &b, &a);
// warn("pr = %i, pg = %i, pb = %i", r, g, b);
coords = newAV();
av_push(coords, newSViv(x));
av_push(coords, newSViv(y));
while (av_len(coords) != -1) {
length = av_len(coords);
// warn("length %i", length);
sv = av_shift(coords);
x = SvIVX(sv);
sv_free(sv);
sv = av_shift(coords);
y = SvIVX(sv);
sv_free(sv);
imlib_image_query_pixel(x, y, &c);
if ((c.red == or && c.green == og && c.blue == ob)) {
if (newimage != NULL) {
imlib_context_set_image(newimage);
imlib_context_set_color(r, g, b, a);
imlib_image_draw_pixel(x, y, 0);
imlib_context_set_image(image);
}
imlib_image_draw_pixel(x, y, 0);
west = x;
east = x;
abort = FALSE;
while (!abort) {
west -= 1;
imlib_image_query_pixel(west, y, &c);
abort = (west == 0
|| !(c.red == or && c.green == og && c.blue == ob)
);
}
abort = FALSE;
while (!abort) {
east += 1;
imlib_image_query_pixel(east, y, &c);
abort = (east == width
|| !(c.red == or && c.green == og && c.blue == ob)
);
}
// warn(" %i-%i, %i", west, east, y);
for (px = west; px <= east; px++) {
if (newimage != NULL) {
imlib_context_set_image(newimage);
imlib_image_draw_pixel(px, y, 0);
imlib_context_set_image(image);
}
imlib_image_draw_pixel(px, y, 0);
py = y - 1;
imlib_image_query_pixel(px, py, &c);
if (py > 0
&& (c.red == or && c.green == og && c.blue == ob)
) {
// warn(" ^ %i, %i", px, py);
av_push(coords, newSViv(px));
av_push(coords, newSViv(py));
}
py = y + 1;
imlib_image_query_pixel(px, py, &c);
if (py < height
&& (c.red == or && c.green == og && c.blue == ob)
) {
// warn(" v %i, %i", px, py);
av_push(coords, newSViv(px));
av_push(coords, newSViv(py));
}
}
}
}
av_undef(coords);
void
Imlib2_draw_rectangle(image, x, y, w, h)
Image::Imlib2 image
int x
int y
int w
int h
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_image_draw_rectangle(x, y, w, h);
}
void
Imlib2_fill_rectangle(image, x, y, w, h)
Image::Imlib2 image
int x
int y
int w
int h
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_image_fill_rectangle(x, y, w, h);
}
void
Imlib2_draw_ellipse(image, x, y, w, h)
Image::Imlib2 image
int x
int y
int w
int h
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_image_draw_ellipse(x, y, w, h);
}
void
Imlib2_fill_ellipse(image, x, y, w, h)
Image::Imlib2 image
int x
int y
int w
int h
PROTOTYPE: $$$$$
CODE:
{
imlib_context_set_image(image);
imlib_image_fill_ellipse(x, y, w, h);
}
void
Imlib2_add_font_path(image, directory)
Image::Imlib2 image
char * directory
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_add_path_to_font_path(directory);
}
void
Imlib2_load_font(image, fontname)
Image::Imlib2 image
char * fontname
PROTOTYPE: $$
CODE:
{
Imlib_Font font;
imlib_context_set_image(image);
font = imlib_load_font(fontname);
imlib_context_set_font(font);
}
void
Imlib2_get_text_size(image, text, direction=IMLIB_TEXT_TO_RIGHT, angle=0)
Image::Imlib2 image
char * text
int direction
double angle
PROTOTYPE: $$
PREINIT:
int text_w;
int text_h;
PPCODE:
imlib_context_set_image(image);
imlib_context_set_direction(direction);
imlib_context_set_angle(angle);
imlib_get_text_size(text, &text_w, &text_h);
XPUSHs(sv_2mortal(newSViv(text_w)));
XPUSHs(sv_2mortal(newSViv(text_h)));
void
Imlib2_draw_text(image, x, y, text, direction=IMLIB_TEXT_TO_RIGHT, angle=0)
Image::Imlib2 image
int x
int y
char * text
int direction
double angle
PROTOTYPE: $$$$;$$
CODE:
{
imlib_context_set_image(image);
imlib_context_set_direction(direction);
imlib_context_set_angle(angle);
imlib_text_draw(x, y, text);
}
Image::Imlib2
Imlib2_crop(image, x, y, w, h)
Image::Imlib2 image
int x
int y
int w
int h
PROTOTYPE: $$$$$
CODE:
{
Imlib_Image cropped;
imlib_context_set_image(image);
cropped = imlib_create_cropped_image(x, y, w, h);
RETVAL = cropped;
}
OUTPUT:
RETVAL
void
Imlib2_blend(image, source, alpha, x, y, w, h, d_x, d_y, d_w, d_h)
Image::Imlib2 image
Image::Imlib2 source
int alpha
int x
int y
int w
int h
int d_x
int d_y
int d_w
int d_h
PROTOTYPE: $$$$$$$$$$$
CODE:
{
imlib_context_set_image(image);
imlib_blend_image_onto_image(source, alpha, x, y, w, h, d_x, d_y, d_w, d_h);
}
void
Imlib2_blur(image, radius)
Image::Imlib2 image
int radius
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_image_blur(radius);
}
void
Imlib2_sharpen(image, radius)
Image::Imlib2 image
int radius
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_image_sharpen(radius);
}
Image::Imlib2
Imlib2_clone(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
Imlib_Image cloned;
imlib_context_set_image(image);
cloned = imlib_clone_image();
RETVAL = cloned;
}
OUTPUT:
RETVAL
void
Imlib2_draw_polygon(image, poly, closed)
Image::Imlib2 image
Image::Imlib2::Polygon poly
unsigned char closed
PROTOTYPE: $$$
CODE:
{
imlib_context_set_image(image);
imlib_image_draw_polygon(poly,closed);
}
void Imlib2_fill_color_range_rectangle(image, cr, x, y, width, height, angle)
Image::Imlib2 image
Image::Imlib2::ColorRange cr
int x
int y
int width
int height
double angle
PROTOTYPE: $$$$$$
CODE:
{
Imlib_Color_Range oldcr;
imlib_context_set_image(image);
oldcr = imlib_context_get_color_range();
imlib_context_set_color_range(cr);
imlib_image_fill_color_range_rectangle(x,y,width,height,angle);
imlib_context_set_color_range(oldcr);
}
void Imlib2_image_orientate(image, steps)
Image::Imlib2 image
int steps
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_image_orientate(steps);
}
void Imlib2_image_set_format(image, format)
Image::Imlib2 image
char * format
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_image_set_format(format);
}
Image::Imlib2 Imlib2_create_scaled_image(image, dw, dh)
Image::Imlib2 image
int dw
int dh
PROTOTYPE: $$$
CODE:
{
Imlib_Image dstimage;
int sw, sh;
imlib_context_set_image(image);
sw = imlib_image_get_width();
sh = imlib_image_get_height();
if ( dw == 0 ) {
dw = (int) (((double) dh * sw) / sh);
}
if ( dh == 0 ) {
dh = (int) (((double) dw * sh) / sw);
}
dstimage = imlib_create_cropped_scaled_image(0, 0, sw, sh, dw, dh);
RETVAL = dstimage;
}
OUTPUT:
RETVAL
Image::Imlib2 Imlib2_set_quality(image, qual)
Image::Imlib2 image
int qual
PROTOTYPE: $$
CODE:
{
imlib_context_set_image(image);
imlib_image_attach_data_value("quality",NULL,qual,NULL);
}
Image::Imlib2 Imlib2_flip_horizontal(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
imlib_image_flip_horizontal();
}
Image::Imlib2 Imlib2_flip_vertical(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
imlib_image_flip_vertical();
}
Image::Imlib2 Imlib2_flip_diagonal(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
imlib_image_flip_diagonal();
}
int
Imlib2_has_alpha(image, ...)
Image::Imlib2 image
PREINIT:
char value;
PROTOTYPE: $;$
CODE:
{
imlib_context_set_image(image);
if (items > 1) {
value = SvTRUE(ST(1))?1:0;
imlib_image_set_has_alpha(value);
}
RETVAL = imlib_image_has_alpha();
}
OUTPUT:
RETVAL
void
Imlib2_set_cache_size(packname="Image::Imlib2", size)
char * packname
int size
PROTOTYPE: $$
CODE:
{
imlib_set_cache_size(size);
}
int
Imlib2_get_cache_size(packname="Image::Imlib2")
char * packname
PROTOTYPE: $
CODE:
{
RETVAL = imlib_get_cache_size();
}
OUTPUT:
RETVAL
void
Imlib2_set_changes_on_disk(image)
Image::Imlib2 image
PROTOTYPE: $
CODE:
{
imlib_context_set_image(image);
imlib_image_set_changes_on_disk();
}
Image::Imlib2
Imlib2_create_transparent_image(source, alpha)
Image::Imlib2 source
int alpha
PROTOTYPE: $$
PREINIT:
Imlib_Image destination;
Imlib_Color color_return;
int x, y, w, h;
CODE:
{
imlib_context_set_image(source);
w = imlib_image_get_width();
h = imlib_image_get_height();
destination = imlib_create_image(w, h);
imlib_context_set_image(destination);
imlib_image_set_has_alpha(1);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
imlib_context_set_image(source);
imlib_image_query_pixel(x, y, &color_return);
imlib_context_set_color(color_return.red, color_return.green, color_return.blue, alpha);
imlib_context_set_image(destination);
imlib_image_draw_pixel(x, y, 0);
}
}
RETVAL = destination;
}
OUTPUT:
RETVAL
Image::Imlib2
Imlib2_create_blended_image(source1, source2, pc)
Image::Imlib2 source1
Image::Imlib2 source2
int pc
PROTOTYPE: $$
PREINIT:
Imlib_Image destination;
Imlib_Color color1, color2;
int x, y, w, h;
int npc;
CODE:
{
npc = 100 - pc;
imlib_context_set_image(source1);
w = imlib_image_get_width();
h = imlib_image_get_height();
destination = imlib_create_image(w, h);
imlib_context_set_image(destination);
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
imlib_context_set_image(source1);
imlib_image_query_pixel(x, y, &color1);
imlib_context_set_image(source2);
imlib_image_query_pixel(x, y, &color2);
imlib_context_set_image(destination);
imlib_context_set_color((color1.red * pc + color2.red * npc)/100, (color1.green * pc + color2.green * npc)/100, (color1.blue * pc + color2.blue * npc)/100, 255);
imlib_image_draw_line(x, y, x, y, 0);
}
}
RETVAL = destination;
}
OUTPUT:
RETVAL
Image::Imlib2
Imlib2_create_rotated_image(source, angle)
Image::Imlib2 source
double angle
CODE:
imlib_context_set_image(source);
RETVAL = imlib_create_rotated_image(angle);
OUTPUT:
RETVAL
MODULE = Image::Imlib2 PACKAGE = Image::Imlib2::Polygon PREFIX= Imlib2_Polygon_
Image::Imlib2::Polygon
Imlib2_Polygon_new(packname="Image::Imlib2::Polygon")
char * packname
PROTOTYPE: $
CODE:
{
ImlibPolygon poly;
poly = imlib_polygon_new();
RETVAL = poly;
}
OUTPUT:
RETVAL
void
Imlib2_Polygon_DESTROY(poly)
Image::Imlib2::Polygon poly
PROTOTYPE: $
CODE:
{
imlib_polygon_free(poly);
}
void
Imlib2_Polygon_add_point(poly, x, y)
Image::Imlib2::Polygon poly
int x
int y
PROTOTYPE: $$$
CODE:
{
imlib_polygon_add_point(poly,x,y);
}
void
Imlib2_Polygon_fill(poly)
Image::Imlib2::Polygon poly
PROTOTYPE: $
CODE:
{
imlib_image_fill_polygon(poly);
}
MODULE = Image::Imlib2 PACKAGE = Image::Imlib2::ColorRange PREFIX= Imlib2_ColorRange_
Image::Imlib2::ColorRange
Imlib2_ColorRange_new(packname="Image::Imlib2::ColorRange")
char * packname
PROTOTYPE: $
CODE:
{
Imlib_Color_Range cr;
cr = imlib_create_color_range();
RETVAL = cr;
}
OUTPUT:
RETVAL
void Imlib2_ColorRange_DESTROY(cr)
Image::Imlib2::ColorRange cr
PROTOTYPE: $
CODE:
{
Imlib_Color_Range oldcr;
oldcr = imlib_context_get_color_range();
imlib_context_set_color_range(cr);
imlib_free_color_range();
imlib_context_set_color_range(oldcr);
}
void Imlib2_ColorRange_add_color(cr, d, r, g, b, a)
Image::Imlib2::ColorRange cr
int d
int r
int g
int b
int a
PROTOTYPE: $$
CODE:
{
Imlib_Color_Range oldcr;
oldcr = imlib_context_get_color_range();
imlib_context_set_color_range(cr);
imlib_context_set_color(r,b,g,a);
imlib_add_color_to_color_range(d);
imlib_context_set_color_range(oldcr);
}