gdk3 1.2.0

data/ext/gdk3/rbgdkgeometry.c

@@ -0,0 +1,252 @@
+/* -*- 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 "rbgdk3private.h"
+
+/*****************************************/
+static GdkGeometry*
+geo_copy(const GdkGeometry* geo)
+{
+  GdkGeometry* new_geo;
+  g_return_val_if_fail (geo != NULL, NULL);
+  new_geo = g_new(GdkGeometry, 1);
+  *new_geo = *geo;
+  return new_geo;
+}
+
+GType
+gdk_geometry_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GdkGeometry",
+                    (GBoxedCopyFunc)geo_copy,
+                    (GBoxedFreeFunc)g_free);
+  return our_type;
+}
+/*****************************************/
+
+#define RG_TARGET_NAMESPACE cGeometry
+#define _SELF(g) (RVAL2GDKGEOMETRY(g))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    GdkGeometry g;
+    G_INITIALIZE(self, &g);
+    return Qnil;
+}
+
+static VALUE
+rg_set(VALUE self, VALUE min_width, VALUE min_height, VALUE max_width, VALUE max_height, VALUE base_width, VALUE base_height, VALUE width_inc, VALUE height_inc, VALUE min_aspect, VALUE max_aspect, VALUE gravity)
+{
+    GdkGeometry *geo = _SELF(self);
+    geo->min_width = NUM2INT(min_width);
+    geo->min_height = NUM2INT(min_height);
+    geo->max_width = NUM2INT(max_width);
+    geo->max_height = NUM2INT(max_height);
+    geo->base_width = NUM2INT(base_width);
+    geo->base_height = NUM2INT(base_height);
+    geo->width_inc = NUM2INT(width_inc);
+    geo->height_inc = NUM2INT(height_inc);
+    geo->min_aspect = NUM2DBL(min_aspect);
+    geo->max_aspect = NUM2DBL(max_aspect);
+    geo->win_gravity = RVAL2GDKGRAVITY(gravity);
+
+    return self;
+}
+
+static VALUE
+rg_min_width(VALUE self)
+{
+    return INT2NUM(_SELF(self)->min_width);
+}
+
+static VALUE
+rg_min_height(VALUE self)
+{
+    return INT2NUM(_SELF(self)->min_height);
+}
+
+static VALUE
+rg_max_width(VALUE self)
+{
+    return INT2NUM(_SELF(self)->max_width);
+}
+
+static VALUE
+rg_max_height(VALUE self)
+{
+    return INT2NUM(_SELF(self)->max_height);
+}
+
+static VALUE
+rg_base_width(VALUE self)
+{
+    return INT2NUM(_SELF(self)->base_width);
+}
+
+static VALUE
+rg_base_height(VALUE self)
+{
+    return INT2NUM(_SELF(self)->base_height);
+}
+
+static VALUE
+rg_width_inc(VALUE self)
+{
+    return INT2NUM(_SELF(self)->width_inc);
+}
+
+static VALUE
+rg_height_inc(VALUE self)
+{
+    return INT2NUM(_SELF(self)->height_inc);
+}
+
+static VALUE
+rg_min_aspect(VALUE self)
+{
+    return rb_float_new(_SELF(self)->min_aspect);
+}
+
+static VALUE
+rg_max_aspect(VALUE self)
+{
+    return rb_float_new(_SELF(self)->max_aspect);
+}
+
+static VALUE
+rg_win_gravity(VALUE self)
+{
+    return GDKGRAVITY2RVAL(_SELF(self)->win_gravity);
+}
+
+static VALUE
+rg_set_min_width(VALUE self, VALUE min_width)
+{
+    _SELF(self)->min_width = NUM2INT(min_width);
+    return self;
+}
+
+static VALUE
+rg_set_min_height(VALUE self, VALUE min_height)
+{
+    _SELF(self)->min_height = NUM2INT(min_height);
+    return self;
+}
+
+static VALUE
+rg_set_max_width(VALUE self, VALUE max_width)
+{
+    _SELF(self)->max_width = NUM2INT(max_width);
+    return self;
+}
+
+static VALUE
+rg_set_max_height(VALUE self, VALUE max_height)
+{
+    _SELF(self)->max_height = NUM2INT(max_height);
+    return self;
+}
+
+static VALUE
+rg_set_base_width(VALUE self, VALUE base_width)
+{
+    _SELF(self)->base_width = NUM2INT(base_width);
+    return self;
+}
+
+static VALUE
+rg_set_base_height(VALUE self, VALUE base_height)
+{
+    _SELF(self)->base_height = NUM2INT(base_height);
+    return self;
+}
+
+static VALUE
+rg_set_width_inc(VALUE self, VALUE width_inc)
+{
+    _SELF(self)->width_inc = NUM2INT(width_inc);
+    return self;
+}
+
+static VALUE
+rg_set_height_inc(VALUE self, VALUE height_inc)
+{
+    _SELF(self)->height_inc = NUM2INT(height_inc);
+    return self;
+}
+
+static VALUE
+rg_set_min_aspect(VALUE self, VALUE min_aspect)
+{
+    _SELF(self)->min_aspect = NUM2DBL(min_aspect);
+    return self;
+}
+
+static VALUE
+rg_set_max_aspect(VALUE self, VALUE max_aspect)
+{
+    _SELF(self)->max_aspect = NUM2DBL(max_aspect);
+    return self;
+}
+
+static VALUE
+rg_set_win_gravity(VALUE self, VALUE gravity)
+{
+    _SELF(self)->win_gravity = RVAL2GDKGRAVITY(gravity);
+    return self;
+}
+
+void 
+Init_gdk_geometry(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_GEOMETRY, "Geometry", mGdk);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(min_width, 0);
+    RG_DEF_METHOD(min_height, 0);
+    RG_DEF_METHOD(max_width, 0);
+    RG_DEF_METHOD(max_height, 0);
+    RG_DEF_METHOD(base_width, 0);
+    RG_DEF_METHOD(base_height, 0);
+    RG_DEF_METHOD(width_inc, 0);
+    RG_DEF_METHOD(height_inc, 0);
+    RG_DEF_METHOD(min_aspect, 0);
+    RG_DEF_METHOD(max_aspect, 0);
+    RG_DEF_METHOD(win_gravity, 0);
+    RG_DEF_METHOD(set, 11);
+    RG_DEF_METHOD(set_min_width, 1);
+    RG_DEF_METHOD(set_min_height, 1);
+    RG_DEF_METHOD(set_max_width, 1);
+    RG_DEF_METHOD(set_max_height, 1);
+    RG_DEF_METHOD(set_base_width, 1);
+    RG_DEF_METHOD(set_base_height, 1);
+    RG_DEF_METHOD(set_width_inc, 1);
+    RG_DEF_METHOD(set_height_inc, 1);
+    RG_DEF_METHOD(set_min_aspect, 1);
+    RG_DEF_METHOD(set_max_aspect, 1);
+    RG_DEF_METHOD(set_win_gravity, 1);
+}

