gdk_pixbuf2 0.90.2

data/Rakefile

@@ -0,0 +1,74 @@
+# -*- ruby -*-
+
+require 'pathname'
+require 'find'
+require 'rubygems'
+require 'rake/extensiontask'
+
+@top_dir = Pathname(__FILE__).dirname.parent.expand_path
+@rb_glib2_dir = @top_dir + "glib2"
+
+task :default => :build
+
+def version
+  @version ||= ENV["VERSION"] || guess_version
+end
+
+def guess_version
+  versions = {}
+  rbglib_h_path = @rb_glib2_dir + "ext" + "glib2" + "rbglib.h"
+  rbglib_h_path.open do |rbglib_h|
+    rbglib_h.each_line do |line|
+      if /#define\s+RBGLIB_([A-Z]+)_VERSION\s+(\d+)/ =~ line
+        versions[$1.downcase] = $2.to_i
+      end
+    end
+  end
+  ["major", "minor", "micro"].collect {|type| versions[type]}.compact.join(".")
+end
+
+package_name = "gdk_pixbuf2"
+
+spec = Gem::Specification.new do |s|
+  s.name = package_name
+  s.summary = "Ruby/GdkPixbuf2 is a Ruby binding of GdkPixbuf-2.x."
+  s.description = "Ruby/GdkPixbuf2 is a Ruby binding of GdkPixbuf-2.x."
+  s.author = "The Ruby-GNOME2 Proejct Team"
+  s.email = "ruby-gnome2-devel-en@lists.sourceforge.net"
+  s.homepage = "http://ruby-gnome2.sourceforge.jp/"
+  s.version = version
+  s.platform = Gem::Platform::RUBY
+  s.add_dependency("cairo", ">= 1.10.0")
+  s.add_dependency("glib2", "= #{version}")
+  s.extensions = FileList["ext/#{package_name}/extconf.rb"]
+  s.require_paths = ["lib"]
+  s.files = FileList["ChangeLog", "README", "Rakefile", "extconf.rb",
+                     "lib/**/*.rb", "{ext,sample,test}/**/*"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end
+
+Rake::ExtensionTask.new(package_name, spec) do |ext|
+  ext.cross_compile = true
+  ext.cross_compiling do |spec|
+    if /mingw|mswin/ =~ spec.platform.to_s
+      win32_dir = File.join("vendor", "local")
+      win32_files = []
+      Find.find(win32_dir) do |file|
+        next if /\.zip\z/ =~ file
+        win32_files << file
+      end
+      spec.files += win32_files
+    end
+  end
+end
+
+namespace :win32 do
+  desc "download Windows binaries"
+  task :download do
+    $LOAD_PATH.unshift((@rb_glib2_dir + "lib").to_s)
+    require 'gnome2-win32-binary-downloader'
+    GNOME2Win32BinaryDownloader.download(:package => "gtk+")
+  end
+end

data/ext/gdk_pixbuf2/depend

@@ -0,0 +1,3 @@
+install:
+	$(MAKEDIRS) $(libdir)/pkgconfig
+	$(INSTALL_DATA) ruby-gdkpixbuf2.pc $(libdir)/pkgconfig

data/ext/gdk_pixbuf2/extconf.rb

@@ -0,0 +1,61 @@
+=begin
+extconf.rb for Ruby/GdkPixbuf2 extention library
+=end
+
+require 'pathname'
+
+base_dir = Pathname(__FILE__).dirname.parent.parent.expand_path
+top_dir = base_dir.parent
+top_build_dir = Pathname(".").parent.parent.parent.expand_path
+
+mkmf_gnome2_dir = top_dir + "glib2" + 'lib'
+version_suffix = ""
+unless mkmf_gnome2_dir.exist?
+  if /(-\d+\.\d+\.\d+)\z/ =~ base_dir.basename.to_s
+    version_suffix = $1
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+  end
+end
+
+$LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
+
+module_name = "gdk_pixbuf2"
+package_id = "gdk-pixbuf-2.0"
+
+require 'mkmf-gnome2'
+
+setup_win32(module_name, base_dir)
+
+PKGConfig.have_package(package_id) or exit 1
+
+have_func("gdk_pixbuf_set_option", "gdk-pixbuf/gdk-pixbuf.h") do |src|
+  "#define GDK_PIXBUF_ENABLE_BACKEND\n#{src}"
+end
+have_header("gdk-pixbuf/gdk-pixbuf-io.h")
+
+if PKGConfig.have_package('gdk-2.0')
+  options = {}
+  rcairo_source_dir_names = ["rcairo"]
+  if /mingw|cygwin|mswin32/ =~ RUBY_PLATFORM
+    rcairo_source_dir_names.unshift("rcairo.win32")
+  end
+  rcairo_source_dir_names.each do |rcairo_source_dir_name|
+    rcairo_source_dir = top_dir.parent.expand_path + rcairo_source_dir_name
+    if rcairo_source_dir.exist?
+      options[:rcairo_source_dir] = rcairo_source_dir.to_s
+      break
+    end
+  end
+  check_cairo(options)
+end
+
+["glib2"].each do |package|
+  directory = "#{package}#{version_suffix}"
+  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"
+  add_depend_package(package, "#{directory}/ext/#{package}",
+                     top_dir.to_s,
+                     :top_build_dir => top_build_dir.to_s,
+                     :target_build_dir => build_dir)
+end
+create_pkg_config_file("Ruby/GdkPixbuf2", package_id)
+create_makefile(module_name)

data/ext/gdk_pixbuf2/gdk_pixbuf2.def

@@ -0,0 +1,2 @@
+EXPORTS
+	Init_gdk_pixbuf2

data/ext/gdk_pixbuf2/rbgdk-pixbuf-format.c

@@ -0,0 +1,182 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixbuf-format.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+
+#include "rbgdk-pixbuf.h"
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+
+#ifdef HAVE_GDK_PIXBUF_GDK_PIXBUF_IO_H
+#include <gdk-pixbuf/gdk-pixbuf-io.h>
+#endif
+
+#define _SELF(r) ((GdkPixbufFormat*)RVAL2BOXED(r, GDK_TYPE_PIXBUF_FORMAT))
+
+
+/**********************************/
+static GdkPixbufFormat*
+format_copy(const GdkPixbufFormat* val)
+{
+    GdkPixbufFormat* new_val;
+    g_return_val_if_fail (val != NULL, NULL);
+    new_val = g_new(GdkPixbufFormat, 1);
+    *new_val = *val;
+    return new_val;
+}
+
+GType
+gdk_pixbuf_format_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("GdkPixbufFormat",
+                                                 (GBoxedCopyFunc)format_copy,
+                                                 (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+/**********************************/
+
+/* Move to rbgdk-pixbuf.c
+gboolean    gdk_pixbuf_set_option           (GdkPixbuf *pixbuf,
+                                             const gchar *key,
+                                             const gchar *value);
+GSList*     gdk_pixbuf_get_formats          (void);
+*/
+
+static VALUE
+get_name(self)
+    VALUE self;
+{
+    return CSTR2RVAL2(gdk_pixbuf_format_get_name(_SELF(self)));
+}
+
+static VALUE
+get_description(self)
+    VALUE self;
+{
+    return CSTR2RVAL2(gdk_pixbuf_format_get_description(_SELF(self)));
+}
+    
+static VALUE
+get_mime_types(self)
+    VALUE self;
+{
+    gint i = 0;
+    gchar** mime_types = gdk_pixbuf_format_get_mime_types(_SELF(self));
+    VALUE array = rb_ary_new();
+    while(mime_types[i]){
+        rb_ary_push(array, CSTR2RVAL(mime_types[i]));
+        i++;
+    }
+    g_strfreev(mime_types);
+    return array;
+}
+
+static VALUE
+get_extensions(self)
+    VALUE self;
+{
+    gint i = 0;
+    gchar** extensions = gdk_pixbuf_format_get_extensions(_SELF(self));
+    VALUE array = rb_ary_new();
+
+    while(extensions[i]){
+        rb_ary_push(array, CSTR2RVAL(extensions[i]));
+        i++;
+    }
+    g_strfreev(extensions);
+    return array;
+}
+
+static VALUE
+is_writable(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_pixbuf_format_is_writable(_SELF(self)));
+}
+
+/* Structure */
+static VALUE
+get_domain(self)
+    VALUE self;
+{
+    return CSTR2RVAL(_SELF(self)->domain);
+}
+
+static VALUE
+get_signature(self)
+    VALUE self;
+{
+    GdkPixbufModulePattern* signature = _SELF(self)->signature;
+
+    VALUE array = rb_ary_new();
+    int i = 0;
+    while(signature[i].prefix){
+        rb_ary_push(array, rb_ary_new3(3, CSTR2RVAL((const char*)signature[i].prefix),
+                                       CSTR2RVAL((const char*)signature[i].mask),
+                                       INT2NUM(signature[i].relevance)));
+        i++;
+    }
+    return array;
+}
+#endif
+
+#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
+static VALUE
+is_scalable(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_pixbuf_format_is_scalable(_SELF(self)));
+}
+static VALUE
+is_disabled(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_pixbuf_format_is_disabled(_SELF(self)));
+}
+static VALUE
+set_disabled(self, disabled)
+    VALUE self, disabled;
+{
+    gdk_pixbuf_format_set_disabled(_SELF(self), RVAL2CBOOL(disabled));
+    return self;
+}
+static VALUE
+get_license(self)
+    VALUE self;
+{
+    return CSTR2RVAL(gdk_pixbuf_format_get_license(_SELF(self)));
+}
+#endif
+
+void
+Init_gdk_pixbuf_format(VALUE mGdk)
+{
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+    VALUE format = G_DEF_CLASS(GDK_TYPE_PIXBUF_FORMAT, "PixbufFormat", mGdk);
+
+    rb_define_method(format, "name", get_name, 0);
+    rb_define_method(format, "description", get_description, 0);
+    rb_define_method(format, "mime_types", get_mime_types, 0);
+    rb_define_method(format, "extensions", get_extensions, 0);
+    rb_define_method(format, "writable?", is_writable, 0);
+    rb_define_method(format, "domain", get_domain, 0);
+    rb_define_method(format, "signature", get_signature, 0);
+#if RBGDK_PIXBUF_CHECK_VERSION(2,6,0)
+    rb_define_method(format, "scalable?", is_scalable, 0);
+    rb_define_method(format, "disabled?", is_disabled, 0);
+    rb_define_method(format, "set_disabled", set_disabled, 1);
+    rb_define_method(format, "license", get_license, 0);
+
+#endif
+    G_DEF_SETTERS(format);
+#endif
+}
+

