gdk3 1.2.0

data/ext/gdk3/rbgdkpango.c

@@ -0,0 +1,197 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003,2004 Masao Mutoh
+ *
+ *  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 "rbgdk3private.h"
+#include "rbpango.h"
+
+#define RG_TARGET_NAMESPACE mPango
+
+static VALUE
+rg_s_context(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE screen, ret;
+    rb_scan_args(argc, argv, "01", &screen);
+    if (NIL_P(screen)){
+        ret = GOBJ2RVAL(gdk_pango_context_get());
+    } else {
+        ret = GOBJ2RVAL(gdk_pango_context_get_for_screen(RVAL2GDKSCREEN(screen)));
+    }
+    return ret;
+}
+
+/* deprecated
+static VALUE
+gdkpango_context_set_colormap(VALUE self, VALUE colormap)
+{
+    gdk_pango_context_set_colormap(RVAL2PANGOCONTEXT(self),
+                                   RVAL2GDKCOLORMAP(colormap));
+    return self;
+}
+
+static VALUE
+gdkpango_attr_embossed_initialize(VALUE self, VALUE embossed)
+{
+    DATA_PTR(self) = gdk_pango_attr_embossed_new(RVAL2CBOOL(embossed));
+    return Qnil;
+}
+
+static VALUE
+gdkpango_attr_embossed_value(VALUE self)
+{
+    return CBOOL2RVAL(((GdkPangoAttrEmbossed*)RVAL2ATTR(self))->embossed);
+}
+*/
+
+/* deprecated
+static VALUE
+gdkpango_attr_stipple_initialize(VALUE self, VALUE stipple)
+{
+    DATA_PTR(self) = gdk_pango_attr_stipple_new(RVAL2GDKBITMAP(stipple));
+    return Qnil;
+}
+
+static VALUE
+gdkpango_attr_stipple_value(VALUE self)
+{
+    return GOBJ2RVAL(((GdkPangoAttrStipple*)RVAL2ATTR(self))->stipple);
+}
+*/
+
+static VALUE
+gdkpango_layout_get_clip_region(VALUE self, VALUE rbx_origin, VALUE rby_origin, VALUE rbindex_ranges)
+{
+    PangoLayout *layout = RVAL2PANGOLAYOUT(self);
+    gint x_origin = NUM2INT(rbx_origin);
+    gint y_origin = NUM2INT(rby_origin);
+    long n;
+    gint *index_ranges = RVAL2GINTS(rbindex_ranges, n);
+    cairo_region_t *result;
+
+    if (n % 2 != 0) {
+        g_free(index_ranges);
+
+        rb_raise(rb_eArgError,
+                 "an even number of byte indexes must be given");
+    }
+
+    result = gdk_pango_layout_get_clip_region(layout, x_origin, y_origin, index_ranges, n / 2);
+
+    g_free(index_ranges);
+
+    return CRREGION2RVAL(result);
+}
+
+static VALUE
+gdkpango_layout_line_get_clip_region(VALUE self, VALUE rbx_origin, VALUE rby_origin, VALUE rbindex_ranges)
+{
+    PangoLayoutLine *line = RVAL2PANGOLAYOUTLINE(self);
+    gint x_origin = NUM2INT(rbx_origin);
+    gint y_origin = NUM2INT(rby_origin);
+    long n;
+    gint *index_ranges = RVAL2GINTS(rbindex_ranges, n);
+    cairo_region_t *result;
+
+    if (n % 2 != 0) {
+        g_free(index_ranges);
+
+        rb_raise(rb_eArgError,
+                 "an even number of byte indexes must be given");
+    }
+
+    result = gdk_pango_layout_line_get_clip_region(line, x_origin, y_origin, index_ranges, n / 2);
+
+    g_free(index_ranges);
+
+    return CRREGION2RVAL(result);
+}
+
+/* deprecated
+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 PANGOCOLOR2RVAL(&(((GdkPangoAttrEmbossColor *)RVAL2ATTR(self))->color));
+}
+*/
+
+void
+Init_gdk_pango(VALUE mGdk)
+{
+/* deprecated
+    VALUE klass;
+    PangoAttribute* tmpattr;
+    GdkColor color;
+*/
+
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Pango");
+/* deprecated
+    VALUE context = GTYPE2CLASS(PANGO_TYPE_CONTEXT);
+*/
+    VALUE layout = GTYPE2CLASS(PANGO_TYPE_LAYOUT);
+    VALUE layoutline = GTYPE2CLASS(PANGO_TYPE_LAYOUT_LINE);
+/* deprecated
+    VALUE pattr = ATTRTYPE2CLASS(CSTR2RVAL("Attribute"));
+    VALUE pattrbool = ATTRTYPE2CLASS(CSTR2RVAL("AttrBool"));
+    VALUE pattr_color = ATTRTYPE2CLASS(CSTR2RVAL("AttrColor"));
+*/
+
+    RG_DEF_SMETHOD(context, -1);
+
+/* deprecated
+    rbg_define_method(context, "set_colormap", gdkpango_context_set_colormap, 1);
+*/
+    rbg_define_method(layout, "get_clip_region", gdkpango_layout_get_clip_region, 3);
+    rbg_define_method(layoutline, "get_clip_region", gdkpango_layout_line_get_clip_region, 3);
+
+/* deprecated
+    klass = rb_define_class_under(mGdk, "PangoAttrEmbossed", pattrbool);
+    rbg_define_method(klass, "initialize", gdkpango_attr_embossed_initialize, 1);
+    tmpattr = gdk_pango_attr_embossed_new(TRUE);
+    rbg_define_method(klass, "value", gdkpango_attr_embossed_value, 0);
+    RBPANGO_ADD_ATTRIBUTE(tmpattr->klass->type, klass);
+    pango_attribute_destroy(tmpattr);
+*/
+
+/* deprecated
+    klass = rb_define_class_under(mGdk, "PangoAttrStipple", pattr);
+    rbg_define_method(klass, "initialize", gdkpango_attr_stipple_initialize, 1);
+    rbg_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);
+*/
+
+/* deprecated
+    klass = rb_define_class_under(mGdk, "PangoAttrEmbossColor", pattr_color);
+    rbg_define_method(klass, "initialize",
+                     gdkpango_attr_emboss_color_initialize, 1);
+    rbg_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);
+*/
+}

