gdk3 1.2.0

data/ext/gdk3/rbgdkcolor.c

@@ -0,0 +1,137 @@
+/* -*- 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"
+
+#define RG_TARGET_NAMESPACE cColor
+#define _SELF(c) (RVAL2GDKCOLOR(c))
+
+static VALUE
+rg_initialize(VALUE self, VALUE red, VALUE green, VALUE blue)
+{
+    GdkColor c;
+    c.pixel = 0;
+    c.red = NUM2INT(red);
+    c.green = NUM2INT(green);
+    c.blue = NUM2INT(blue);
+
+    G_INITIALIZE(self, &c);
+
+    return Qnil;
+}
+
+static VALUE
+rg_s_parse(G_GNUC_UNUSED VALUE self, VALUE name)
+{
+    GdkColor c;
+    if (! gdk_color_parse(RVAL2CSTR(name), &c)) {
+        rb_raise(rb_eArgError, "can't parse color name `%s'", RVAL2CSTR(name));
+    }
+    return GDKCOLOR2RVAL(&c);
+}
+
+static VALUE
+rg_pixel(VALUE self)
+{
+    return INT2NUM(_SELF(self)->pixel);
+}
+
+static VALUE
+rg_red(VALUE self)
+{
+
+    return INT2FIX(_SELF(self)->red);
+}
+
+static VALUE
+rg_set_red(VALUE self, VALUE red)
+{
+    _SELF(self)->red = NUM2INT(red);
+    return self;
+}
+
+static VALUE
+rg_green(VALUE self)
+{
+    return INT2FIX(_SELF(self)->green);
+}
+
+static VALUE
+rg_set_green(VALUE self, VALUE green)
+{
+    _SELF(self)->green = NUM2INT(green);
+    return self;
+}
+
+static VALUE
+rg_blue(VALUE self)
+{
+    return INT2FIX(_SELF(self)->blue);
+}
+
+static VALUE
+rg_set_blue(VALUE self, VALUE blue)
+{
+    _SELF(self)->blue = NUM2INT(blue);
+    return self;
+}
+
+static VALUE
+rg_to_a(VALUE self)
+{
+    GdkColor *c = _SELF(self);
+    return rb_ary_new3(3, INT2FIX(c->red), 
+                       INT2FIX(c->green), INT2FIX(c->blue));
+}
+
+static VALUE
+rg_operator_gdkcolor_equal(VALUE self, VALUE other)
+{
+    return CBOOL2RVAL(gdk_color_equal(_SELF(self), _SELF(other)));
+}
+
+static VALUE
+rg_to_s(VALUE self)
+{
+    return CSTR2RVAL_FREE(gdk_color_to_string(_SELF(self)));
+}
+
+void
+Init_gdk_color(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_COLOR, "Color", mGdk);
+
+    RG_DEF_SMETHOD(parse, 1);
+    RG_DEF_METHOD(initialize, 3);
+    RG_DEF_METHOD(pixel, 0);
+    RG_DEF_METHOD(red, 0);
+    RG_DEF_METHOD(set_red, 1);
+    RG_DEF_METHOD(green, 0);
+    RG_DEF_METHOD(set_green, 1);
+    RG_DEF_METHOD(blue, 0);
+    RG_DEF_METHOD(set_blue, 1);
+    RG_DEF_METHOD(to_a, 0);
+    RG_DEF_METHOD_OPERATOR("==", gdkcolor_equal, 1);
+    RG_DEF_METHOD(to_s, 0);
+}

data/ext/gdk3/rbgdkconst.c

@@ -0,0 +1,33 @@
+/* -*- 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"
+
+void
+Init_gdk_const(VALUE mGdk)
+{
+    G_DEF_CLASS(GDK_TYPE_STATUS, "Status", mGdk);
+}
+
+

data/ext/gdk3/rbgdkcursor.c

@@ -0,0 +1,99 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2001-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 cCursor
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GdkCursor* cursor = NULL;
+
+    if (argc == 1){
+        VALUE type;
+        rb_scan_args(argc, argv, "10", &type);
+        cursor = gdk_cursor_new(RVAL2GDKCURSORTYPE(type));
+    } else if (argc == 2) {
+        VALUE display, type_or_name;
+        rb_scan_args(argc, argv, "20", &display, &type_or_name);
+        if (TYPE(type_or_name) == T_STRING)
+            cursor = gdk_cursor_new_from_name(RVAL2GDKDISPLAYOBJECT(display),
+                                              RVAL2CSTR(type_or_name));
+        else
+            cursor = gdk_cursor_new_for_display(RVAL2GDKDISPLAYOBJECT(display), 
+                                                RVAL2GDKCURSORTYPE(type_or_name));
+    } else if (argc == 4) {
+        VALUE display, pixbuf, x, y;
+        rb_scan_args(argc, argv, "40", &display, &pixbuf, &x, &y);
+        cursor = gdk_cursor_new_from_pixbuf(RVAL2GDKDISPLAYOBJECT(display), 
+                                            RVAL2GDKPIXBUF(pixbuf), 
+                                            NUM2INT(x), NUM2INT(y));
+/* deprecated
+    } else if (argc == 6) {
+        VALUE pixmap, mask, fg, bg, x, y;
+        rb_scan_args(argc, argv, "60", &pixmap, &mask, &fg, &bg, &x, &y);
+        cursor = gdk_cursor_new_from_pixmap(RVAL2GDKPIXMAP(pixmap), 
+                                            NIL_P(mask)?NULL:RVAL2GDKPIXMAP(mask), 
+                                            RVAL2GDKCOLOR(fg),
+                                            RVAL2GDKCOLOR(bg),
+                                            NUM2INT(x), NUM2INT(y));
+*/
+    }
+    G_INITIALIZE(self, cursor);
+
+    return Qnil;
+}
+
+static VALUE
+rg_display(VALUE self)
+{
+    return GOBJ2RVAL(gdk_cursor_get_display(RVAL2GDKCURSOR(self)));
+}
+
+/* TODO
+static VALUE
+rg_cursor_type(VALUE self)
+{
+    return GDKCURSORTYPE2RVAL((RVAL2GDKCURSOR(self))->type);
+}
+*/
+
+static VALUE
+rg_image(VALUE self)
+{
+    return GOBJ2RVAL(gdk_cursor_get_image(RVAL2GDKCURSOR(self)));
+}
+
+void
+Init_gdk_cursor(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_CURSOR, "Cursor", mGdk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(display, 0);
+/* TODO
+    RG_DEF_METHOD(cursor_type, 0);
+*/
+    RG_DEF_METHOD(image, 0);
+
+    G_DEF_CLASS(GDK_TYPE_CURSOR_TYPE, "Type", RG_TARGET_NAMESPACE);
+}

