gdk3 1.2.0

data/ext/gdk3/rbgdkselection.c

@@ -0,0 +1,146 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-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 mSelection
+
+static VALUE
+rg_s_owner_set(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE owner, selection, time, send_event;
+    int ret;
+
+    if (argc == 4){
+        rb_scan_args(argc, argv, "40", &owner, &selection, &time, &send_event);
+        ret = gdk_selection_owner_set(RVAL2GDKWINDOW(owner), 
+                                      RVAL2ATOM(selection), 
+                                      NUM2UINT(time), RVAL2CBOOL(send_event));
+    } else {
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "50", &display, &owner, &selection, &time, &send_event);
+      ret = gdk_selection_owner_set_for_display(RVAL2GDKDISPLAYOBJECT(display),
+                                                RVAL2GDKWINDOW(owner), 
+                                                RVAL2ATOM(selection), 
+                                                NUM2UINT(time), RVAL2CBOOL(send_event));
+    }
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+rg_s_owner_get(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE selection;
+
+    if (argc == 1) {
+        rb_scan_args(argc, argv, "10", &selection);
+        return GOBJ2RVAL(gdk_selection_owner_get(RVAL2ATOM(selection)));
+    } else {
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "20", &display, &selection);
+      return GOBJ2RVAL(gdk_selection_owner_get_for_display(RVAL2GDKDISPLAYOBJECT(display),
+                                                           RVAL2ATOM(selection)));
+    }
+}
+
+static VALUE
+rg_s_convert(VALUE self, VALUE requestor, VALUE selection, VALUE target, VALUE time)
+{
+    gdk_selection_convert(RVAL2GDKWINDOW(requestor), 
+                          RVAL2ATOM(selection), 
+                          RVAL2ATOM(target), NUM2INT(time));
+    return self;
+}
+
+static VALUE
+rg_s_property_get(G_GNUC_UNUSED VALUE self, VALUE requestor)
+{
+    guchar *data;
+    GdkAtom prop_type;
+    gint prop_format;
+    VALUE ary;
+
+    gdk_selection_property_get(RVAL2GDKWINDOW(requestor), &data, 
+                               &prop_type, &prop_format);
+
+    ary = rb_ary_new3(3, CSTR2RVAL((const char*)data), GDKATOM2RVAL(prop_type), 
+                      INT2NUM(prop_format));
+    g_free(data);
+    return ary;
+}
+
+static VALUE
+rg_s_send_notify(int argc, VALUE *argv, VALUE self)
+{
+    VALUE requestor, selection, target, property, time;
+
+    if (argc == 5) {
+        rb_scan_args(argc, argv, "50", &requestor, &selection, &target, &property, &time);
+        gdk_selection_send_notify(RVAL2GDKWINDOW(requestor), RVAL2ATOM(selection),
+                                  RVAL2ATOM(target), 
+                                  NIL_P(property) ? GDK_NONE : RVAL2ATOM(property), 
+                                  NUM2INT(time));
+    } else {
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "60", &display, &requestor, &selection, &target, &property, &time);
+      gdk_selection_send_notify_for_display(RVAL2GDKDISPLAYOBJECT(display),
+                                            RVAL2GDKWINDOW(requestor), RVAL2ATOM(selection),
+                                            RVAL2ATOM(target), 
+                                            NIL_P(property) ? GDK_NONE : RVAL2ATOM(property), 
+                                            NUM2INT(time));
+    }
+    return self;
+}
+
+void
+Init_gdk_selection(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Selection");
+
+    RG_DEF_SMETHOD(owner_set, -1);
+    RG_DEF_SMETHOD(owner_get, -1);
+    RG_DEF_SMETHOD(convert, 4);
+    RG_DEF_SMETHOD(property_get, 1);
+    RG_DEF_SMETHOD(send_notify, -1);
+
+    /* Constants */
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIMARY", GDKATOM2RVAL(GDK_SELECTION_PRIMARY));
+    rb_define_const(RG_TARGET_NAMESPACE, "SECONDARY", GDKATOM2RVAL(GDK_SELECTION_SECONDARY));
+    rb_define_const(RG_TARGET_NAMESPACE, "CLIPBOARD", GDKATOM2RVAL(GDK_SELECTION_CLIPBOARD));
+
+    /* GdkSelectionType */
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_ATOM", GDKATOM2RVAL(GDK_SELECTION_TYPE_ATOM));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_BITMAP", GDKATOM2RVAL(GDK_SELECTION_TYPE_BITMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_COLORMAP", GDKATOM2RVAL(GDK_SELECTION_TYPE_COLORMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_DRAWABLE", GDKATOM2RVAL(GDK_SELECTION_TYPE_DRAWABLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_INTEGER", GDKATOM2RVAL(GDK_SELECTION_TYPE_INTEGER));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_PIXMAP", GDKATOM2RVAL(GDK_SELECTION_TYPE_PIXMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_WINDOW", GDKATOM2RVAL(GDK_SELECTION_TYPE_WINDOW));
+    rb_define_const(RG_TARGET_NAMESPACE, "TYPE_STRING", GDKATOM2RVAL(GDK_SELECTION_TYPE_STRING));
+
+    /* GdkTarget */
+    rb_define_const(RG_TARGET_NAMESPACE, "TARGET_BITMAP", GDKATOM2RVAL(GDK_TARGET_BITMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TARGET_COLORMAP", GDKATOM2RVAL(GDK_TARGET_COLORMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TARGET_DRAWABLE", GDKATOM2RVAL(GDK_TARGET_DRAWABLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "TARGET_PIXMAP", GDKATOM2RVAL(GDK_TARGET_PIXMAP));
+    rb_define_const(RG_TARGET_NAMESPACE, "TARGET_STRING", GDKATOM2RVAL(GDK_TARGET_STRING));
+
+}

data/ext/gdk3/rbgdkthreads.c

@@ -0,0 +1,77 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003-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
+ */
+
+#include "rbgdk3private.h"
+
+#ifdef   G_THREADS_ENABLED
+
+#define RG_TARGET_NAMESPACE mThreads
+
+static VALUE
+rg_s_init(VALUE self)
+{
+#ifndef GDK_WINDOWING_WIN32
+    if (!g_thread_supported()){
+        g_thread_init(NULL);
+    }
+    gdk_threads_init();
+#endif
+    return self;
+}
+
+static VALUE
+rg_s_enter(VALUE self)
+{
+    gdk_threads_enter();
+    return self;
+}
+
+static VALUE
+rg_s_leave(VALUE self)
+{
+    gdk_threads_leave();
+    return self;
+}
+
+static VALUE
+rg_s_synchronize(G_GNUC_UNUSED VALUE self)
+{
+    VALUE func = rb_block_proc();
+    gdk_threads_enter();
+    func = rb_block_proc();
+    rb_funcall(func, id_call, 0);
+    gdk_threads_leave();
+    return Qnil;
+}
+#endif
+
+void
+Init_gdk_threads(VALUE mGdk)
+{
+#ifdef   G_THREADS_ENABLED
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "Threads");
+
+    RG_DEF_SMETHOD(init, 0);
+    RG_DEF_SMETHOD(enter, 0);
+    RG_DEF_SMETHOD(leave, 0);
+    RG_DEF_SMETHOD(synchronize, 0);
+#endif
+}

data/ext/gdk3/rbgdktimecoord.c

@@ -0,0 +1,133 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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 cTimeCoord
+#define _SELF(s) (RVAL2GDKTIMECOORD(s))
+
+/**********************************/
+static GdkTimeCoord*
+timecoord_copy(const GdkTimeCoord* val)
+{
+    GdkTimeCoord* new_val;
+    g_return_val_if_fail (val != NULL, NULL);
+    new_val = g_new(GdkTimeCoord, 1);
+    *new_val = *val;
+    return new_val;
+}
+
+GType
+gdk_timecoord_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("GdkTimeCoord",
+                    (GBoxedCopyFunc)timecoord_copy,
+                    (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+/**********************************/
+
+static VALUE
+rg_initialize(VALUE self, VALUE rbtime, VALUE rbaxes)
+{
+    guint32 time = NUM2UINT(rbtime);
+    long n;
+    gdouble *axes = RVAL2GDOUBLES(rbaxes, n);
+    GdkTimeCoord *coord;
+
+    if (n > GDK_MAX_TIMECOORD_AXES) {
+        g_free(axes);
+
+        rb_raise(rb_eArgError,
+                 "axes out of range: %ld (0..%d)",
+                 n, GDK_MAX_TIMECOORD_AXES);
+    }
+
+    coord = g_new(GdkTimeCoord, 1);
+    coord->time = time;
+    MEMCPY(coord->axes, axes, gdouble, n);
+
+    g_free(axes);
+
+    G_INITIALIZE(self, coord);
+
+    return Qnil;
+}
+
+static VALUE
+rg_time(VALUE self)
+{
+    return UINT2NUM(_SELF(self)->time);
+}
+
+static VALUE
+rg_set_time(VALUE self, VALUE time)
+{
+    _SELF(self)->time = NUM2UINT(time);
+    return self;
+}
+
+static VALUE
+rg_axes(VALUE self)
+{
+    VALUE ary = rb_ary_new();
+    int i;
+    for (i = 0; i < GDK_MAX_TIMECOORD_AXES; i++){
+        rb_ary_push(ary, rb_float_new(_SELF(self)->axes[i]));
+    }
+    return ary;
+}
+
+static VALUE
+rg_set_axes(VALUE self, VALUE rbaxes)
+{
+    GdkTimeCoord *coord = _SELF(self);
+    VALUE axes = rb_ary_to_ary(rbaxes);
+    long i;
+    long n = RARRAY_LEN(axes);
+
+    if (n < 0 || n > GDK_MAX_TIMECOORD_AXES)
+        rb_raise(rb_eArgError,
+                 "axes out of range: %ld (0..%d)",
+                 n, GDK_MAX_TIMECOORD_AXES);
+
+    for (i = 0; i < n; i++)
+        coord->axes[i] = NUM2DBL(RARRAY_PTR(axes)[i]);
+
+    return self;
+}
+
+void
+Init_gdk_timecoord(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_TIME_COORD, "TimeCoord", mGdk);
+
+    RG_DEF_METHOD(initialize, 2);
+    RG_DEF_METHOD(time, 0);
+    RG_DEF_METHOD(set_time, 1);
+    RG_DEF_METHOD(axes, 0);
+    RG_DEF_METHOD(set_axes, 1);
+
+    rb_define_const(RG_TARGET_NAMESPACE, "MAX_AXES", INT2NUM(GDK_MAX_TIMECOORD_AXES));
+}

data/ext/gdk3/rbgdkvisual.c

@@ -0,0 +1,251 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 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"
+
+#define RG_TARGET_NAMESPACE cVisual
+#define _SELF(self) (RVAL2GDKVISUAL(self))
+
+static VALUE
+rg_s_query_depths(G_GNUC_UNUSED VALUE self)
+{
+    gint *depth;
+    gint count;
+    VALUE ary;
+    int i;
+
+    gdk_query_depths(&depth, &count);
+    ary = rb_ary_new2(count);
+    for (i = 0; i < count; i++) {
+        rb_ary_push(ary, INT2NUM((depth)[i]));
+    }
+    return ary;
+}
+
+static VALUE
+rg_s_query_visual_types(G_GNUC_UNUSED VALUE self)
+{
+    GdkVisualType *visual_types;
+    gint count;
+    VALUE ary;
+    int i;
+
+    gdk_query_visual_types(&visual_types, &count);
+    ary = rb_ary_new2(count);
+    for (i = 0; i < count; i++) {
+        rb_ary_push(ary, GDKVISUALTYPE2RVAL((visual_types)[i]));
+    }
+    return ary;
+}
+
+static VALUE
+rg_s_visuals(G_GNUC_UNUSED VALUE self)
+{
+    GList *list = gdk_list_visuals(), *cur;
+    VALUE ary = rb_ary_new();
+
+    for (cur = list; cur != NULL; cur = cur->next) {
+        rb_ary_push(ary, GOBJ2RVAL((GdkVisual *)cur->data));
+    }
+    g_list_free(list);
+    return ary;
+}
+
+static VALUE
+rg_s_best_depth(G_GNUC_UNUSED VALUE self)
+{
+    return INT2NUM(gdk_visual_get_best_depth());
+}
+
+static VALUE
+rg_s_best_type(G_GNUC_UNUSED VALUE self)
+{
+    return INT2NUM(gdk_visual_get_best_type());
+}
+
+static VALUE
+rg_s_system(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gdk_visual_get_system());
+}
+
+static VALUE
+rg_s_best(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gdk_visual_get_best());
+}
+
+static VALUE
+rg_s_best_with_depth(G_GNUC_UNUSED VALUE self, VALUE depth)
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_depth(NUM2INT(depth)));
+}
+
+static VALUE
+rg_s_best_with_type(G_GNUC_UNUSED VALUE self, VALUE type)
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_depth(
+                                    (GdkVisualType)GDKVISUALTYPE2RVAL(type)));
+}
+
+static VALUE
+rg_s_best_with_both(G_GNUC_UNUSED VALUE self, VALUE depth, VALUE type)
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_both(
+                                    NUM2INT(depth),
+                                    (GdkVisualType)RVAL2GDKVISUALTYPE(type)));
+}
+
+static VALUE
+rg_screen(VALUE self)
+{
+    return GOBJ2RVAL(gdk_visual_get_screen(_SELF(self)));
+}
+
+/* Structure accessors */
+static VALUE
+rg_visual_type(VALUE self)
+{
+    return GDKVISUALTYPE2RVAL(gdk_visual_get_visual_type(_SELF(self)));
+}
+
+static VALUE
+rg_depth(VALUE self)
+{
+    return INT2FIX(gdk_visual_get_depth(_SELF(self)));
+}
+
+static VALUE
+rg_byte_order(VALUE self)
+{
+    return GDKBYTEORDER2RVAL(gdk_visual_get_byte_order(_SELF(self)));
+}
+
+static VALUE
+rg_colormap_size(VALUE self)
+{
+    return INT2FIX(gdk_visual_get_colormap_size(_SELF(self)));
+}
+
+static VALUE
+rg_bits_per_rgb(VALUE self)
+{
+    return INT2FIX(gdk_visual_get_bits_per_rgb(_SELF(self)));
+}
+
+/* TODO
+static VALUE
+rg_red_mask(VALUE self)
+{
+    return INT2FIX(_SELF(self)->red_mask);
+}
+
+static VALUE
+rg_red_shift(VALUE self)
+{
+    return INT2FIX(_SELF(self)->red_shift);
+}
+
+static VALUE
+rg_red_prec(VALUE self)
+{
+    return INT2FIX(_SELF(self)->red_prec);
+}
+
+static VALUE
+rg_green_mask(VALUE self)
+{
+    return INT2FIX(_SELF(self)->green_mask);
+}
+
+static VALUE
+rg_green_shift(VALUE self)
+{
+    return INT2FIX(_SELF(self)->green_shift);
+}
+
+static VALUE
+rg_green_prec(VALUE self)
+{
+    return INT2FIX(_SELF(self)->green_prec);
+}
+
+static VALUE
+rg_blue_mask(VALUE self)
+{
+    return INT2FIX(_SELF(self)->blue_mask);
+}
+
+static VALUE
+rg_blue_shift(VALUE self)
+{
+    return INT2FIX(_SELF(self)->blue_shift);
+}
+
+static VALUE
+rg_blue_prec(VALUE self)
+{
+    return INT2FIX(_SELF(self)->blue_prec);
+}
+*/
+
+void
+Init_gdk_visual(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_VISUAL, "Visual", mGdk);
+
+    /* class methods */
+    RG_DEF_SMETHOD(query_depths, 0);
+    RG_DEF_SMETHOD(query_visual_types, 0);
+    RG_DEF_SMETHOD(visuals, 0);
+    RG_DEF_SMETHOD(best_depth, 0);
+    RG_DEF_SMETHOD(best_type, 0);
+    RG_DEF_SMETHOD(system, 0);
+    RG_DEF_SMETHOD(best, 0);
+    RG_DEF_SMETHOD(best_with_depth, 1);
+    RG_DEF_SMETHOD(best_with_type, 1);
+    RG_DEF_SMETHOD(best_with_both, 2);
+
+    /* instance methods */
+    RG_DEF_METHOD(screen, 0);
+    RG_DEF_METHOD(visual_type, 0);
+    RG_DEF_METHOD(depth, 0);
+    RG_DEF_METHOD(byte_order, 0);
+    RG_DEF_METHOD(colormap_size, 0);
+    RG_DEF_METHOD(bits_per_rgb, 0);
+/* TODO
+    RG_DEF_METHOD(red_mask, 0);
+    RG_DEF_METHOD(red_shift, 0);
+    RG_DEF_METHOD(red_prec, 0);
+    RG_DEF_METHOD(green_mask, 0);
+    RG_DEF_METHOD(green_shift, 0);
+    RG_DEF_METHOD(green_prec, 0);
+    RG_DEF_METHOD(blue_mask, 0);
+    RG_DEF_METHOD(blue_shift, 0);
+    RG_DEF_METHOD(blue_prec, 0);
+*/
+
+    G_DEF_CLASS(GDK_TYPE_VISUAL_TYPE, "Type", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GDK_TYPE_BYTE_ORDER, "ByteOrder", RG_TARGET_NAMESPACE);
+}