data/ext/gdk3/rbgdkpangorenderer.c

@@ -0,0 +1,144 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2005  Masao Mutoh
+ *
+ *  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
+ */
+
+/* deprecated
+#include "rbgdk3private.h"
+
+#define RG_TARGET_NAMESPACE cPangoRenderer
+#define _SELF(s) (RVAL2GDKPANGORENDERER(s))
+
+static VALUE
+rg_initialize(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 = RVAL2GDKSCREEN(screen);
+    }
+
+    G_INITIALIZE(self, gdk_pango_renderer_new(gscreen));
+
+    return Qnil;
+}
+
+static VALUE
+rg_s_get_default(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE screen;
+    GdkScreen* gscreen;
+
+    rb_scan_args(argc, argv, "01", &screen);
+
+    if (NIL_P(screen)){
+        gscreen = gdk_screen_get_default();
+    } else {
+        gscreen = RVAL2GDKSCREEN(screen);
+    }
+    return GOBJ2RVAL(gdk_pango_renderer_get_default(gscreen));
+}
+
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE self)
+{
+    GdkScreen* gscreen = gdk_screen_get_default();
+    return GOBJ2RVAL(gdk_pango_renderer_get_default(gscreen));
+}
+
+static VALUE
+rg_set_drawable(VALUE self, VALUE drawable)
+{
+    gdk_pango_renderer_set_drawable(_SELF(self), 
+                                    RVAL2GDKDRAWABLE(drawable));
+    return self;
+}
+
+static VALUE
+rg_set_gc(VALUE self, VALUE gc)
+{
+    gdk_pango_renderer_set_gc(_SELF(self), 
+                              NIL_P(gc) ? NULL : RVAL2GDKGC(gc));
+    return self;
+}
+
+#ifdef HAVE_PANGO_RENDER_PART_GET_TYPE
+static VALUE
+rg_set_stipple(VALUE self, VALUE part, VALUE stipple)
+{
+    gdk_pango_renderer_set_stipple(_SELF(self), RVAL2PANGORENDERPART(part),
+                                   NIL_P(stipple) ? NULL : RVAL2GDKBITMAP(stipple));
+
+    return self;
+}
+#else
+static VALUE
+prenderer_set_stipple(G_GNUC_UNUSED VALUE self,
+                      G_GNUC_UNUSED VALUE part,
+                      G_GNUC_UNUSED VALUE stipple)
+{
+    rb_warning("Gdk::PangoRender#set_tipple is not supported (Require pango-1.8.1 or later");
+
+    return self;
+}
+#endif
+
+#ifdef HAVE_PANGO_RENDER_PART_GET_TYPE
+static VALUE
+rg_set_override_color(VALUE self, VALUE part, VALUE color)
+{
+    gdk_pango_renderer_set_override_color(_SELF(self),
+                                          RVAL2PANGORENDERPART(part),
+                                          RVAL2GDKCOLOR(color));
+
+    return self;
+}
+#else
+static VALUE
+prenderer_set_override_color(G_GNUC_UNUSED VALUE self,
+                             G_GNUC_UNUSED VALUE part,
+                             G_GNUC_UNUSED VALUE color)
+{
+    rb_warning("Gdk::PangoRender#set_override_color is not supported (Require pango-1.8.1 or later");
+
+    return self;
+}
+#endif
+
+void
+Init_gdk_pangorenderer(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PANGO_RENDERER, "PangoRenderer", mGdk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(set_drawable, 1);
+    RG_DEF_METHOD(set_gc, 1);
+    RG_DEF_METHOD(set_stipple, 2);
+    RG_DEF_METHOD(set_override_color, 2);
+
+    RG_DEF_SMETHOD(get_default, -1);
+    RG_DEF_SMETHOD(default, 0);
+}
+*/
+

