gtk2 2.2.4-x64-mingw32

data/ext/gtk2/rbgdkimage.c

@@ -0,0 +1,152 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "global.h"
+
+#define RG_TARGET_NAMESPACE cImage
+#define _SELF(i) GDK_IMAGE(RVAL2GOBJ(i))
+
+static VALUE
+rg_initialize(VALUE self, VALUE type, VALUE visual, VALUE w, VALUE h)
+{
+    GdkImage* image = gdk_image_new((GdkImageType)RVAL2GENUM(type, GDK_TYPE_IMAGE_TYPE),
+                                    GDK_VISUAL(RVAL2GOBJ(visual)),
+                                    NUM2INT(w), NUM2INT(h));
+
+    if (image)
+        G_INITIALIZE(self, image);
+    else
+        rb_raise(rb_eArgError, "The image could not be created.");
+
+    return Qnil;
+}
+
+static VALUE
+rg_colormap(VALUE self)
+{
+    return GOBJ2RVAL(gdk_image_get_colormap(_SELF(self)));
+}
+
+static VALUE
+rg_set_colormap(VALUE self, VALUE colormap)
+{
+    gdk_image_set_colormap(_SELF(self), RVAL2GOBJ(colormap));
+    return self;
+}
+
+static VALUE
+rg_put_pixel(VALUE self, VALUE x, VALUE y, VALUE pix)
+{
+    gdk_image_put_pixel(_SELF(self),
+                        NUM2INT(x), NUM2INT(y), NUM2INT(pix));
+    return self;
+}
+
+static VALUE
+rg_get_pixel(VALUE self, VALUE x, VALUE y)
+{
+    return INT2NUM(gdk_image_get_pixel(_SELF(self),
+                                       NUM2INT(x), NUM2INT(y)));
+}
+
+static VALUE
+rg_image_type(VALUE self)
+{
+    return GENUM2RVAL((_SELF(self))->type, GDK_TYPE_IMAGE_TYPE);
+}
+
+static VALUE
+rg_visual(VALUE self)
+{
+    return GOBJ2RVAL((_SELF(self))->visual);
+}
+
+static VALUE
+rg_byte_order(VALUE self)
+{
+    return GENUM2RVAL((_SELF(self))->byte_order, GDK_TYPE_BYTE_ORDER);
+}
+
+static VALUE
+rg_bits_per_pixel(VALUE self)
+{
+    return INT2NUM((_SELF(self))->bits_per_pixel);
+}
+
+static VALUE
+rg_width(VALUE self)
+{
+    return INT2NUM((_SELF(self))->width);
+}
+
+static VALUE
+rg_height(VALUE self)
+{
+    return INT2NUM((_SELF(self))->height);
+}
+
+static VALUE
+rg_depth(VALUE self)
+{
+    return INT2NUM((_SELF(self))->depth);
+}
+
+static VALUE
+rg_bpp(VALUE self)
+{
+    return INT2NUM((_SELF(self))->bpp);
+}
+
+static VALUE
+rg_bpl(VALUE self)
+{
+    return INT2NUM((_SELF(self))->bpl);
+}
+
+void 
+Init_gtk_gdk_image(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_IMAGE, "Image", mGdk);
+
+    RG_DEF_METHOD(initialize, 4);
+    RG_DEF_METHOD(colormap, 0);
+    RG_DEF_METHOD(set_colormap, 1);
+    RG_DEF_METHOD(put_pixel, 3);
+    RG_DEF_METHOD(get_pixel, 2);
+    RG_DEF_METHOD(image_type, 0);
+    RG_DEF_METHOD(visual, 0);
+    RG_DEF_METHOD(byte_order, 0);
+    RG_DEF_METHOD(bits_per_pixel, 0);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(depth, 0);
+    RG_DEF_METHOD(bpp, 0);
+    RG_DEF_METHOD(bpl, 0);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+
+    /* GdkImageType */
+    G_DEF_CLASS(GDK_TYPE_IMAGE_TYPE, "Type", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_IMAGE_TYPE, "GDK_IMAGE_");
+}

data/ext/gtk2/rbgdkinput.c