data/ext/gdk_pixbuf2/rbgdk-pixbuf-loader.c

@@ -0,0 +1,164 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdk-pixbuf-loader.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:06 $
+
+  Copyright (C) 2004 Masao Mutoh
+  Copyright (C) 2003 Geoff Youngs
+************************************************/
+
+#include "rbgdk-pixbuf.h"
+
+#define _SELF(s) GDK_PIXBUF_LOADER(RVAL2GOBJ(s))
+
+/****************************************************/
+/* File opening */
+/* Image Data in Memory */
+static VALUE
+initialize_loader(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    GdkPixbufLoader* loader;
+    GError* error = NULL;
+    VALUE arg1, is_mime_type;
+
+    rb_scan_args(argc, argv, "02", &arg1, &is_mime_type);
+
+    if (NIL_P(arg1)) {
+        loader = gdk_pixbuf_loader_new();
+    } else {
+        if (is_mime_type == Qtrue) {
+#if RBGDK_PIXBUF_CHECK_VERSION(2,4,0)
+            loader = gdk_pixbuf_loader_new_with_mime_type(RVAL2CSTR(arg1), &error);
+#else
+            rb_warning("Not supported GTK+-2.0/2.2.");
+            loader = gdk_pixbuf_loader_new();
+#endif
+        } else {
+            /* Default behavior */
+            loader = gdk_pixbuf_loader_new_with_type(RVAL2CSTR(arg1), &error);
+        }
+        if(error) RAISE_GERROR(error);
+    }
+    
+    G_INITIALIZE(self, loader);
+    return Qnil;
+}
+
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+static VALUE
+loader_get_format(self)
+    VALUE self;
+{
+    GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self));
+    return BOXED2RVAL(format, GDK_TYPE_PIXBUF_FORMAT);
+}
+#endif
+
+static VALUE
+loader_write(self, data)
+    VALUE self;
+    VALUE data;
+{
+    GError *error = NULL;
+    gboolean res;
+  
+    res = gdk_pixbuf_loader_write(_SELF(self), (const guchar*)RVAL2CSTR(data),
+                                  RSTRING_LEN(data), &error);
+    if (error)
+        RAISE_GERROR(error);
+    return CBOOL2RVAL(res);
+}
+
+static VALUE
+last_write(self, data)
+    VALUE self;
+    VALUE data;
+{
+    GError *error = NULL;
+    gboolean res;
+
+    res = gdk_pixbuf_loader_write(_SELF(self), (const guchar*)RVAL2CSTR(data),
+                                  RSTRING_LEN(data), &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    res = gdk_pixbuf_loader_close(_SELF(self), &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(res);
+}
+
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+static VALUE
+loader_set_size(self, width, height)
+    VALUE self, width, height;
+{
+    gdk_pixbuf_loader_set_size(_SELF(self), NUM2INT(width), NUM2INT(height));
+    return self;
+}
+#endif
+
+static VALUE
+loader_close(self)
+    VALUE self;
+{
+    GError *error = NULL;
+    gboolean res;
+	
+    res = gdk_pixbuf_loader_close(_SELF(self), &error);
+    if(error)
+        RAISE_GERROR(error);
+	
+    return CBOOL2RVAL(res);
+}
+
+/****************************************************/
+/* Creating image */
+static VALUE
+get_pixbuf(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_pixbuf_loader_get_pixbuf(_SELF(self)));
+}
+
+/* Creating animation */
+static VALUE
+get_animation(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_pixbuf_loader_get_animation(_SELF(self)));
+}
+
+
+void 
+Init_gdk_pixbuf_loader(VALUE mGdk)
+{
+    VALUE gdkPixbufLoader;
+    /* initialize it */
+    gdkPixbufLoader = G_DEF_CLASS(GDK_TYPE_PIXBUF_LOADER, "PixbufLoader", mGdk);    
+
+    /* 
+     * File Loading, Image Data in Memory
+     */
+    rb_define_method(gdkPixbufLoader, "initialize", initialize_loader, -1);
+
+    rb_undef_method(gdkPixbufLoader, "dup");
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+    rb_define_method(gdkPixbufLoader, "format", loader_get_format, 0);
+#endif
+    rb_define_method(gdkPixbufLoader, "write", loader_write, 1);
+    rb_define_method(gdkPixbufLoader, "last_write", last_write, 1);
+#if RBGDK_PIXBUF_CHECK_VERSION(2,2,0)
+    rb_define_method(gdkPixbufLoader, "set_size", loader_set_size, 2);
+#endif
+    rb_define_method(gdkPixbufLoader, "close", loader_close, 0);
+    rb_define_method(gdkPixbufLoader, "pixbuf", get_pixbuf, 0);
+    rb_define_method(gdkPixbufLoader, "animation", get_animation, 0);
+}