gdkpixbuf 0.20.0

data/rbgdk-pixbuf.h

@@ -0,0 +1,34 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixbuf.h -
+
+  $Author: ggc $
+  $Date: 2005/09/23 22:02:07 $
+
+  Copyright (C) 2002-2004 Masao Mutoh
+************************************************/
+
+
+#define GDK_PIXBUF_ENABLE_BACKEND
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk-pixbuf/gdk-pixdata.h>
+#include "rbgobject.h"
+
+extern void Init_gdk_pixbuf_animation(VALUE mGLib);
+extern void Init_gdk_pixdata(VALUE mGLib);
+extern void Init_gdk_pixbuf_loader(VALUE mGLib);
+extern void Init_gdk_pixbuf_format(VALUE mGLib);
+extern GType gdk_pixbuf_format_get_type(void);
+
+#define RBGDK_PIXBUF_CHECK_VERSION(major,minor,micro)    \
+    (GDK_PIXBUF_MAJOR > (major) || \
+     (GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR > (minor)) || \
+     (GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR == (minor) && \
+      GDK_PIXBUF_MICRO >= (micro)))
+
+#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+extern void Init_gdk_pixbuf_simpleanim(VALUE mGLib);
+#endif
+
+#define GDK_TYPE_PIXBUF_FORMAT (gdk_pixbuf_format_get_type())

data/rbgdk-pixbufanimation.c

@@ -0,0 +1,144 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixbufanimation.c -
+
+  $Author: mutoh $
+  $Date: 2004/11/30 16:23:13 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+#include "rbgdk-pixbuf.h"
+
+#define _SELF(s) (GDK_PIXBUF_ANIMATION(RVAL2GOBJ(s)))
+#define RVAL2ITR(i) (GDK_PIXBUF_ANIMATION_ITER(RVAL2GOBJ(i)))
+
+static VALUE
+animation_initialize(self, filename)
+    VALUE self, filename;
+{
+    GdkPixbufAnimation* ret;
+    GError* error = NULL;
+
+    ret = gdk_pixbuf_animation_new_from_file(RVAL2CSTR(filename), &error);
+    if (ret == NULL)
+        RAISE_GERROR(error);
+
+    G_INITIALIZE(self, ret);
+    return Qnil;
+}
+
+static VALUE
+animation_get_width(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_pixbuf_animation_get_width(_SELF(self)));
+}
+
+static VALUE
+animation_get_height(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_pixbuf_animation_get_height(_SELF(self)));
+}
+
+static VALUE
+animation_get_iter(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE start_time_sec, start_time_usec;
+    GTimeVal* time = NULL;
+
+    rb_scan_args(argc, argv, "02", &start_time_sec, &start_time_usec);
+
+    if (! NIL_P(start_time_sec)){
+        time = g_new(GTimeVal, 1);
+        time->tv_sec = NUM2LONG(start_time_sec);
+        if (NIL_P(start_time_usec)){
+            time->tv_usec = 0;
+        } else {
+            time->tv_usec = NUM2LONG(start_time_usec);
+        }
+    }
+    return GOBJ2RVAL(gdk_pixbuf_animation_get_iter(_SELF(self), time)); 
+}
+
+static VALUE
+animation_is_static_image(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_pixbuf_animation_is_static_image(_SELF(self)));
+}
+
+static VALUE
+animation_get_static_image(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_pixbuf_animation_get_static_image(_SELF(self)));
+}
+
+static VALUE
+animation_iter_advance(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE current_time_sec, current_time_usec;
+    GTimeVal* time = NULL;
+
+    rb_scan_args(argc, argv, "02", &current_time_sec, &current_time_usec);
+
+    if (! NIL_P(current_time_sec)){
+        time = g_new(GTimeVal, 1);
+        time->tv_sec = NUM2LONG(current_time_sec);
+        if (NIL_P(current_time_usec)){
+            time->tv_usec = 0;
+        } else {
+            time->tv_usec = NUM2LONG(current_time_usec);
+        }
+    }
+
+    return CBOOL2RVAL(gdk_pixbuf_animation_iter_advance(RVAL2ITR(self), time));
+}
+
+static VALUE
+animation_iter_get_delay_time(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_pixbuf_animation_iter_get_delay_time(RVAL2ITR(self)));
+}
+
+static VALUE
+animation_iter_on_currently_loading_frame(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_pixbuf_animation_iter_on_currently_loading_frame(RVAL2ITR(self)));
+}
+
+static VALUE
+animation_iter_get_pixbuf(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_pixbuf_animation_iter_get_pixbuf(RVAL2ITR(self)));
+}
+
+void
+Init_gdk_pixbuf_animation(VALUE mGdk)
+{
+    VALUE anim = G_DEF_CLASS(GDK_TYPE_PIXBUF_ANIMATION, "PixbufAnimation", mGdk);    
+    VALUE animiter = G_DEF_CLASS(GDK_TYPE_PIXBUF_ANIMATION_ITER, "PixbufAnimationIter", mGdk);    
+
+    rb_define_method(anim, "initialize", animation_initialize, 1);
+    rb_define_method(anim, "width", animation_get_width, 0);
+    rb_define_method(anim, "height", animation_get_height, 0);
+    rb_define_method(anim, "get_iter", animation_get_iter, -1);
+    rb_define_method(anim, "static_image?", animation_is_static_image, 0);
+    rb_define_method(anim, "static_image", animation_get_static_image, 0);
+    rb_define_method(animiter, "advance", animation_iter_advance, -1);
+    rb_define_method(animiter, "delay_time", animation_iter_get_delay_time, 0);
+    rb_define_method(animiter, "on_currently_loading_frame?", animation_iter_on_currently_loading_frame, 0);
+    rb_define_method(animiter, "pixbuf", animation_iter_get_pixbuf, 0);
+
+}