@@ -0,0 +1,72 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Masao Mutoh
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "global.h"
+
+#define RG_TARGET_NAMESPACE mInput
+
+static void
+exec_input(gpointer data, G_GNUC_UNUSED gint source, GdkInputCondition condition)
+{
+    rb_funcall((VALUE)data, id_call, 1, 
+               GFLAGS2RVAL(condition, GDK_TYPE_INPUT_CONDITION));
+}
+
+static VALUE
+rg_m_add(VALUE self, VALUE filedescriptor, VALUE gdk_input_condition)
+{
+    VALUE id;
+    VALUE func;
+
+    func = rb_block_proc();
+    id = INT2FIX(gdk_input_add(NUM2INT(rb_funcall(filedescriptor,
+                                                  rb_intern("to_i"), 0)),
+                               RVAL2GFLAGS(gdk_input_condition, GDK_TYPE_INPUT_CONDITION),
+                               (GdkInputFunction)exec_input,
+                               (gpointer)func));
+    G_RELATIVE2(self, func, id_relative_callbacks, id);
+    return id;
+}
+
+static VALUE
+rg_m_remove(VALUE self, VALUE id)
+{
+    gdk_input_remove(NUM2INT(id));
+    G_REMOVE_RELATIVE(self, id_relative_callbacks, id);
+    return id;
+}
+
+void
+Init_gtk_gdk_input(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Input");
+
+    RG_DEF_MODFUNC(add, 2);
+    RG_DEF_MODFUNC(remove, 1);
+
+    /* GdkInputCondition */
+    G_DEF_CLASS(GDK_TYPE_INPUT_CONDITION, "Condition", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_INPUT_CONDITION, "GDK_INPUT_");
+
+}

data/ext/gtk2/rbgdkkeymap.c

