gtk2 0.20.0

data/src/rbgdkrectangle.c

@@ -0,0 +1,146 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkrectangle.c -
+
+  $Author: mutoh $
+  $Date: 2003/01/12 18:09:10 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+
+  This file is derived from rbgdkregion.c.
+  rbgdkregion.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(r) ((GdkRectangle*)RVAL2BOXED(r, GDK_TYPE_RECTANGLE))
+
+static VALUE
+gdkrect_initialize(self, x, y, width, height)
+    VALUE self, x, y, width, height;
+{
+    GdkRectangle new;
+
+    new.x = NUM2INT(x);
+    new.y = NUM2INT(y);
+    new.width = NUM2INT(width);
+    new.height = NUM2INT(height);
+
+    G_INITIALIZE(self, &new);
+    return Qnil;
+}
+
+static VALUE
+gdkrect_intersect(self, other)
+    VALUE self, other;
+{
+    GdkRectangle dest;
+    gboolean ret = gdk_rectangle_intersect(_SELF(self), _SELF(other), &dest);
+    return ret ? BOXED2RVAL(&dest, GDK_TYPE_RECTANGLE) : Qnil;
+}
+
+static VALUE
+gdkrect_union(self, other)
+    VALUE self, other;
+{
+    GdkRectangle dest;
+    gdk_rectangle_union(_SELF(self), _SELF(other), &dest);
+    return BOXED2RVAL(&dest, GDK_TYPE_RECTANGLE);
+}
+
+/* Struct accessors */
+static VALUE
+gdkrect_x(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->x);
+}
+
+static VALUE
+gdkrect_y(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->y);
+}
+
+static VALUE
+gdkrect_w(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->width);
+}
+
+static VALUE
+gdkrect_h(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->height);
+}
+
+static VALUE
+gdkrect_set_x(self, x)
+    VALUE self, x;
+{
+    _SELF(self)->x = NUM2INT(x);
+    return self;
+}
+
+static VALUE
+gdkrect_set_y(self, y)
+    VALUE self, y;
+{
+    _SELF(self)->y = NUM2INT(y);
+    return self;
+}
+
+static VALUE
+gdkrect_set_w(self, width)
+    VALUE self, width;
+{
+    _SELF(self)->width = NUM2INT(width);
+    return self;
+}
+
+static VALUE
+gdkrect_set_h(self, height)
+    VALUE self, height;
+{
+    _SELF(self)->height = NUM2INT(height);
+    return self;
+}
+
+static VALUE
+gdkrect_to_a(self)
+    VALUE self;
+{
+  GdkRectangle* a = _SELF(self);
+  return rb_ary_new3(4, INT2FIX(a->x), INT2FIX(a->y),
+                     INT2FIX(a->width), INT2FIX(a->height));
+}
+
+void
+Init_gtk_gdk_rectangle()
+{
+    VALUE gdkRectangle = G_DEF_CLASS(GDK_TYPE_RECTANGLE, "Rectangle", mGdk);
+
+    rb_define_method(gdkRectangle, "initialize", gdkrect_initialize, 4);
+    rb_define_method(gdkRectangle, "intersect", gdkrect_intersect, 1);
+    rb_define_alias(gdkRectangle, "&", "intersect");
+    rb_define_method(gdkRectangle, "union", gdkrect_union, 1);
+    rb_define_alias(gdkRectangle, "|", "union");
+    rb_define_method(gdkRectangle, "x", gdkrect_x, 0);
+    rb_define_method(gdkRectangle, "y", gdkrect_y, 0);
+    rb_define_method(gdkRectangle, "width", gdkrect_w, 0);
+    rb_define_method(gdkRectangle, "height", gdkrect_h, 0);
+    rb_define_method(gdkRectangle, "set_x", gdkrect_set_x, 1);
+    rb_define_method(gdkRectangle, "set_y", gdkrect_set_y, 1);
+    rb_define_method(gdkRectangle, "set_width", gdkrect_set_w, 1);
+    rb_define_method(gdkRectangle, "set_height", gdkrect_set_h, 1);
+    rb_define_method(gdkRectangle, "to_a", gdkrect_to_a, 0);
+
+    G_DEF_SETTERS(gdkRectangle);
+}