data/rbgdk-pixbufsimpleanim.c

@@ -0,0 +1,43 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixbufanimation.c -
+
+  $Author: ggc $
+  $Date: 2005/09/23 22:02:07 $
+
+  Copyright (C) 2002,2003 the ruby-gnome2 project
+************************************************/
+#include "rbgdk-pixbuf.h"
+
+#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+#define _SELF(s) (GDK_PIXBUF_SIMPLE_ANIM(RVAL2GOBJ(s)))
+
+static VALUE
+simpleanim_initialize(self, width, height, rate)
+    VALUE self, width, height, rate;
+{
+    GdkPixbufSimpleAnim* ret = gdk_pixbuf_simple_anim_new(NUM2INT(width), NUM2INT(height), NUM2DBL(rate));
+    G_INITIALIZE(self, ret);
+    return Qnil;
+}
+
+static VALUE
+simpleanim_add_frame(self, pixbuf)
+    VALUE self, pixbuf;
+{
+    gdk_pixbuf_simple_anim_add_frame(_SELF(self), RVAL2GOBJ(pixbuf));
+    return self;
+}
+#endif
+
+void
+Init_gdk_pixbuf_simpleanim(VALUE mGdk)
+{
+#if RBGDK_PIXBUF_CHECK_VERSION(2,8,0)
+    VALUE anim = G_DEF_CLASS(GDK_TYPE_PIXBUF_SIMPLE_ANIM, "PixbufSimpleAnim", mGdk);    
+
+    rb_define_method(anim, "initialize", simpleanim_initialize, 3);
+    rb_define_method(anim, "add_frame", simpleanim_add_frame, 1);
+#endif
+}

data/rbgdk-pixdata.c

