738 lines
24 KiB
C
738 lines
24 KiB
C
/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
|
|
/*
|
|
* Copyright (C) 2011 Ruby-GNOME2 Project Team
|
|
* Copyright (C) 2002-2004 Masao Mutoh
|
|
* Copyright (C) 2000 Yasushi Shoji
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "rbgdk-pixbuf2private.h"
|
|
#include <string.h>
|
|
|
|
#define RG_TARGET_NAMESPACE cPixbuf
|
|
#define _SELF(s) RVAL2GDKPIXBUF(s)
|
|
|
|
#define NOMEM_ERROR(error) g_set_error(error,\
|
|
GDK_PIXBUF_ERROR,\
|
|
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,\
|
|
"Insufficient memory to load image file");
|
|
|
|
static ID id_pixdata;
|
|
|
|
/****************************************************/
|
|
/* The GdkPixbuf Structure */
|
|
static int
|
|
pixels_size(GdkPixbuf *pixbuf)
|
|
{
|
|
int height, width, rowstride, n_channels, bits_per_sample;
|
|
|
|
height = gdk_pixbuf_get_height(pixbuf);
|
|
width = gdk_pixbuf_get_width(pixbuf);
|
|
rowstride = gdk_pixbuf_get_rowstride(pixbuf);
|
|
n_channels = gdk_pixbuf_get_n_channels(pixbuf);
|
|
bits_per_sample = gdk_pixbuf_get_bits_per_sample(pixbuf);
|
|
|
|
return ((height - 1) * rowstride +
|
|
width * ((n_channels * bits_per_sample + 7) / 8));
|
|
}
|
|
|
|
static VALUE
|
|
get_pixels(VALUE self)
|
|
{
|
|
GdkPixbuf *pixbuf = _SELF(self);
|
|
int size;
|
|
|
|
size = pixels_size(pixbuf);
|
|
return rb_str_new((const char *)gdk_pixbuf_get_pixels(pixbuf), size);
|
|
}
|
|
|
|
static VALUE
|
|
rg_operator_set_pixels(VALUE self, VALUE pixels)
|
|
{
|
|
GdkPixbuf *pixbuf = _SELF(self);
|
|
int size;
|
|
int arg_size;
|
|
|
|
size = pixels_size(pixbuf);
|
|
|
|
StringValue(pixels);
|
|
arg_size = RSTRING_LEN(pixels);
|
|
if (arg_size != size)
|
|
rb_raise(rb_eRangeError,
|
|
"Pixels are %i bytes, %i bytes supplied.",
|
|
size, arg_size);
|
|
|
|
/* The user currently cannot get a pointer to the actual
|
|
* pixels, the data is copied to a String. */
|
|
memcpy(gdk_pixbuf_get_pixels(pixbuf),
|
|
RSTRING_PTR(pixels), MIN(RSTRING_LEN(pixels), size));
|
|
|
|
return pixels;
|
|
}
|
|
|
|
static VALUE
|
|
rg_get_option(VALUE self, VALUE key)
|
|
{
|
|
const gchar* ret = gdk_pixbuf_get_option(_SELF(self), RVAL2CSTR(key));
|
|
return ret ? CSTR2RVAL(ret) : Qnil;
|
|
}
|
|
|
|
/****************************************************/
|
|
/* File opening */
|
|
/* Image Data in Memory */
|
|
static GdkPixbuf *
|
|
pixbuf_initialize_by_hash(VALUE self, VALUE arg, GError **error)
|
|
{
|
|
GdkPixbuf *buf = NULL;
|
|
|
|
VALUE rb_colorspace, rb_has_alpha, rb_bits_per_sample, rb_width, rb_height,
|
|
rb_data, rb_rowstride, rb_xpm, rb_inline, rb_copy_pixels,
|
|
rb_src_pixbuf, rb_src_x, rb_src_y,
|
|
rb_file, rb_scale_width, rb_scale_height, rb_preserve_aspect_ratio;
|
|
rbg_scan_options(arg,
|
|
"colorspace", &rb_colorspace,
|
|
"has_alpha", &rb_has_alpha,
|
|
"bits_per_sample", &rb_bits_per_sample,
|
|
"width", &rb_width,
|
|
"height", &rb_height,
|
|
"data", &rb_data,
|
|
"rowstride", &rb_rowstride,
|
|
"xpm", &rb_xpm,
|
|
"inline", &rb_inline,
|
|
"copy_pixels", &rb_copy_pixels,
|
|
"src_pixbuf", &rb_src_pixbuf,
|
|
"src_x", &rb_src_x,
|
|
"src_y", &rb_src_y,
|
|
"file", &rb_file,
|
|
"scale_width", &rb_scale_width,
|
|
"scale_height", &rb_scale_height,
|
|
"preserve_aspect_ratio", &rb_preserve_aspect_ratio,
|
|
NULL);
|
|
|
|
if (!NIL_P(rb_data)) {
|
|
buf = gdk_pixbuf_new_from_data((const guchar*)RVAL2CSTR(rb_data),
|
|
NIL_P(rb_colorspace) ? GDK_COLORSPACE_RGB : RVAL2GDKCOLORSPACE(rb_colorspace),
|
|
RVAL2CBOOL(rb_has_alpha),
|
|
NIL_P(rb_bits_per_sample) ? 8 : NUM2INT(rb_bits_per_sample),
|
|
NUM2INT(rb_width),
|
|
NUM2INT(rb_height),
|
|
NUM2INT(rb_rowstride),
|
|
NULL, NULL);
|
|
if (buf == NULL)
|
|
NOMEM_ERROR(error);
|
|
// Save a reference to the string because the pixbuf doesn't copy it.
|
|
G_RELATIVE(self, rb_data);
|
|
} else if (!NIL_P(rb_xpm)) {
|
|
const gchar **data = RVAL2STRV(rb_xpm);
|
|
buf = gdk_pixbuf_new_from_xpm_data(data);
|
|
g_free(data);
|
|
if (buf == NULL)
|
|
NOMEM_ERROR(error);
|
|
} else if (!NIL_P(rb_inline)) {
|
|
/* TODO: Is this really up to the caller to decide? */
|
|
long n;
|
|
guint8 *data = RVAL2GUINT8S(rb_inline, n);
|
|
buf = gdk_pixbuf_new_from_inline(n, data, RVAL2CBOOL(rb_copy_pixels), error);
|
|
/* need to manage the returned value */
|
|
rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, data));
|
|
} else if (!NIL_P(rb_src_pixbuf)) {
|
|
buf = gdk_pixbuf_new_subpixbuf(_SELF(rb_src_pixbuf),
|
|
NUM2INT(rb_src_x),
|
|
NUM2INT(rb_src_y),
|
|
NUM2INT(rb_width),
|
|
NUM2INT(rb_height));
|
|
if (buf == NULL)
|
|
NOMEM_ERROR(error);
|
|
} else if (!NIL_P(rb_file)) {
|
|
if (!NIL_P(rb_width)) {
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
buf = gdk_pixbuf_new_from_file_at_size(RVAL2CSTR(rb_file),
|
|
NUM2INT(rb_width),
|
|
NUM2INT(rb_height),
|
|
error);
|
|
#else
|
|
rb_warning("Sizing on load not supported in GTK+ < 2.4.0");
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
|
|
#endif
|
|
} else if (!NIL_P(rb_scale_width)) {
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
|
|
int width = NUM2INT(rb_scale_width);
|
|
int height = NUM2INT(rb_scale_height);
|
|
#if !RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
|
|
if (width < 0 || height < 0)
|
|
rb_warning("For scaling on load, a negative value for width or height are not supported in GTK+ < 2.8.0");
|
|
#endif
|
|
buf = gdk_pixbuf_new_from_file_at_scale(RVAL2CSTR(rb_file),
|
|
width, height,
|
|
NIL_P(rb_preserve_aspect_ratio) ? TRUE : RVAL2CBOOL(rb_preserve_aspect_ratio),
|
|
error);
|
|
#else
|
|
rb_warning("Scaling on load not supported in GTK+ < 2.6.0");
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
|
|
#endif
|
|
} else {
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(rb_file), error);
|
|
}
|
|
} else {
|
|
buf = gdk_pixbuf_new(NIL_P(rb_colorspace) ? GDK_COLORSPACE_RGB : RVAL2GDKCOLORSPACE(rb_colorspace),
|
|
RVAL2CBOOL(rb_has_alpha),
|
|
NIL_P(rb_bits_per_sample) ? 8 : NUM2INT(rb_bits_per_sample),
|
|
NUM2INT(rb_width),
|
|
NUM2INT(rb_height));
|
|
if (buf == NULL)
|
|
NOMEM_ERROR(error);
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* TODO: make deprecated */
|
|
static GdkPixbuf *
|
|
pixbuf_initialize(VALUE self, int argc, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, GError **error)
|
|
{
|
|
GdkPixbuf* buf;
|
|
|
|
if (argc == 7){
|
|
buf = gdk_pixbuf_new_from_data((const guchar*)RVAL2CSTR(arg1),
|
|
RVAL2GDKCOLORSPACE(arg2),
|
|
RVAL2CBOOL(arg3), NUM2INT(arg4),
|
|
NUM2INT(arg5), NUM2INT(arg6),
|
|
NUM2INT(arg7), NULL, NULL);
|
|
if (buf == NULL) NOMEM_ERROR(error);
|
|
// Save a reference to the string because the pixbuf doesn't copy it.
|
|
G_RELATIVE(self, arg1);
|
|
} else if (argc == 5){
|
|
if (rb_obj_is_kind_of(arg1, GTYPE2CLASS(GDK_TYPE_PIXBUF))){
|
|
buf = gdk_pixbuf_new_subpixbuf(_SELF(arg1),
|
|
NUM2INT(arg2), NUM2INT(arg3),
|
|
NUM2INT(arg4), NUM2INT(arg5));
|
|
if (buf == NULL) NOMEM_ERROR(error);
|
|
} else if (rb_obj_is_kind_of(arg1, GTYPE2CLASS(GDK_TYPE_COLORSPACE))){
|
|
buf = gdk_pixbuf_new(RVAL2GDKCOLORSPACE(arg1),
|
|
RVAL2CBOOL(arg2), NUM2INT(arg3),
|
|
NUM2INT(arg4), NUM2INT(arg5));
|
|
if (buf == NULL) NOMEM_ERROR(error);
|
|
} else {
|
|
rb_raise(rb_eArgError, "Wrong type of 1st argument or wrong number of arguments");
|
|
}
|
|
} else if (argc == 4) {
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
|
|
int width = NUM2INT(arg2);
|
|
int height = NUM2INT(arg3);
|
|
#if ! RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
|
|
if (width < 0 || height < 0)
|
|
rb_warning("For scaling on load, a negative value for width or height are not supported in GTK+ < 2.8.0");
|
|
#endif
|
|
buf = gdk_pixbuf_new_from_file_at_scale(RVAL2CSTR(arg1),
|
|
width, height,
|
|
RVAL2CBOOL(arg4), error);
|
|
#else
|
|
rb_warning("Scaling on load not supported in GTK+ < 2.6.0");
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
|
|
#endif
|
|
} else if (argc == 3) {
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
buf = gdk_pixbuf_new_from_file_at_size(RVAL2CSTR(arg1),
|
|
NUM2INT(arg2), NUM2INT(arg3), error);
|
|
#else
|
|
rb_warning("Sizing on load not supported in GTK+ < 2.4.0");
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
|
|
#endif
|
|
} else if (argc == 2) {
|
|
/* TODO: Is this really up to the caller to decide? */
|
|
gboolean copy_pixels = RVAL2CBOOL(arg2);
|
|
long n;
|
|
guint8 *data = RVAL2GUINT8S(arg1, n);
|
|
buf = gdk_pixbuf_new_from_inline(n, data, copy_pixels, error);
|
|
/* need to manage the returned value */
|
|
rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, data));
|
|
} else if (argc == 1){
|
|
if (TYPE(arg1) == T_STRING) {
|
|
buf = gdk_pixbuf_new_from_file(RVAL2CSTR(arg1), error);
|
|
} else if (TYPE(arg1) == T_ARRAY) {
|
|
const gchar **data = RVAL2STRV(arg1);
|
|
buf = gdk_pixbuf_new_from_xpm_data(data);
|
|
g_free(data);
|
|
if (buf == NULL)
|
|
NOMEM_ERROR(error);
|
|
} else if (TYPE(arg1) == T_HASH) {
|
|
buf = pixbuf_initialize_by_hash(self, arg1, error);
|
|
} else {
|
|
rb_raise(rb_eArgError, "Wrong type of 1st argument or wrong number of arguments");
|
|
}
|
|
} else {
|
|
rb_raise(rb_eArgError, "Wrong number of arguments");
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static VALUE
|
|
rg_initialize(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
VALUE arg1, arg2, arg3, arg4, arg5, arg6, arg7;
|
|
GdkPixbuf *buf;
|
|
GError *error = NULL;
|
|
|
|
rb_scan_args(argc, argv, "16", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7);
|
|
buf = pixbuf_initialize(self, argc, arg1, arg2, arg3, arg4, arg5, arg6, arg7, &error);
|
|
if (buf == NULL) {
|
|
rb_gc();
|
|
g_error_free(error);
|
|
error = NULL;
|
|
buf = pixbuf_initialize(self, argc, arg1, arg2, arg3, arg4, arg5, arg6, arg7, &error);
|
|
}
|
|
if (error || !buf)
|
|
RAISE_GERROR(error);
|
|
|
|
G_INITIALIZE(self, buf);
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
rg_dup(VALUE self)
|
|
{
|
|
VALUE ret;
|
|
GdkPixbuf* dest = gdk_pixbuf_copy(_SELF(self));
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
static VALUE
|
|
rg_s_get_file_info(G_GNUC_UNUSED VALUE self, VALUE filename)
|
|
{
|
|
gint width, height;
|
|
|
|
GdkPixbufFormat* format = gdk_pixbuf_get_file_info(RVAL2CSTR(filename),
|
|
&width, &height);
|
|
return format ? rb_ary_new3(3, GDKPIXBUFFORMAT2RVAL(format), INT2NUM(width), INT2NUM(height)) : Qnil;
|
|
}
|
|
|
|
#endif
|
|
|
|
static VALUE
|
|
save_to(VALUE self, const gchar *filename, const gchar *type, VALUE options)
|
|
{
|
|
VALUE result = self;
|
|
GError *error = NULL;
|
|
gchar **keys = NULL;
|
|
gchar **values = NULL;
|
|
|
|
if (!NIL_P(options)) {
|
|
VALUE ary, key, value;
|
|
ID to_s;
|
|
gint len, i;
|
|
|
|
Check_Type(options, T_HASH);
|
|
to_s = rb_intern("to_s");
|
|
|
|
ary = rb_funcall(options, rb_intern("to_a"), 0);
|
|
len = RARRAY_LEN(ary);
|
|
keys = ALLOCA_N(gchar *, len + 1);
|
|
values = ALLOCA_N(gchar *, len + 1);
|
|
for (i = 0; i < len; i++) {
|
|
key = RARRAY_PTR(RARRAY_PTR(ary)[i])[0];
|
|
if (SYMBOL_P(key)) {
|
|
const char *const_key;
|
|
const_key = rb_id2name(SYM2ID(key));
|
|
keys[i] = (gchar *)const_key;
|
|
} else {
|
|
keys[i] = (gchar *)RVAL2CSTR(key);
|
|
}
|
|
value = rb_funcall(RARRAY_PTR(RARRAY_PTR(ary)[i])[1], to_s, 0);
|
|
values[i] = (gchar *)RVAL2CSTR(value);
|
|
}
|
|
keys[len] = NULL;
|
|
values[len] = NULL;
|
|
}
|
|
|
|
if (filename) {
|
|
gdk_pixbuf_savev(_SELF(self), filename, type, keys, values, &error);
|
|
}
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
else {
|
|
gchar *buffer;
|
|
gsize buffer_size;
|
|
if (gdk_pixbuf_save_to_bufferv(_SELF(self), &buffer, &buffer_size,
|
|
type, keys, values, &error))
|
|
result = rb_str_new(buffer, buffer_size);
|
|
}
|
|
#endif
|
|
|
|
if (error)
|
|
RAISE_GERROR(error);
|
|
|
|
return result;
|
|
}
|
|
|
|
/****************************************************/
|
|
/* File saving */
|
|
static VALUE
|
|
rg_save(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
VALUE filename, type, options;
|
|
|
|
rb_scan_args(argc, argv, "21", &filename, &type, &options);
|
|
|
|
return save_to(self, RVAL2CSTR(filename), RVAL2CSTR(type), options);
|
|
}
|
|
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
/* XXX
|
|
gboolean gdk_pixbuf_save_to_callbackv (GdkPixbuf *pixbuf,
|
|
GdkPixbufSaveFunc save_func,
|
|
gpointer user_data,
|
|
const char *type,
|
|
char **option_keys,
|
|
char **option_values,
|
|
GError **error);
|
|
*/
|
|
|
|
static VALUE
|
|
rg_save_to_buffer(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
VALUE type, options;
|
|
|
|
rb_scan_args(argc, argv, "11", &type, &options);
|
|
|
|
return save_to(self, NULL, RVAL2CSTR(type), options);
|
|
}
|
|
#endif
|
|
|
|
/****************************************************/
|
|
/* Scaling */
|
|
static VALUE
|
|
rg_scale(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
GdkPixbuf* dest;
|
|
VALUE dest_width, dest_height, interp_type, ret;
|
|
GdkInterpType type = GDK_INTERP_BILINEAR;
|
|
|
|
rb_scan_args(argc, argv, "21", &dest_width, &dest_height,
|
|
&interp_type);
|
|
|
|
if (!NIL_P(interp_type))
|
|
type = RVAL2GDKINTERPTYPE(interp_type);
|
|
|
|
dest = gdk_pixbuf_scale_simple(_SELF(self),
|
|
NUM2INT(dest_width),
|
|
NUM2INT(dest_height),
|
|
type);
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
|
|
static VALUE
|
|
rg_scale_bang(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
GdkInterpType type = GDK_INTERP_BILINEAR;
|
|
|
|
VALUE src, src_x, src_y, src_width, src_height;
|
|
VALUE offset_x, offset_y, scale_x, scale_y, interp_type;
|
|
|
|
rb_scan_args(argc, argv, "91", &src, &src_x, &src_y,
|
|
&src_width, &src_height, &offset_x, &offset_y,
|
|
&scale_x, &scale_y, &interp_type);
|
|
|
|
if (!NIL_P(interp_type))
|
|
type = RVAL2GDKINTERPTYPE(interp_type);
|
|
|
|
gdk_pixbuf_scale(_SELF(src), _SELF(self),
|
|
NUM2INT(src_x), NUM2INT(src_y),
|
|
NUM2INT(src_width), NUM2INT(src_height),
|
|
NUM2DBL(offset_x), NUM2DBL(offset_y),
|
|
NUM2DBL(scale_x), NUM2DBL(scale_y), type);
|
|
return self;
|
|
}
|
|
|
|
static VALUE
|
|
rg_composite(VALUE self, VALUE dest_width, VALUE dest_height, VALUE interp_type, VALUE overall_alpha, VALUE check_size, VALUE color1, VALUE color2)
|
|
{
|
|
GdkPixbuf* dest;
|
|
VALUE ret;
|
|
GdkInterpType type = GDK_INTERP_BILINEAR;
|
|
|
|
if (!NIL_P(interp_type))
|
|
type = RVAL2GDKINTERPTYPE(interp_type);
|
|
|
|
dest = gdk_pixbuf_composite_color_simple(
|
|
_SELF(self), NUM2INT(dest_width), NUM2INT(dest_height),
|
|
type, NUM2INT(overall_alpha), NUM2INT(check_size),
|
|
NUM2UINT(color1), NUM2UINT(color2));
|
|
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
|
|
static VALUE
|
|
rg_composite_bang(int argc, VALUE *argv, VALUE self)
|
|
{
|
|
VALUE ret;
|
|
VALUE args[16];
|
|
GdkInterpType interp_type = GDK_INTERP_BILINEAR;
|
|
|
|
rb_scan_args(argc, argv, "97",
|
|
&args[0], &args[1], &args[2], &args[3], &args[4],
|
|
&args[5], &args[6], &args[7], &args[8], &args[9],
|
|
&args[10], &args[11], &args[12], &args[13], &args[14],
|
|
&args[15]);
|
|
|
|
switch (argc) {
|
|
case 11:
|
|
if (!NIL_P(args[9]))
|
|
interp_type = RVAL2GDKINTERPTYPE(args[9]);
|
|
|
|
gdk_pixbuf_composite(_SELF(args[0]), _SELF(self),
|
|
NUM2INT(args[1]), NUM2INT(args[2]),
|
|
NUM2INT(args[3]), NUM2INT(args[4]),
|
|
NUM2DBL(args[5]), NUM2DBL(args[6]),
|
|
NUM2DBL(args[7]), NUM2DBL(args[8]),
|
|
interp_type, NUM2INT(args[10]));
|
|
ret = self;
|
|
break;
|
|
case 16:
|
|
if (!NIL_P(args[9]))
|
|
interp_type = RVAL2GDKINTERPTYPE(args[9]);
|
|
|
|
gdk_pixbuf_composite_color(_SELF(args[0]), _SELF(self),
|
|
NUM2INT(args[1]), NUM2INT(args[2]),
|
|
NUM2INT(args[3]), NUM2INT(args[4]),
|
|
NUM2DBL(args[5]), NUM2DBL(args[6]),
|
|
NUM2DBL(args[7]), NUM2DBL(args[8]),
|
|
interp_type, NUM2INT(args[10]),
|
|
NUM2INT(args[11]), NUM2INT(args[12]),
|
|
NUM2INT(args[13]), NUM2UINT(args[14]),
|
|
NUM2UINT(args[15]));
|
|
ret = self;
|
|
break;
|
|
default:
|
|
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
|
|
static VALUE
|
|
rg_rotate(VALUE self, VALUE angle)
|
|
{
|
|
VALUE ret;
|
|
GdkPixbuf* dest = gdk_pixbuf_rotate_simple(_SELF(self), RVAL2GDKPIXBUFROTATION(angle));
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
|
|
static VALUE
|
|
rg_flip(VALUE self, VALUE horizontal)
|
|
{
|
|
VALUE ret;
|
|
GdkPixbuf* dest = gdk_pixbuf_flip(_SELF(self), RVAL2CBOOL(horizontal));
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static VALUE
|
|
rg_add_alpha(VALUE self, VALUE substitute_color, VALUE r, VALUE g, VALUE b)
|
|
{
|
|
VALUE ret;
|
|
GdkPixbuf* dest = gdk_pixbuf_add_alpha(_SELF(self),
|
|
RVAL2CBOOL(substitute_color),
|
|
FIX2INT(r), FIX2INT(g), FIX2INT(b));
|
|
if (dest == NULL)
|
|
return Qnil;
|
|
ret = GOBJ2RVAL(dest);
|
|
g_object_unref(dest);
|
|
return ret;
|
|
}
|
|
|
|
static VALUE
|
|
rg_copy_area(VALUE self, VALUE src_x, VALUE src_y, VALUE width, VALUE height, VALUE dest, VALUE dest_x, VALUE dest_y)
|
|
{
|
|
gdk_pixbuf_copy_area(_SELF(self), NUM2INT(src_x), NUM2INT(src_y),
|
|
NUM2INT(width), NUM2INT(height),
|
|
_SELF(dest), NUM2INT(dest_x), NUM2INT(dest_y));
|
|
return dest;
|
|
}
|
|
|
|
static VALUE
|
|
rg_saturate_and_pixelate(VALUE self, VALUE staturation, VALUE pixelate)
|
|
{
|
|
GdkPixbuf* dest = gdk_pixbuf_copy(_SELF(self));
|
|
gdk_pixbuf_saturate_and_pixelate(_SELF(self), dest,
|
|
NUM2DBL(staturation), RVAL2CBOOL(pixelate));
|
|
return GOBJ2RVAL(dest);
|
|
}
|
|
|
|
static VALUE
|
|
rg_fill_bang(VALUE self, VALUE pixel)
|
|
{
|
|
gdk_pixbuf_fill(_SELF(self), NUM2UINT(pixel));
|
|
return self;
|
|
}
|
|
|
|
/* From Module Interface */
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
|
|
static VALUE
|
|
rg_s_formats(G_GNUC_UNUSED VALUE self)
|
|
{
|
|
return GSLIST2ARY2(gdk_pixbuf_get_formats(), GDK_TYPE_PIXBUF_FORMAT);
|
|
}
|
|
|
|
#ifdef HAVE_GDK_PIXBUF_SET_OPTION
|
|
static VALUE
|
|
rg_set_option(VALUE self, VALUE key, VALUE value)
|
|
{
|
|
return CBOOL2RVAL(gdk_pixbuf_set_option(_SELF(self),
|
|
RVAL2CSTR(key), RVAL2CSTR(value)));
|
|
}
|
|
#else
|
|
static VALUE
|
|
rg_set_option(G_GNUC_UNUSED VALUE self, G_GNUC_UNUSED VALUE key, G_GNUC_UNUSED VALUE value)
|
|
{
|
|
rb_warning("not supported in this version of GTK+");
|
|
return Qfalse;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
extern void Init_gdk_pixbuf2(void);
|
|
|
|
void
|
|
Init_gdk_pixbuf2(void)
|
|
{
|
|
VALUE mGdk = rb_define_module("Gdk");
|
|
VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXBUF, "Pixbuf", mGdk);
|
|
|
|
id_pixdata = rb_intern("pixdata");
|
|
|
|
/*
|
|
gdk_rgb_init();*/ /* initialize it anyway */
|
|
|
|
/*
|
|
* Initialization and Versions
|
|
*/
|
|
/* Removed. This crashes Ruby/GTK on Windows + GTK+-2.4.x.
|
|
Pointed out by Laurent.
|
|
#ifdef HAVE_GDK_PIXBUF_VERSION
|
|
rb_define_const(RG_TARGET_NAMESPACE, "VERSION", CSTR2RVAL(gdk_pixbuf_version));
|
|
#endif
|
|
*/
|
|
rb_define_const(RG_TARGET_NAMESPACE, "MAJOR", INT2FIX(GDK_PIXBUF_MAJOR));
|
|
rb_define_const(RG_TARGET_NAMESPACE, "MINOR", INT2FIX(GDK_PIXBUF_MINOR));
|
|
rb_define_const(RG_TARGET_NAMESPACE, "MICRO", INT2FIX(GDK_PIXBUF_MICRO));
|
|
|
|
/*
|
|
* The GdkPixbuf Structure
|
|
*/
|
|
G_REPLACE_GET_PROPERTY(RG_TARGET_NAMESPACE, "pixels", get_pixels, 0);
|
|
RG_DEF_METHOD_OPERATOR("pixels=", set_pixels, 1);
|
|
RG_DEF_METHOD(get_option, 1);
|
|
|
|
/* GdkPixbufError */
|
|
G_DEF_ERROR(GDK_PIXBUF_ERROR, "PixbufError", mGdk, rb_eRuntimeError, GDK_TYPE_PIXBUF_ERROR);
|
|
|
|
/* GdkColorspace */
|
|
G_DEF_CLASS(GDK_TYPE_COLORSPACE, "ColorSpace", RG_TARGET_NAMESPACE);
|
|
G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_COLORSPACE, "GDK_");
|
|
|
|
/* GdkPixbufAlphaMode */
|
|
G_DEF_CLASS(GDK_TYPE_PIXBUF_ALPHA_MODE, "AlphaMode", RG_TARGET_NAMESPACE);
|
|
G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_PIXBUF_ALPHA_MODE, "GDK_PIXBUF_");
|
|
|
|
/*
|
|
* File Loading, Image Data in Memory
|
|
*/
|
|
RG_DEF_METHOD(initialize, -1);
|
|
RG_DEF_METHOD(dup, 0);
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
RG_DEF_SMETHOD(get_file_info, 1);
|
|
#endif
|
|
|
|
/*
|
|
* File saving
|
|
*/
|
|
RG_DEF_METHOD(save, -1);
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
|
|
RG_DEF_METHOD(save_to_buffer, -1);
|
|
#endif
|
|
|
|
/*
|
|
* Scaling
|
|
*/
|
|
RG_DEF_METHOD(scale, -1);
|
|
RG_DEF_METHOD_BANG(scale, -1);
|
|
RG_DEF_METHOD(composite, 7);
|
|
RG_DEF_METHOD_BANG(composite, -1);
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
|
|
RG_DEF_METHOD(rotate, 1);
|
|
RG_DEF_METHOD(flip, 1);
|
|
#endif
|
|
|
|
/* GdkInterpType */
|
|
G_DEF_CLASS(GDK_TYPE_INTERP_TYPE, "InterpType", RG_TARGET_NAMESPACE);
|
|
G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_INTERP_TYPE, "GDK_");
|
|
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
|
|
/* GdkPixbufRotation */
|
|
G_DEF_CLASS(GDK_TYPE_PIXBUF_ROTATION, "GdkPixbufRotation", RG_TARGET_NAMESPACE);
|
|
G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_PIXBUF_ROTATION, "GDK_PIXBUF_");
|
|
#endif
|
|
/*
|
|
* Utilities
|
|
*/
|
|
RG_DEF_METHOD(add_alpha, 4);
|
|
RG_DEF_METHOD(copy_area, 7);
|
|
RG_DEF_METHOD(saturate_and_pixelate, 2);
|
|
RG_DEF_METHOD_BANG(fill, 1);
|
|
|
|
/*
|
|
* Module Interface
|
|
*/
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
|
|
RG_DEF_SMETHOD(formats, 0);
|
|
RG_DEF_METHOD(set_option, 2);
|
|
#endif
|
|
|
|
Init_gdk_pixbuf_animation(mGdk);
|
|
Init_gdk_pixbuf_animation_iter(mGdk);
|
|
#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
|
|
Init_gdk_pixbuf_simpleanim(mGdk);
|
|
#endif
|
|
Init_gdk_pixdata(mGdk);
|
|
Init_gdk_pixbuf_loader(mGdk);
|
|
Init_gdk_pixbuf_format(mGdk);
|
|
}
|