@@ -0,0 +1,155 @@
+/* -*- 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 "global.h"
+
+#define RG_TARGET_NAMESPACE cKeymap
+#define _SELF(s) GDK_KEYMAP(RVAL2GOBJ(s))
+
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE self)
+{
+  return GOBJ2RVAL(gdk_keymap_get_default());
+}
+
+static VALUE
+rg_s_for_display(G_GNUC_UNUSED VALUE self, VALUE display)
+{
+  return GOBJ2RVAL(gdk_keymap_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display))));
+}
+
+static VALUE
+rg_lookup_key(VALUE self, VALUE keycode, VALUE group, VALUE level)
+{
+  GdkKeymapKey key;
+
+  key.keycode = NUM2UINT(keycode);
+  key.group = NUM2INT(group);
+  key.level = NUM2INT(level);
+
+  return INT2NUM(gdk_keymap_lookup_key(_SELF(self), &key));
+}
+
+static VALUE
+rg_translate_keyboard_state(VALUE self, VALUE hardware_keycode, VALUE state, VALUE group)
+{
+  guint keyval;
+  gint effective_group, level;
+  GdkModifierType consumed_modifiers;
+  gboolean ret;
+
+  ret = gdk_keymap_translate_keyboard_state(_SELF(self),
+                                            NUM2UINT(hardware_keycode),
+                                            RVAL2GFLAGS(state, GDK_TYPE_MODIFIER_TYPE),
+                                            NUM2INT(group),
+                                            &keyval, &effective_group,
+                                            &level, &consumed_modifiers);
+  return ret ? rb_ary_new3(4, UINT2NUM(keyval), INT2NUM(effective_group),
+                           INT2NUM(level), 
+                           GFLAGS2RVAL(consumed_modifiers, GDK_TYPE_MODIFIER_TYPE)) : Qnil;
+}
+
+static VALUE
+rg_get_entries_for_keyval(VALUE self, VALUE keyval)
+{
+  GdkKeymapKey* keys;
+  gint n_keys;
+  gboolean ret;
+  ret = gdk_keymap_get_entries_for_keyval(_SELF(self),
+                                          NUM2UINT(keyval), &keys, &n_keys);
+
+  if (ret){
+    VALUE key;
+    VALUE ary = rb_ary_new();
+    gint i;
+    for (i = 0; i < n_keys; i++){
+      key = rb_ary_new3(3, UINT2NUM(keys[i].keycode), INT2NUM(keys[i].group), 
+                        INT2NUM(keys[i].level));
+      rb_ary_push(ary, key);
+    }
+    g_free(keys);
+    return ary;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE
+rg_get_entries_for_keycode(VALUE self, VALUE hardware_keycode)
+{
+  GdkKeymapKey* keys;
+  guint* keyvals;
+  gint n_entries;
+  gboolean  ret = gdk_keymap_get_entries_for_keycode(_SELF(self),
+                                                     NUM2UINT(hardware_keycode),
+                                                     &keys, &keyvals, &n_entries);
+  if (ret){
+    VALUE key;
+    VALUE ary = rb_ary_new();
+    gint i;
+    for (i = 0; i < n_entries; i++){
+      key = rb_ary_new3(4, UINT2NUM(keys[i].keycode), INT2NUM(keys[i].group), 
+                        INT2NUM(keys[i].level), UINT2NUM(keyvals[i]));
+      rb_ary_push(ary, key);
+    }
+    g_free(keys);
+    g_free(keyvals);
+    return ary;
+  } else {
+    return Qnil;
+  }  
+}
+
+static VALUE
+rg_direction(VALUE self)
+{
+  return GENUM2RVAL(gdk_keymap_get_direction(_SELF(self)), PANGO_TYPE_DIRECTION);
+}
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+static VALUE
+rg_have_bidi_layouts_p(VALUE self)
+{
+    return CBOOL2RVAL(gdk_keymap_have_bidi_layouts(_SELF(self)));
+}
+#endif
+
+void 
+Init_gtk_gdk_keymap(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_KEYMAP, "Keymap", mGdk);
+
+    RG_DEF_SMETHOD(default, 0);
+    RG_DEF_SMETHOD(for_display, 0);
+    RG_DEF_METHOD(lookup_key, 3);
+    RG_DEF_METHOD(translate_keyboard_state, 3);
+    RG_DEF_METHOD(get_entries_for_keyval, 1);
+    RG_DEF_METHOD(get_entries_for_keycode, 1);
+    RG_DEF_METHOD(direction, 0);
+#if GTK_CHECK_VERSION(2, 12, 0)
+    RG_DEF_METHOD_P(have_bidi_layouts, 0);
+#endif
+
+#ifdef GDK_WINDOWING_X11
+    G_DEF_CLASS3("GdkKeymapX11", "KeymapX11", mGdk);
+#endif
+
+}

data/ext/gtk2/rbgdkkeyval.c

@@ -0,0 +1,108 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "global.h"
+#include <gdk/gdkkeysyms.h>
+
+#define RG_TARGET_NAMESPACE mGdkKeyval
+
+static VALUE
+rg_m_to_name(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    gchar* name = gdk_keyval_name(NUM2UINT(keyval));
+    return name ? CSTR2RVAL(name) : Qnil;
+}
+
+static VALUE
+rg_m_from_name(G_GNUC_UNUSED VALUE self, VALUE keyval_name)
+{
+    return UINT2NUM(gdk_keyval_from_name(RVAL2CSTR(keyval_name)));
+}
+
+static VALUE
+rg_m_upper_p(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return CBOOL2RVAL(gdk_keyval_is_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_m_lower_p(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return CBOOL2RVAL(gdk_keyval_is_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_m_convert_case(G_GNUC_UNUSED VALUE self, VALUE symbol)
+{
+    guint upper, lower;
+    gdk_keyval_convert_case(NUM2UINT(symbol), &lower, &upper);
+    return rb_ary_new3(2, UINT2NUM(lower), UINT2NUM(upper));
+}
+
+static VALUE
+rg_m_to_upper(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return INT2NUM(gdk_keyval_to_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_m_to_lower(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return INT2NUM(gdk_keyval_to_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_m_to_unicode(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return UINT2NUM(gdk_keyval_to_unicode(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_m_from_unicode(G_GNUC_UNUSED VALUE self, VALUE 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 mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Keyval");
+    RG_DEF_MODFUNC(to_name, 1);
+    RG_DEF_MODFUNC(from_name, 1);
+    RG_DEF_MODFUNC_P(upper, 1);
+    RG_DEF_MODFUNC_P(lower, 1);
+    RG_DEF_MODFUNC(convert_case, 1);
+    RG_DEF_MODFUNC(to_upper, 1);
+    RG_DEF_MODFUNC(to_lower, 1);
+    RG_DEF_MODFUNC(to_unicode, 1);
+    RG_DEF_MODFUNC(from_unicode, 1);
+
+#include "rbgdkkeysyms.h"
+}