gtk2 0.20.0

data/src/rbgdkkeyval.c

@@ -0,0 +1,105 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkkeyval.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:08 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+#include <gdk/gdkkeysyms.h>
+
+static VALUE
+keyval_to_name(self, keyval)
+    VALUE self, keyval;
+{
+    gchar* name = gdk_keyval_name(NUM2UINT(keyval));
+    return name ? CSTR2RVAL(name) : Qnil;
+}
+
+static VALUE
+keyval_from_name(self, keyval_name)
+    VALUE self, keyval_name;
+{
+    return UINT2NUM(gdk_keyval_from_name(RVAL2CSTR(keyval_name)));
+}
+
+static VALUE
+keyval_is_upper(self, keyval)
+    VALUE self, keyval;
+{
+    return CBOOL2RVAL(gdk_keyval_is_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+keyval_is_lower(self, keyval)
+    VALUE self, keyval;
+{
+    return CBOOL2RVAL(gdk_keyval_is_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+keyval_convert_case(self, symbol)
+    VALUE self, symbol;
+{
+    guint upper, lower;
+    gdk_keyval_convert_case(NUM2UINT(symbol), &lower, &upper);
+    return rb_ary_new3(2, UINT2NUM(lower), UINT2NUM(upper));
+}
+
+static VALUE
+keyval_to_upper(self, keyval)
+    VALUE self, keyval;
+{
+    return INT2NUM(gdk_keyval_to_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+keyval_to_lower(self, keyval)
+    VALUE self, keyval;
+{
+    return INT2NUM(gdk_keyval_to_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+keyval_to_unicode(self, keyval)
+    VALUE self, keyval;
+{
+    return UINT2NUM(gdk_keyval_to_unicode(NUM2UINT(keyval)));
+}
+
+static VALUE
+unicode_to_keyval(self, wc)
+    VALUE self, wc;
+{
+    VALUE unicode;
+    if (TYPE(wc) == T_STRING) {
+        unicode = NUM2UINT(rb_funcall(wc, rb_intern("[]"), 1, INT2FIX(0)));
+    } else {
+        unicode = NUM2UINT(wc);
+    }
+    return UINT2NUM(gdk_unicode_to_keyval(unicode));
+}
+
+void
+Init_gtk_gdk_keyval()
+{
+    VALUE mGdkKeyval = rb_define_module_under(mGdk, "Keyval");
+    rb_define_module_function(mGdkKeyval, "to_name", keyval_to_name, 1);
+    rb_define_module_function(mGdkKeyval, "from_name", keyval_from_name, 1);
+    rb_define_module_function(mGdkKeyval, "upper?", keyval_is_upper, 1);
+    rb_define_module_function(mGdkKeyval, "lower?", keyval_is_lower, 1);
+    rb_define_module_function(mGdkKeyval, "convert_case", keyval_convert_case, 1);
+    rb_define_module_function(mGdkKeyval, "to_upper", keyval_to_upper, 1);
+    rb_define_module_function(mGdkKeyval, "to_lower", keyval_to_lower, 1);
+    rb_define_module_function(mGdkKeyval, "to_unicode", keyval_to_unicode, 1);
+    rb_define_module_function(mGdkKeyval, "from_unicode", unicode_to_keyval, 1);
+
+#include "rbgdkkeysyms.h"
+}

data/src/rbgdkpango.c

@@ -0,0 +1,171 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkpango.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2003,2004 Masao Mutoh
+************************************************/
+
+#include "global.h"
+#include "rbpango.h"
+
+static VALUE
+gdkpango_s_context_get(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE screen, ret;
+    rb_scan_args(argc, argv, "01", &screen);
+    if (NIL_P(screen)){
+        ret = GOBJ2RVAL(gdk_pango_context_get());
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        ret = GOBJ2RVAL(gdk_pango_context_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
+#else
+        rb_warn("Gdk::Pango.context_get: Not supported arguments in GTK+-2.0.x.");
+        ret = GOBJ2RVAL(gdk_pango_context_get());
+#endif
+    }
+    return ret;
+}
+
+static VALUE
+gdkpango_context_set_colormap(self, colormap)
+    VALUE self, colormap;
+{
+    gdk_pango_context_set_colormap(PANGO_CONTEXT(RVAL2GOBJ(self)),
+                                   GDK_COLORMAP(RVAL2GOBJ(self)));
+    return self;
+}
+
+static VALUE
+gdkpango_attr_embossed_initialize(self, embossed)
+    VALUE self, embossed;
+{
+    DATA_PTR(self) = gdk_pango_attr_embossed_new(RVAL2CBOOL(embossed));
+    return Qnil;
+}
+
+static VALUE
+gdkpango_attr_embossed_value(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(((GdkPangoAttrEmbossed*)RVAL2ATTR(self))->embossed);
+}
+
+static VALUE
+gdkpango_attr_stipple_initialize(self, stipple)
+    VALUE self, stipple;
+{
+    DATA_PTR(self) = gdk_pango_attr_stipple_new(GDK_BITMAP(RVAL2GOBJ(stipple)));
+    return Qnil;
+}
+
+static VALUE
+gdkpango_attr_stipple_value(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(((GdkPangoAttrStipple*)RVAL2ATTR(self))->stipple);
+}
+
+static VALUE
+gdkpango_layout_get_clip_region(self, x_origin, y_origin, index_ranges)
+    VALUE self, x_origin, y_origin, index_ranges;
+{
+    int i;
+    gint len = RARRAY_LEN(index_ranges);
+    gint* ranges = g_new(gint, len);
+
+    for (i = 0; i < len; i++) {
+        ranges[i] = RARRAY_PTR(index_ranges)[i];
+    }
+    return BOXED2RVAL(gdk_pango_layout_get_clip_region(PANGO_LAYOUT(RVAL2GOBJ(self)),
+                                                       NUM2INT(x_origin),
+                                                       NUM2INT(y_origin),
+                                                       ranges, len), GDK_TYPE_REGION);
+}
+
+static VALUE
+gdkpango_layout_line_get_clip_region(self, x_origin, y_origin, index_ranges)
+    VALUE self, x_origin, y_origin, index_ranges;
+{
+    int i;
+    gint len = RARRAY_LEN(index_ranges);
+    gint* ranges = g_new(gint, len);
+
+    for (i = 0; i < len; i++) {
+        ranges[i] = RARRAY_PTR(index_ranges)[i];
+    }
+    return BOXED2RVAL(gdk_pango_layout_line_get_clip_region(
+                          (PangoLayoutLine*)RVAL2BOXED(self, PANGO_TYPE_LAYOUT_LINE),
+                          NUM2INT(x_origin),
+                          NUM2INT(y_origin),
+                          ranges, len), GDK_TYPE_REGION);
+}
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+static VALUE
+gdkpango_attr_emboss_color_initialize(VALUE self, VALUE color)
+{
+    DATA_PTR(self) = gdk_pango_attr_emboss_color_new(RVAL2GDKCOLOR(color));
+    return Qnil;
+}
+
+static VALUE
+gdkpango_attr_emboss_color_value(VALUE self)
+{
+    return BOXED2RVAL(&(((GdkPangoAttrEmbossColor *)RVAL2ATTR(self))->color),
+		      PANGO_TYPE_COLOR);
+}
+#endif
+
+void
+Init_gtk_gdk_pango()
+{
+    VALUE klass;
+    PangoAttribute* tmpattr;
+    GdkColor color;
+
+    VALUE mGdkPango = rb_define_module_under(mGdk, "Pango");
+    VALUE context = GTYPE2CLASS(PANGO_TYPE_CONTEXT);
+    VALUE layout = GTYPE2CLASS(PANGO_TYPE_LAYOUT);
+    VALUE layoutline = GTYPE2CLASS(PANGO_TYPE_LAYOUT_LINE);
+    VALUE pattr = ATTRTYPE2CLASS(CSTR2RVAL("Attribute"));
+    VALUE pattrbool = ATTRTYPE2CLASS(CSTR2RVAL("AttrBool"));
+    VALUE pattr_color = ATTRTYPE2CLASS(CSTR2RVAL("AttrColor"));
+
+    rb_define_module_function(mGdkPango, "context", gdkpango_s_context_get, -1);
+
+    rb_define_method(context, "set_colormap", gdkpango_context_set_colormap, 1);
+    G_DEF_SETTER(context, "colormap");
+    rb_define_method(layout, "get_clip_region", gdkpango_layout_get_clip_region, 3);
+    rb_define_method(layoutline, "get_clip_region", gdkpango_layout_line_get_clip_region, 3);
+
+    klass = rb_define_class_under(mGdk, "PangoAttrEmbossed", pattrbool);
+    rb_define_method(klass, "initialize", gdkpango_attr_embossed_initialize, 1);
+    tmpattr = gdk_pango_attr_embossed_new(TRUE);
+    rb_define_method(klass, "value", gdkpango_attr_embossed_value, 0);
+    RBPANGO_ADD_ATTRIBUTE(tmpattr->klass->type, klass);
+    pango_attribute_destroy(tmpattr);
+
+    klass = rb_define_class_under(mGdk, "PangoAttrStipple", pattr);
+    rb_define_method(klass, "initialize", gdkpango_attr_stipple_initialize, 1);
+    rb_define_method(klass, "value", gdkpango_attr_stipple_value, 0);
+    tmpattr = gdk_pango_attr_stipple_new(NULL);
+    RBPANGO_ADD_ATTRIBUTE(tmpattr->klass->type, klass);
+    pango_attribute_destroy(tmpattr);
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+    klass = rb_define_class_under(mGdk, "PangoAttrEmbossColor", pattr_color);
+    rb_define_method(klass, "initialize",
+		     gdkpango_attr_emboss_color_initialize, 1);
+    rb_define_method(klass, "value", gdkpango_attr_emboss_color_value, 0);
+    tmpattr = gdk_pango_attr_emboss_color_new(&color);
+    RBPANGO_ADD_ATTRIBUTE(tmpattr->klass->type, klass);
+    pango_attribute_destroy(tmpattr);
+#endif
+}

data/src/rbgdkpangorenderer.c

@@ -0,0 +1,132 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkpangorenderer.c -
+
+  $Author: mutoh $
+  $Date: 2005/02/12 16:03:46 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,6,0)
+
+#define _SELF(s) (GDK_PANGO_RENDERER(RVAL2GOBJ(s)))
+
+static VALUE
+prenderer_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE screen;
+    GdkScreen* gscreen;
+
+    rb_scan_args(argc, argv, "01", &screen);
+
+    if (NIL_P(screen)){
+        gscreen = gdk_screen_get_default();
+    } else {
+        gscreen = GDK_SCREEN(RVAL2GOBJ(screen));
+    }
+
+    G_INITIALIZE(self, gdk_pango_renderer_new(gscreen));
+
+    return Qnil;
+}
+
+static VALUE
+prenderer_s_get_default(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE screen;
+    GdkScreen* gscreen;
+
+    rb_scan_args(argc, argv, "01", &screen);
+
+    if (NIL_P(screen)){
+        gscreen = gdk_screen_get_default();
+    } else {
+        gscreen = GDK_SCREEN(RVAL2GOBJ(screen));
+    }
+    return GOBJ2RVAL(gdk_pango_renderer_get_default(gscreen));
+}
+
+static VALUE
+prenderer_s_default(self)
+    VALUE self;
+{
+    GdkScreen* gscreen = gdk_screen_get_default();
+    return GOBJ2RVAL(gdk_pango_renderer_get_default(gscreen));
+}
+
+static VALUE
+prenderer_set_drawable(self, drawable)
+    VALUE self, drawable;
+{
+    gdk_pango_renderer_set_drawable(_SELF(self), 
+                                    GDK_DRAWABLE(RVAL2GOBJ(drawable)));
+    return self;
+}
+
+static VALUE
+prenderer_set_gc(self, gc)
+    VALUE self, gc;
+{
+    gdk_pango_renderer_set_gc(_SELF(self), 
+                              NIL_P(gc) ? NULL : GDK_GC(RVAL2GOBJ(gc)));
+    return self;
+}
+
+static VALUE
+prenderer_set_stipple(self, part, stipple)
+    VALUE self, part, stipple;
+{
+#if HAVE_PANGO_RENDER_PART_GET_TYPE
+    gdk_pango_renderer_set_stipple(_SELF(self), RVAL2GENUM(part, PANGO_TYPE_RENDER_PART),
+                                   NIL_P(stipple) ? NULL : GDK_BITMAP(RVAL2GOBJ(stipple)));
+#else
+      rb_warning("Gdk::PangoRender#set_tipple is not supported (Require pango-1.8.1 or later");
+#endif
+    return self;
+}
+
+static VALUE
+prenderer_set_override_color(self, part, color)
+    VALUE self, part, color;
+{
+#if HAVE_PANGO_RENDER_PART_GET_TYPE
+    gdk_pango_renderer_set_override_color(_SELF(self), 
+                                          RVAL2GENUM(part, PANGO_TYPE_RENDER_PART),
+                                          RVAL2GDKCOLOR(color));
+#else
+      rb_warning("Gdk::PangoRender#set_override_color is not supported (Require pango-1.8.1 or later");
+#endif
+    return self;
+}
+#endif
+
+void
+Init_gtk_gdk_pangorenderer()
+{
+#if GTK_CHECK_VERSION(2,6,0)
+    VALUE renderer = G_DEF_CLASS(GDK_TYPE_PANGO_RENDERER, "PangoRenderer", mGdk);
+
+    rb_define_method(renderer, "initialize", prenderer_initialize, -1);
+    rb_define_method(renderer, "set_drawable", prenderer_set_drawable, 1);
+    rb_define_method(renderer, "set_gc", prenderer_set_gc, 1);
+    rb_define_method(renderer, "set_stipple", prenderer_set_stipple, 2);
+    rb_define_method(renderer, "set_override_color", prenderer_set_override_color, 2);
+
+    rb_define_singleton_method(renderer, "get_default", prenderer_s_get_default, -1);
+    rb_define_singleton_method(renderer, "default", prenderer_s_default, 0);
+
+    G_DEF_SETTERS(renderer);
+#endif
+}
+
+

data/src/rbgdkpixbuf.c

@@ -0,0 +1,178 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkpixbuf.c -
+
+  $Author: ktou $
+  $Date: 2006/10/14 04:59:14 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) GDK_PIXBUF(RVAL2GOBJ(s)) 
+
+static VALUE
+pixbuf_render_threshold_alpha(self, bitmap, src_x, src_y, dest_x, dest_y,
+                              width, height, alpha_threshold)
+    VALUE self, bitmap, src_x, src_y, dest_x, dest_y,
+    width, height, alpha_threshold;
+{
+    gdk_pixbuf_render_threshold_alpha(_SELF(self), GDK_BITMAP(RVAL2GOBJ(bitmap)),
+                                      NUM2INT(src_x), NUM2INT(src_y),
+                                      NUM2INT(dest_x), NUM2INT(dest_y),
+                                      NUM2INT(width), NUM2INT(height),
+                                      NUM2INT(alpha_threshold));
+    return self;
+}
+
+static VALUE
+pixbuf_render_to_drawable(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE gc, src_x, src_y, dest_x, dest_y, width, height,
+        dither, x_dither, y_dither;
+
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_warn("Gdk::Pixbuf#render_to_drawable is obsolete. Use Gdk::Drawable#draw_pixbuf instead.");
+#endif
+
+    rb_scan_args(argc, argv, "73", &gc, &src_x, &src_y, &dest_x, &dest_y,
+                 &width, &height, &dither, &x_dither, &y_dither);
+
+    if (NIL_P(gc))
+        rb_raise(rb_eArgError, "arguments 1 must be non nil");
+    if (NIL_P(src_x))
+        rb_raise(rb_eArgError, "arguments 2 must be non nil");
+    if (NIL_P(src_y))
+        rb_raise(rb_eArgError, "arguments 3 must be non nil");
+    if (NIL_P(dest_x))
+        rb_raise(rb_eArgError, "arguments 4 must be non nil");
+    if (NIL_P(dest_y))
+        rb_raise(rb_eArgError, "arguments 5 must be non nil");
+    if (NIL_P(width))
+        rb_raise(rb_eArgError, "arguments 6 must be non nil");
+    if (NIL_P(height))
+        rb_raise(rb_eArgError, "arguments 7 must be non nil");
+
+    gdk_pixbuf_render_to_drawable(_SELF(self),
+				  GDK_DRAWABLE(RVAL2GOBJ(self)),
+				  GDK_GC(RVAL2GOBJ(gc)),
+				  NUM2INT(src_x), NUM2INT(src_y),
+                                  NUM2INT(dest_x), NUM2INT(dest_y),
+                                  NUM2INT(width), NUM2INT(height),
+                                  NIL_P(dither) ? GDK_RGB_DITHER_NONE : RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                                  NIL_P(x_dither) ? 0 : NUM2INT(x_dither), 
+                                  NIL_P(y_dither) ? 0 : NUM2INT(y_dither));
+    return self;
+}
+
+static VALUE
+pixbuf_render_pixmap_and_mask(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE colormap_or_alpha, alpha;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+
+    rb_scan_args(argc, argv, "11", &colormap_or_alpha, &alpha);
+
+    if (rb_obj_is_kind_of(colormap_or_alpha, GTYPE2CLASS(GDK_TYPE_COLORMAP))){
+        gdk_pixbuf_render_pixmap_and_mask_for_colormap(_SELF(self),
+                                                       RVAL2GOBJ(colormap_or_alpha),
+                                                       &pixmap,
+                                                       &mask,
+                                                       NIL_P(alpha)?0:NUM2INT(alpha));
+    } else {
+        gdk_pixbuf_render_pixmap_and_mask(_SELF(self),
+                                          &pixmap,
+                                          &mask,
+                                          NIL_P(colormap_or_alpha)?
+                                          0:NUM2INT(colormap_or_alpha));
+    }
+
+    return rb_ary_new3(2,
+                       pixmap ? GOBJ2RVAL(pixmap) : Qnil,
+                       mask ? GOBJ2RVAL(mask) : Qnil);
+}
+
+static VALUE
+pixbuf_s_from_drawable(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE cmap, src, src_x, src_y, width, height, dest, dest_x, dest_y;
+    GdkPixbuf* buf;
+
+    rb_scan_args(argc, argv, "63", &cmap, &src, &src_x, &src_y, &width, &height, 
+                 &dest, &dest_x, &dest_y);
+
+    buf = gdk_pixbuf_get_from_drawable(GDK_PIXBUF(RVAL2GOBJ(dest)),
+                                       GDK_DRAWABLE(RVAL2GOBJ(src)),
+                                       GDK_COLORMAP(RVAL2GOBJ(cmap)),
+                                       NUM2INT(src_x), NUM2INT(src_y),
+                                       NIL_P(dest_x) ? 0 : NUM2INT(dest_x),
+                                       NIL_P(dest_y) ? 0 : NUM2INT(dest_y),
+                                       NUM2INT(width), NUM2INT(height));
+    if (NIL_P(dest)) {
+        if (buf) {
+            return GOBJ2RVALU(buf);
+        } else {
+            return Qnil;
+        }
+    } else {
+        return dest;
+    }
+}
+ 
+static VALUE
+pixbuf_s_from_image(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE cmap, src, src_x, src_y, width, height, dest, dest_x, dest_y;
+    GdkPixbuf* buf;
+
+    rb_scan_args(argc, argv, "63", &cmap, &src, &src_x, &src_y, &width, &height, 
+                 &dest, &dest_x, &dest_y);
+
+    buf = gdk_pixbuf_get_from_image(GDK_PIXBUF(RVAL2GOBJ(dest)),
+                                    GDK_IMAGE(RVAL2GOBJ(src)),
+                                    GDK_COLORMAP(RVAL2GOBJ(cmap)),
+                                    NUM2INT(src_x), NUM2INT(src_y),
+                                    NIL_P(dest_x) ? 0 : NUM2INT(dest_x),
+                                    NIL_P(dest_y) ? 0 : NUM2INT(dest_y),
+                                    NUM2INT(width), NUM2INT(height));
+    if (NIL_P(dest)) {
+        if (buf) {
+            return GOBJ2RVAL(buf);
+        } else {
+            return Qnil;
+        }
+    } else {
+        return dest;
+    }
+}
+
+void
+Init_gtk_gdk_pixbuf()
+{
+    /*
+     *  This defines Gdk::Pixbuf methods of GDK side.
+     */
+    VALUE gdkPixbuf = GTYPE2CLASS(GDK_TYPE_PIXBUF);
+
+    rb_define_method(gdkPixbuf, "render_threshold_alpha", pixbuf_render_threshold_alpha, 8);
+    rb_define_method(gdkPixbuf, "render_to_drawable", pixbuf_render_to_drawable, -1);
+    rb_define_method(gdkPixbuf, "render_pixmap_and_mask", pixbuf_render_pixmap_and_mask, -1);
+
+    rb_define_singleton_method(gdkPixbuf, "from_drawable", pixbuf_s_from_drawable, -1);
+    rb_define_singleton_method(gdkPixbuf, "from_image", pixbuf_s_from_image, -1);
+}