@@ -0,0 +1,221 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixdata.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+#include "rbgdk-pixbuf.h"
+
+#define GDK_TYPE_PIXDATA (gdk_pixdata_get_type())
+#define _SELF(s) ((GdkPixdata*)(RVAL2BOXED(s, GDK_TYPE_PIXDATA)))
+#define PIXDATA2RVAL(pix) (BOXED2RVAL(pix, GDK_TYPE_PIXDATA))
+
+static ID id_pixdata;
+
+/*****************************************/
+GdkPixdata*
+gdk_pixdata_copy(const GdkPixdata* src)
+{
+  GdkPixdata* data;
+  g_return_val_if_fail (src != NULL, NULL);
+  data = g_new(GdkPixdata, 1);
+  *data = *src;
+  return data;
+}
+
+GType
+gdk_pixdata_get_type (void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+      our_type = g_boxed_type_register_static ("GdkPixdata",
+                                               (GBoxedCopyFunc)gdk_pixdata_copy,
+                                               (GBoxedFreeFunc)g_free);
+  return our_type;
+}
+/*****************************************/
+static VALUE
+pixdata_s_from_pixbuf(self, pixbuf, use_rle)
+    VALUE self, pixbuf, use_rle;
+{
+    GdkPixdata pixdata;
+    gpointer rle_data = gdk_pixdata_from_pixbuf(&pixdata, RVAL2GOBJ(pixbuf), RVAL2CBOOL(use_rle));
+    VALUE ret = PIXDATA2RVAL(&pixdata);
+    if (use_rle){
+        /* need to manage the returned value */
+        rb_ivar_set(ret, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, rle_data));
+    }
+    return ret;
+}
+
+static VALUE
+pixdata_to_pixbuf(self, copy_pixels)
+    VALUE self, copy_pixels;
+{
+    GError* error = NULL;
+    GdkPixbuf* ret = gdk_pixbuf_from_pixdata(_SELF(self), RVAL2CBOOL(copy_pixels), &error);
+    if (error)
+        RAISE_GERROR(error);
+    return GOBJ2RVAL(ret);
+}
+
+static VALUE
+pixdata_serialize(self)
+    VALUE self;
+{
+    guint stream_length;
+    gint i;
+    guint8* ret = gdk_pixdata_serialize(_SELF(self), &stream_length);
+    VALUE ary = rb_ary_new2(stream_length);
+    for (i = 0; i < stream_length; i++) {
+        rb_ary_push(ary, UINT2NUM(ret[i]));
+    }
+    return ary;
+}
+
+static VALUE
+pixdata_s_deserialize(self, stream)
+    VALUE self, stream;
+{
+    GdkPixdata pixdata;
+    gboolean ret;
+    guint8 *gstream;
+    GError* error = NULL;
+    gint i, len;
+
+    len = RARRAY_LEN(stream);
+    gstream = g_new(guint8, len);
+    //   gstream = ALLOCA_N(guint8, len);
+    for (i = 0; i < len; i++){
+        gstream[i] = (guint8)NUM2UINT(RARRAY_PTR(stream)[i]);
+    }
+    ret = gdk_pixdata_deserialize(&pixdata, len, gstream, &error);
+
+    /* need to manage the returned value */
+    rb_ivar_set(ret, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, gstream));
+
+    if (ret != TRUE) RAISE_GERROR(error);
+
+    return PIXDATA2RVAL(&pixdata);
+}
+
+static VALUE
+pixdata_to_csource(self, name, dump_type)
+    VALUE self, name, dump_type;
+{
+    GString* str = gdk_pixdata_to_csource(_SELF(self), RVAL2CSTR(name), FIX2INT(dump_type));
+    VALUE ret = CSTR2RVAL(str->str);
+    g_string_free(str, TRUE);
+    return ret;
+}
+
+/* GdkPixdata */
+static VALUE
+pixdata_magic(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->magic);
+}
+
+static VALUE
+pixdata_length(self)
+    VALUE self;
+{
+    gint32 length = _SELF(self)->length;
+
+    if(length > 0)
+        length -= GDK_PIXDATA_HEADER_LENGTH;
+    return INT2NUM(length);
+}
+
+static VALUE
+pixdata_pixdata_type(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->pixdata_type);
+}
+
+static VALUE
+pixdata_rowstride(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->rowstride);
+}
+
+static VALUE
+pixdata_width(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->width);
+}
+
+static VALUE
+pixdata_height(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->height);
+}
+
+static VALUE
+pixdata_pixel_data(self)
+    VALUE self;
+{
+    gint i;
+    guint8* ret = _SELF(self)->pixel_data;
+    gint32 length = _SELF(self)->length - GDK_PIXDATA_HEADER_LENGTH;
+
+    VALUE ary = rb_ary_new2(length);
+    for (i = 0; i < length; i++) {
+        rb_ary_push(ary, UINT2NUM(ret[i]));
+    }
+    return ary;
+}
+
+
+void
+Init_gdk_pixdata(VALUE mGdk)
+{
+    VALUE pixdata = G_DEF_CLASS(GDK_TYPE_PIXDATA, "Pixdata", mGdk);    
+
+    id_pixdata = rb_intern("pixdata");
+
+    rb_define_singleton_method(pixdata, "from_pixbuf", pixdata_s_from_pixbuf, 2);
+    rb_define_singleton_method(pixdata, "deserialize", pixdata_s_deserialize, 1);
+    rb_define_method(pixdata, "to_pixbuf", pixdata_to_pixbuf, 1);
+    rb_define_method(pixdata, "serialize", pixdata_serialize, 0);
+    rb_define_method(pixdata, "to_csource", pixdata_to_csource, 2);
+    rb_define_method(pixdata, "magic", pixdata_magic, 0);
+    rb_define_method(pixdata, "length", pixdata_length, 0);
+    rb_define_method(pixdata, "pixdata_type", pixdata_pixdata_type, 0);
+    rb_define_method(pixdata, "rowstride", pixdata_rowstride, 0);
+    rb_define_method(pixdata, "width", pixdata_width, 0);
+    rb_define_method(pixdata, "height", pixdata_height, 0);
+    rb_define_method(pixdata, "pixel_data", pixdata_pixel_data, 0);
+
+    rb_define_const(pixdata, "PIXBUF_MAGIC_NUMBER", INT2NUM(GDK_PIXBUF_MAGIC_NUMBER));
+    rb_define_const(pixdata, "HEADER_LENGTH", INT2NUM(GDK_PIXDATA_HEADER_LENGTH));
+
+    /* GdkPixdataType */
+    rb_define_const(pixdata, "COLOR_TYPE_RGB", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGB));
+    rb_define_const(pixdata, "COLOR_TYPE_RGBA", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGBA));
+    rb_define_const(pixdata, "COLOR_TYPE_MASK", INT2FIX(GDK_PIXDATA_COLOR_TYPE_MASK));
+    rb_define_const(pixdata, "SAMPLE_WIDTH_8", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_8));
+    rb_define_const(pixdata, "SAMPLE_WIDTH_MASK", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_MASK));
+    rb_define_const(pixdata, "ENCODING_RAW", INT2FIX(GDK_PIXDATA_ENCODING_RAW));
+    rb_define_const(pixdata, "ENCODING_RLE", INT2FIX(GDK_PIXDATA_ENCODING_RLE));
+    rb_define_const(pixdata, "ENCODING_MASK", INT2FIX(GDK_PIXDATA_ENCODING_MASK));
+
+    /* GdkPixdataDumpType */
+    rb_define_const(pixdata, "DUMP_PIXDATA_STREAM", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STREAM));
+    rb_define_const(pixdata, "DUMP_PIXDATA_STRUCT", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STRUCT));
+    rb_define_const(pixdata, "DUMP_MACROS", INT2FIX(GDK_PIXDATA_DUMP_MACROS));
+    rb_define_const(pixdata, "DUMP_GTYPES", INT2FIX(GDK_PIXDATA_DUMP_GTYPES));
+    rb_define_const(pixdata, "DUMP_CTYPES", INT2FIX(GDK_PIXDATA_DUMP_CTYPES));
+    rb_define_const(pixdata, "DUMP_STATIC", INT2FIX(GDK_PIXDATA_DUMP_STATIC));
+    rb_define_const(pixdata, "DUMP_CONST", INT2FIX(GDK_PIXDATA_DUMP_CONST));
+    rb_define_const(pixdata, "DUMP_RLE_DECODER", INT2FIX(GDK_PIXDATA_DUMP_RLE_DECODER));
+}

data/sample/anim.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+=begin
+  anim.rb - Ruby/GdkPixbuf sample script.
+
+  Copyright (c) 2002-2006 Ruby-GNOME2 Project Team
+  This program is licenced under the same licence as Ruby-GNOME2.
+
+  $Id: anim.rb,v 1.5 2006/06/17 14:38:08 mutoh Exp $
+=end
+
+require 'gtk2'
+
+w = Gtk::Window.new
+w.signal_connect('delete-event') do
+  Gtk.main_quit
+end
+
+box = Gtk::VBox.new
+src =  Gdk::PixbufAnimation.new("floppybuddy.gif")
+box.pack_start(Gtk::Image.new(src))
+p src.width
+p src.height
+p src.static_image?
+
+static_image = src.static_image
+box.pack_start(Gtk::Image.new(static_image))
+
+iter = src.get_iter
+p iter.advance
+p iter.delay_time
+p iter.on_currently_loading_frame?
+
+box.pack_start(Gtk::Image.new(iter.pixbuf))
+
+w.add(box)
+w.show_all
+
+Gtk.main