data/ext/gdk3/rbgdkdevice.c

@@ -0,0 +1,197 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003-2006 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 cDevice
+#define _SELF(self) (RVAL2GDKDEVICE(self))
+
+/* deprecated
+static VALUE
+rg_s_list(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJGLIST2RVAL(gdk_devices_list());
+}
+
+static VALUE
+rg_s_set_extension_events(G_GNUC_UNUSED VALUE self, VALUE window, VALUE mask, VALUE mode)
+{
+    gdk_input_set_extension_events(RVAL2GDKWINDOW(window),
+                                   NUM2INT(mask), FIX2INT(mode));
+    return Qnil;
+}
+
+static VALUE
+rg_s_core_pointer(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gdk_device_get_core_pointer());
+}
+
+static VALUE
+rg_set_source(VALUE self, VALUE source)
+{
+    gdk_device_set_source(_SELF(self), RVAL2GDKINPUTSOURCE(source));
+    return self;
+}
+*/
+
+static VALUE
+rg_set_mode(VALUE self, VALUE mode)
+{
+    return CBOOL2RVAL(gdk_device_set_mode(_SELF(self), RVAL2GDKINPUTMODE(mode)));
+}
+
+static VALUE
+rg_set_key(VALUE self, VALUE index, VALUE keyval, VALUE modifiers)
+{
+    gdk_device_set_key(_SELF(self), NUM2UINT(index), NUM2UINT(keyval),
+                       RVAL2GDKMODIFIERTYPE(modifiers));
+    return self;
+}
+
+static VALUE
+rg_set_axis_use(VALUE self, VALUE index, VALUE use)
+{
+    gdk_device_set_axis_use(_SELF(self), NUM2UINT(index), 
+                            RVAL2GDKAXISUSE(use));
+    return self;
+}
+
+static VALUE
+rg_get_state(VALUE self, VALUE window)
+{
+    gdouble axes[2];
+    GdkModifierType mask;
+
+    gdk_device_get_state(_SELF(self), RVAL2GDKWINDOW(window),
+                         axes, &mask);
+    return rb_ary_new3(3, rb_float_new(axes[0]), rb_float_new(axes[1]),
+                       GDKMODIFIERTYPE2RVAL(mask));
+}
+
+static VALUE
+rg_get_history(VALUE self, VALUE window, VALUE start, VALUE stop)
+{
+    gboolean ret;
+    GdkTimeCoord** events;
+    gint i, n_events;
+    VALUE ary = Qnil;
+    ret = gdk_device_get_history(_SELF(self),
+                                 RVAL2GDKWINDOW(window),
+                                 NUM2UINT(start), NUM2UINT(stop),
+                                 &events, &n_events);
+    if (ret){
+        ary = rb_ary_new();
+        for (i = 0; i < n_events; i++){
+            rb_ary_push(ary, GDKTIMECOORD2RVAL(events));
+        }
+        gdk_device_free_history(events, n_events);
+    }
+    return ary;
+}
+
+static VALUE
+rg_get_axis(VALUE self, VALUE rbaxes, VALUE rbuse)
+{
+    GdkDevice *device = _SELF(self);
+    GdkAxisUse use = RVAL2GDKAXISUSE(rbuse);
+    long n;
+    gdouble *axes = RVAL2GDOUBLES(rbaxes, n);
+    gint device_n_axes = gdk_device_get_n_axes(device);
+    gdouble value;
+    gboolean found;
+
+    if (n != device_n_axes)
+        rb_raise(rb_eArgError,
+                 "unexpected number of axes: %ld != %d",
+                 n, device_n_axes);
+
+    found = gdk_device_get_axis(device, axes, use, &value);
+
+    g_free(axes);
+
+    return found ? DBL2NUM(value) : Qnil;
+}
+
+static VALUE
+rg_mode(VALUE self)
+{
+    return GDKINPUTMODE2RVAL(gdk_device_get_mode(_SELF(self)));
+}
+
+/* deprecated
+static VALUE
+rg_axes(VALUE self)
+{
+    gint i;
+    VALUE ary = rb_ary_new();
+    GdkDeviceAxis* axes = _SELF(self)->axes;
+
+    for (i = 0; i < _SELF(self)->num_axes; i++){
+        rb_ary_push(ary, rb_ary_new3(3, GDKAXISUSE2RVAL(axes[i].use), 
+                                     rb_float_new(axes[i].min), rb_float_new(axes[i].max)));
+    }
+    return ary;
+}
+
+static VALUE
+rg_keys(VALUE self)
+{
+    gint i;
+    VALUE ary = rb_ary_new();
+    GdkDeviceKey* keys = _SELF(self)->keys;
+
+    for (i = 0; i < _SELF(self)->num_keys; i++){
+        rb_ary_push(ary, rb_ary_new3(2, UINT2NUM(keys[i].keyval),
+                                     GDKMODIFIERTYPE2RVAL(keys[i].modifiers)));
+    }
+    return ary;
+}
+*/
+
+void 
+Init_gdk_device(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DEVICE, "Device", mGdk);
+
+/* deprecated
+    RG_DEF_SMETHOD(list, 0);
+    RG_DEF_SMETHOD(set_extension_events, 3);
+    RG_DEF_SMETHOD(core_pointer, 0);
+
+    RG_DEF_METHOD(set_source, 1);
+*/
+    RG_DEF_METHOD(set_mode, 1);
+    RG_DEF_METHOD(set_key, 3);
+    RG_DEF_METHOD(set_axis_use, 2);
+    RG_DEF_METHOD(get_state, 1);
+    RG_DEF_METHOD(get_history, 3);
+    RG_DEF_METHOD(get_axis, 2);
+    RG_DEF_METHOD(mode, 0);
+/* deprecated
+    RG_DEF_METHOD(axes, 0);
+    RG_DEF_METHOD(keys, 0);
+*/
+
+    G_DEF_CLASS(GDK_TYPE_INPUT_SOURCE, "InputSource", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GDK_TYPE_INPUT_MODE, "InputMode", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GDK_TYPE_AXIS_USE, "AxisUse", RG_TARGET_NAMESPACE);
+}