data/src/rbgdkregion.c

@@ -0,0 +1,242 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkregion.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+#include "global.h"
+
+#define _SELF(r) ((GdkRegion*)RVAL2BOXED(r, GDK_TYPE_REGION))
+
+/**********************************/
+GType
+gdk_region_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("GdkRegion",
+                    (GBoxedCopyFunc)gdk_region_copy,
+                    (GBoxedFreeFunc)gdk_region_destroy);
+    return our_type;
+}
+/**********************************/
+static VALUE
+gdkregion_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE points_or_rectangle, fill_rule;
+    GdkRegion* region;
+    GdkPoint *gpoints;
+    int i;
+
+    rb_scan_args(argc, argv, "02", &points_or_rectangle, &fill_rule);
+    if (NIL_P(points_or_rectangle)){
+        region = gdk_region_new();
+    } else if (TYPE(points_or_rectangle) == T_ARRAY){
+        gpoints = ALLOCA_N(GdkPoint, RARRAY_LEN(points_or_rectangle));
+
+        for (i = 0; i < RARRAY_LEN(points_or_rectangle); i++) {
+            Check_Type(RARRAY_PTR(points_or_rectangle)[i], T_ARRAY);
+            if (RARRAY_LEN(RARRAY_PTR(points_or_rectangle)[i]) < 2) {
+                rb_raise(rb_eArgError, "point %d should be array of size 2", i);
+            }
+            gpoints[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[0]);
+            gpoints[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[1]);
+        }
+        region = gdk_region_polygon(gpoints, RARRAY_LEN(points_or_rectangle),
+                                    RVAL2GENUM(fill_rule, GDK_TYPE_FILL_RULE));
+    } else if (RVAL2GTYPE(points_or_rectangle) == GDK_TYPE_RECTANGLE){
+        region = gdk_region_rectangle((GdkRectangle*)RVAL2BOXED(points_or_rectangle, 
+                                                                GDK_TYPE_RECTANGLE));
+    } else {
+        rb_raise(rb_eArgError, 
+                 "invalid argument %s (expect array of Gdk::Point or Gdk::Rectangle, nil)",
+                 rb_class2name(CLASS_OF(points_or_rectangle)));
+    }
+
+    G_INITIALIZE(self, region);
+    return Qnil;
+}
+
+static VALUE
+gdkregion_get_rectangles(self)
+    VALUE self;
+{
+    GdkRectangle* rectangles;
+    gint n_rect, i;
+    VALUE ary;
+
+    gdk_region_get_rectangles(_SELF(self), &rectangles, &n_rect);
+    ary = rb_ary_new2(n_rect);
+    for (i = 0; i < n_rect; i++) {
+        rb_ary_push(ary, BOXED2RVAL(&rectangles[i], GDK_TYPE_RECTANGLE));
+    }
+    g_free(rectangles);
+    return ary;
+}
+
+static void
+gdkregion_span_func(span, func)
+    GdkSpan* span;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 3, 
+               INT2NUM(span->x), INT2NUM(span->y), INT2NUM(span->width));
+}
+
+static VALUE
+gdkregion_spans_intersect_foreach(self, spans, sorted)
+    VALUE self, spans, sorted;
+{
+    int i;
+    GdkSpan* gspans = ALLOCA_N(GdkSpan, RARRAY_LEN(spans));
+    volatile VALUE func = rb_block_proc();
+
+    G_RELATIVE(self, func);
+    for (i = 0; i < RARRAY_LEN(spans); i++) {
+        gspans[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[0]);
+        gspans[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[1]);
+        gspans[i].width = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[2]);
+    }
+    gdk_region_spans_intersect_foreach(_SELF(self),
+                                       gspans, RARRAY_LEN(spans), RVAL2CBOOL(sorted),
+                                       (GdkSpanFunc)gdkregion_span_func, (gpointer)func);
+    return self;
+}
+
+static VALUE
+gdkregion_get_clipbox(self)
+    VALUE self;
+{
+    GdkRectangle rect;
+    gdk_region_get_clipbox(_SELF(self), &rect);
+    return BOXED2RVAL(&rect, GDK_TYPE_RECTANGLE);
+}
+
+static VALUE
+gdkregion_empty(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_region_empty(_SELF(self)));
+}
+
+static VALUE
+gdkregion_equal(self, obj)
+    VALUE self, obj;
+{
+    if (!rb_obj_is_instance_of(obj, GTYPE2CLASS(GDK_TYPE_REGION))) {
+        return Qnil;
+    }
+    return CBOOL2RVAL(gdk_region_equal(_SELF(self), _SELF(obj)));
+}
+
+static VALUE
+gdkregion_point_in(self, x, y)
+    VALUE self, x, y;
+{
+    return CBOOL2RVAL(gdk_region_point_in(_SELF(self), NUM2INT(x),
+                                          NUM2INT(y)));
+}
+
+static VALUE
+gdkregion_rect_in(self, rect)
+    VALUE self, rect;
+{
+    return GENUM2RVAL(gdk_region_rect_in(
+                          _SELF(self),
+                          (GdkRectangle*)RVAL2BOXED(rect, GDK_TYPE_RECTANGLE)),
+                      GDK_TYPE_OVERLAP_TYPE);
+}
+
+static VALUE
+gdkregion_offset(self, dx, dy)
+    VALUE self, dx, dy;
+{
+    gdk_region_offset(_SELF(self), NUM2INT(dx), NUM2INT(dy));
+    return self;
+}
+
+static VALUE
+gdkregion_shrink(self, dx, dy)
+    VALUE self, dx, dy;
+{
+    gdk_region_shrink(_SELF(self), NUM2INT(dx), NUM2INT(dy));
+    return self;
+}
+
+static VALUE
+gdkregion_intersect(self, region)
+    VALUE self, region;
+{
+    gdk_region_intersect(_SELF(self), _SELF(region));
+    return self;
+}
+
+static VALUE
+gdkregion_union(self, other)
+    VALUE self, other;
+{
+    if (RVAL2GTYPE(other) == GDK_TYPE_RECTANGLE){
+        gdk_region_union_with_rect(_SELF(self),
+                                   (GdkRectangle*)RVAL2BOXED(other, GDK_TYPE_RECTANGLE));
+    } else {
+        gdk_region_union(_SELF(self), _SELF(other));
+    }
+    return self;
+}
+
+static VALUE
+gdkregion_subtract(self, region)
+    VALUE self, region;
+{
+    gdk_region_subtract(_SELF(self), _SELF(region));
+    return self;
+}
+
+static VALUE
+gdkregion_xor(self, region)
+    VALUE self, region;
+{
+    gdk_region_xor(_SELF(self), _SELF(region));
+    return self;
+}
+
+
+void
+Init_gtk_gdk_region()
+{
+    VALUE gdkRegion = G_DEF_CLASS(GDK_TYPE_REGION, "Region", mGdk);
+
+    rb_define_method(gdkRegion, "initialize", gdkregion_initialize, -1);
+    rb_define_method(gdkRegion, "rectangles", gdkregion_get_rectangles, 0);
+    rb_define_method(gdkRegion, "spans_intersect_each", gdkregion_spans_intersect_foreach, 2);
+    rb_define_method(gdkRegion, "clipbox", gdkregion_get_clipbox, 0);
+    rb_define_method(gdkRegion, "empty?", gdkregion_empty, 0);
+    rb_define_method(gdkRegion, "==", gdkregion_equal, 1);
+    rb_define_method(gdkRegion, "point_in?", gdkregion_point_in, 2);
+    rb_define_method(gdkRegion, "rect_in", gdkregion_rect_in, 1);
+    rb_define_method(gdkRegion, "offset", gdkregion_offset, 2);
+    rb_define_method(gdkRegion, "shrink", gdkregion_shrink, 2);
+    rb_define_method(gdkRegion, "intersect", gdkregion_intersect, 1);
+    rb_define_method(gdkRegion, "union", gdkregion_union, 1);
+    rb_define_method(gdkRegion, "subtract", gdkregion_subtract, 1);
+    rb_define_method(gdkRegion, "xor", gdkregion_xor, 1);
+
+    /* GdkOverlapType */
+    G_DEF_CLASS(GDK_TYPE_OVERLAP_TYPE, "OverlapType", gdkRegion);
+    G_DEF_CONSTANTS(gdkRegion, GDK_TYPE_OVERLAP_TYPE, "GDK_");
+
+    /* GdkFillRule */
+    G_DEF_CLASS(GDK_TYPE_FILL_RULE, "FillRule", gdkRegion);
+    G_DEF_CONSTANTS(gdkRegion, GDK_TYPE_FILL_RULE, "GDK_");
+}