data/ext/gdk3/rbgdkkeymap.c

@@ -0,0 +1,151 @@
+/* -*- 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"
+
+#define RG_TARGET_NAMESPACE cKeymap
+#define _SELF(s) RVAL2GDKKEYMAP(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(RVAL2GDKDISPLAYOBJECT(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),
+                                            RVAL2GDKMODIFIERTYPE(state),
+                                            NUM2INT(group),
+                                            &keyval, &effective_group,
+                                            &level, &consumed_modifiers);
+  return ret ? rb_ary_new3(4, UINT2NUM(keyval), INT2NUM(effective_group),
+                           INT2NUM(level), 
+                           GDKMODIFIERTYPE2RVAL(consumed_modifiers)) : 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 PANGODIRECTION2RVAL(gdk_keymap_get_direction(_SELF(self)));
+}
+
+static VALUE
+rg_have_bidi_layouts_p(VALUE self)
+{
+    return CBOOL2RVAL(gdk_keymap_have_bidi_layouts(_SELF(self)));
+}
+
+void 
+Init_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);
+    RG_DEF_METHOD_P(have_bidi_layouts, 0);
+
+#ifdef GDK_WINDOWING_X11
+    G_DEF_CLASS3("GdkKeymapX11", "KeymapX11", mGdk);
+#endif
+
+}

data/ext/gdk3/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 "rbgdk3private.h"
+#include <gdk/gdkkeysyms.h>
+
+#define RG_TARGET_NAMESPACE mGdkKeyval
+
+static VALUE
+rg_s_to_name(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    gchar* name = gdk_keyval_name(NUM2UINT(keyval));
+    return name ? CSTR2RVAL(name) : Qnil;
+}
+
+static VALUE
+rg_s_from_name(G_GNUC_UNUSED VALUE self, VALUE keyval_name)
+{
+    return UINT2NUM(gdk_keyval_from_name(RVAL2CSTR(keyval_name)));
+}
+
+static VALUE
+rg_s_upper_p(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return CBOOL2RVAL(gdk_keyval_is_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_s_lower_p(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return CBOOL2RVAL(gdk_keyval_is_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_s_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_s_to_upper(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return INT2NUM(gdk_keyval_to_upper(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_s_to_lower(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return INT2NUM(gdk_keyval_to_lower(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_s_to_unicode(G_GNUC_UNUSED VALUE self, VALUE keyval)
+{
+    return UINT2NUM(gdk_keyval_to_unicode(NUM2UINT(keyval)));
+}
+
+static VALUE
+rg_s_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_gdk_keyval(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Keyval");
+    RG_DEF_SMETHOD(to_name, 1);
+    RG_DEF_SMETHOD(from_name, 1);
+    RG_DEF_SMETHOD_P(upper, 1);
+    RG_DEF_SMETHOD_P(lower, 1);
+    RG_DEF_SMETHOD(convert_case, 1);
+    RG_DEF_SMETHOD(to_upper, 1);
+    RG_DEF_SMETHOD(to_lower, 1);
+    RG_DEF_SMETHOD(to_unicode, 1);
+    RG_DEF_SMETHOD(from_unicode, 1);
+
+#include "rbgdkkeysyms.h"
+}