data/ext/gdk3/rbgdkpixbuf.c

@@ -0,0 +1,176 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Masao Mutoh
+ *
+ *  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 "rbgdk3private.h"
+
+#define RG_TARGET_NAMESPACE cPixbuf
+#define _SELF(s) RVAL2GDKPIXBUF(s) 
+
+/* deprecated
+static VALUE
+rg_render_threshold_alpha(VALUE self, VALUE bitmap, VALUE src_x, VALUE src_y, VALUE dest_x, VALUE dest_y, VALUE width, VALUE height, VALUE alpha_threshold)
+{
+    gdk_pixbuf_render_threshold_alpha(_SELF(self), RVAL2GDKBITMAP(bitmap),
+                                      NUM2INT(src_x), NUM2INT(src_y),
+                                      NUM2INT(dest_x), NUM2INT(dest_y),
+                                      NUM2INT(width), NUM2INT(height),
+                                      NUM2INT(alpha_threshold));
+    return self;
+}
+
+static VALUE
+rg_render_to_drawable(int argc, VALUE *argv, VALUE self)
+{
+    VALUE gc, src_x, src_y, dest_x, dest_y, width, height,
+        dither, x_dither, y_dither;
+
+    rb_warn("Gdk::Pixbuf#render_to_drawable is obsolete. Use Gdk::Drawable#draw_pixbuf instead.");
+
+    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),
+                                  RVAL2GDKDRAWABLE(self),
+                                  RVAL2GDKGC(gc),
+                                  NUM2INT(src_x), NUM2INT(src_y),
+                                  NUM2INT(dest_x), NUM2INT(dest_y),
+                                  NUM2INT(width), NUM2INT(height),
+                                  NIL_P(dither) ? GDK_RGB_DITHER_NONE : RVAL2GDKRGBDITHER(dither),
+                                  NIL_P(x_dither) ? 0 : NUM2INT(x_dither), 
+                                  NIL_P(y_dither) ? 0 : NUM2INT(y_dither));
+    return self;
+}
+
+static VALUE
+rg_render_pixmap_and_mask(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
+rg_s_from_drawable(int argc, VALUE *argv, G_GNUC_UNUSED 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(RVAL2GDKPIXBUF(dest),
+                                       RVAL2GDKDRAWABLE(src),
+                                       RVAL2GDKCOLORMAP(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
+rg_s_from_image(int argc, VALUE *argv, G_GNUC_UNUSED 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(RVAL2GDKPIXBUF(dest),
+                                    RVAL2GDKIMAGE(src),
+                                    RVAL2GDKCOLORMAP(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_gdk_pixbuf(VALUE mGdk)
+{
+    /*
+     *  This defines Gdk::Pixbuf methods of GDK side.
+     */
+    VALUE RG_TARGET_NAMESPACE = GTYPE2CLASS(GDK_TYPE_PIXBUF);
+
+/* deprecated
+    RG_DEF_METHOD(render_threshold_alpha, 8);
+    RG_DEF_METHOD(render_to_drawable, -1);
+    RG_DEF_METHOD(render_pixmap_and_mask, -1);
+
+    RG_DEF_SMETHOD(from_drawable, -1);
+    RG_DEF_SMETHOD(from_image, -1);
+*/
+}