data/src/rbgdkrgb.c

@@ -0,0 +1,197 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkrgb.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define RVAL2DRAW(s) GDK_DRAWABLE(RVAL2GOBJ(s))
+
+
+static VALUE
+rgb_draw_rgb_image(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE self;
+{
+    VALUE win, gc, x, y, w, h, dither, buf, rowstride, xdith, ydith;
+
+    rb_scan_args(argc, argv, "92", &win, &gc, &x, &y, &w, &h, &dither, 
+                 &buf, &rowstride, &xdith, &ydith);
+
+    if (argc == 9){
+        gdk_draw_rgb_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                           NUM2INT(x), NUM2INT(y),
+                           NUM2INT(w), NUM2INT(h),
+                           RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                           (guchar*)RVAL2CSTR(buf),
+                           NUM2INT(rowstride));
+    } else {
+        gdk_draw_rgb_image_dithalign(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                                     NUM2INT(x), NUM2INT(y),
+                                     NUM2INT(w), NUM2INT(h),
+                                     RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                                     (guchar*)RVAL2CSTR(buf),
+                                     NUM2INT(rowstride),
+                                     NUM2INT(xdith), NUM2INT(ydith));
+    }
+
+    return self;
+}
+
+static VALUE
+rgb_draw_indexed_image(self, win, gc, x, y, w, h, dither, buf, rowstride, colors)
+    VALUE self, win, gc, x, y, w, h, dither, buf, rowstride, colors;
+{
+    GdkRgbCmap* cmap;
+    guint32* gcolors;
+    gint i, n_colors;
+
+    n_colors = RARRAY_LEN(colors);
+
+    if (n_colors > 255)
+        rb_raise(rb_eArgError, "colors: out of range (0 - 255)");
+
+    gcolors = g_new(guint32, n_colors);
+    for (i = 0; i < n_colors; i++) {
+        gcolors[i] = NUM2UINT(RARRAY_PTR(colors)[i]);
+    }
+
+    cmap = gdk_rgb_cmap_new(gcolors, n_colors);
+    
+    gdk_draw_indexed_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                           NUM2INT(x), NUM2INT(y),
+                           NUM2INT(w), NUM2INT(h),
+                           RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                           (guchar*)RVAL2CSTR(buf), 
+                           NUM2INT(rowstride), cmap);
+    gdk_rgb_cmap_free(cmap);
+    return self;
+}
+
+static VALUE
+rgb_draw_gray_image(self, win, gc, x, y, w, h, dither, buf, rowstride)
+    VALUE self, win, gc, x, y, w, h, dither, buf, rowstride;
+{
+    gdk_draw_gray_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                        NUM2INT(x), NUM2INT(y),
+                        NUM2INT(w), NUM2INT(h),
+                        RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                        (guchar*)RVAL2CSTR(buf),
+                        NUM2INT(rowstride));
+    return self;
+}
+
+static VALUE
+rgb_draw_rgb_32_image(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE self;
+{
+    VALUE win, gc, x, y, w, h, dither, buf, rowstride, xdith, ydith;
+
+    rb_scan_args(argc, argv, "92", &win, &gc, &x, &y, &w, &h, &dither, 
+                 &buf, &rowstride, &xdith, &ydith);
+
+    if (argc == 9){
+        gdk_draw_rgb_32_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                              NUM2INT(x), NUM2INT(y),
+                              NUM2INT(w), NUM2INT(h),
+                              RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                              (guchar*)RVAL2CSTR(buf),
+                              NUM2INT(rowstride));
+    } else {
+        gdk_draw_rgb_32_image_dithalign(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
+                                        NUM2INT(x), NUM2INT(y),
+                                        NUM2INT(w), NUM2INT(h),
+                                        RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                                        (guchar*)RVAL2CSTR(buf),
+                                        NUM2INT(rowstride), NUM2INT(xdith), NUM2INT(ydith));
+    }
+    return self;
+}
+
+static VALUE
+rgb_find_color(self, colormap, color)
+    VALUE self, colormap, color;
+{
+    gdk_rgb_find_color(GDK_COLORMAP(RVAL2GOBJ(colormap)),
+                       RVAL2GDKCOLOR(color));
+    return self;
+}
+
+static VALUE
+rgb_set_install(self, install)
+    VALUE self, install;
+{
+    gdk_rgb_set_install(RVAL2CBOOL(install));
+    return self;
+}
+
+static VALUE
+rgb_set_min_colors(self, min_colors)
+    VALUE self, min_colors;
+{
+    gdk_rgb_set_min_colors(NUM2INT(min_colors));
+    return self;
+}
+
+static VALUE
+rgb_get_visual(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_rgb_get_visual());
+}
+
+static VALUE
+rgb_get_cmap(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_rgb_get_colormap());
+}
+
+static VALUE
+rgb_ditherable(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_rgb_ditherable());
+}
+
+static VALUE
+rgb_set_verbose(self, verbose)
+    VALUE self, verbose;
+{
+    gdk_rgb_set_verbose(RVAL2CBOOL(verbose));
+    return self;
+}
+
+void
+Init_gtk_gdk_rgb()
+{
+    VALUE mGdkRgb = rb_define_module_under(mGdk, "RGB");
+
+    rb_define_module_function(mGdkRgb, "draw_rgb_image", rgb_draw_rgb_image, -1);
+    rb_define_module_function(mGdkRgb, "draw_indexed_image", rgb_draw_indexed_image, 10);
+    rb_define_module_function(mGdkRgb, "draw_gray_image", rgb_draw_gray_image, 9);
+    rb_define_module_function(mGdkRgb, "draw_rgb_32_image", rgb_draw_rgb_32_image, -1);
+    rb_define_module_function(mGdkRgb, "find_color", rgb_find_color, 2);
+    rb_define_module_function(mGdkRgb, "set_install", rgb_set_install, 1);
+    rb_define_module_function(mGdkRgb, "set_min_colors", rgb_set_min_colors, 0);
+    rb_define_module_function(mGdkRgb, "visual", rgb_get_visual, 0);
+    rb_define_module_function(mGdkRgb, "colormap", rgb_get_cmap, 0);
+    rb_define_module_function(mGdkRgb, "ditherable?", rgb_ditherable, 0);
+    rb_define_module_function(mGdkRgb, "set_verbose", rgb_set_verbose, 1);
+
+    /* GdkRgbDither */
+    G_DEF_CLASS(GDK_TYPE_RGB_DITHER, "Dither", mGdkRgb);
+    G_DEF_CONSTANTS(mGdkRgb, GDK_TYPE_RGB_DITHER, "GDK_RGB_");
+}