gtk2 0.20.0

data/src/rbgdkselection.c

@@ -0,0 +1,161 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkselection.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002-2004 Masao Mutoh
+************************************************/
+
+
+#include "global.h"
+
+#define GATOM2RVAL(g) (BOXED2RVAL(g, GDK_TYPE_ATOM))
+
+static VALUE
+gdkselection_owner_set(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    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(GDK_WINDOW(RVAL2GOBJ(owner)), 
+                                      RVAL2ATOM(selection), 
+                                      NUM2UINT(time), RVAL2CBOOL(send_event));
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "50", &display, &owner, &selection, &time, &send_event);
+      ret = gdk_selection_owner_set_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                GDK_WINDOW(RVAL2GOBJ(owner)), 
+                                                RVAL2ATOM(selection), 
+                                                NUM2UINT(time), RVAL2CBOOL(send_event));
+#else
+      rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+#endif
+
+    }
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+gdkselection_owner_get(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE selection;
+
+    if (argc == 1) {
+        rb_scan_args(argc, argv, "10", &selection);
+        return GOBJ2RVAL(gdk_selection_owner_get(RVAL2ATOM(selection)));
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "20", &display, &selection);
+      return GOBJ2RVAL(gdk_selection_owner_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                           RVAL2ATOM(selection)));
+#else
+      rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+#endif
+    }
+}
+
+static VALUE
+gdkselection_convert(self, requestor, selection, target, time)
+    VALUE self, requestor, selection, target, time;
+{
+    gdk_selection_convert(GDK_WINDOW(RVAL2GOBJ(requestor)), 
+                          RVAL2ATOM(selection), 
+                          RVAL2ATOM(target), NUM2INT(time));
+    return self;
+}
+
+static VALUE
+gdkselection_property_get(self, requestor)
+    VALUE self, requestor;
+{
+    guchar *data;
+    GdkAtom prop_type;
+    gint prop_format;
+    VALUE ary;
+
+    gdk_selection_property_get(GDK_WINDOW(RVAL2GOBJ(requestor)), &data, 
+                               &prop_type, &prop_format);
+
+    ary = rb_ary_new3(3, CSTR2RVAL((const char*)data), GATOM2RVAL(prop_type), 
+                      INT2NUM(prop_format));
+    g_free(data);
+    return ary;
+}
+
+static VALUE
+gdkselection_send_notify(argc, argv, self)
+    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(NUM2UINT(requestor), RVAL2ATOM(selection),
+                                  RVAL2ATOM(target), 
+                                  NIL_P(property) ? GDK_NONE : RVAL2ATOM(property), 
+                                  NUM2INT(time));
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+      VALUE display = Qnil;
+      rb_scan_args(argc, argv, "60", &display, &requestor, &selection, &target, &property, &time);
+      gdk_selection_send_notify_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                            NUM2UINT(requestor), RVAL2ATOM(selection),
+                                            RVAL2ATOM(target), 
+                                            NIL_P(property) ? GDK_NONE : RVAL2ATOM(property), 
+                                            NUM2INT(time));
+#else
+      rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+#endif
+    }
+    return self;
+}
+
+void
+Init_gtk_gdk_selection()
+{
+    VALUE mGdkSelection = rb_define_module_under(mGdk, "Selection");
+
+    rb_define_module_function(mGdkSelection, "owner_set", gdkselection_owner_set, -1);
+    rb_define_module_function(mGdkSelection, "owner_get", gdkselection_owner_get, -1);
+    rb_define_module_function(mGdkSelection, "convert", gdkselection_convert, 4);
+    rb_define_module_function(mGdkSelection, "property_get", gdkselection_property_get, 1);
+    rb_define_module_function(mGdkSelection, "send_notify", gdkselection_send_notify, -1);
+
+    /* Constants */
+    rb_define_const(mGdkSelection, "PRIMARY", GATOM2RVAL(GDK_SELECTION_PRIMARY));
+    rb_define_const(mGdkSelection, "SECONDARY", GATOM2RVAL(GDK_SELECTION_SECONDARY));
+    rb_define_const(mGdkSelection, "CLIPBOARD", GATOM2RVAL(GDK_SELECTION_CLIPBOARD));
+    
+    /* GdkSelectionType */
+    rb_define_const(mGdkSelection, "TYPE_ATOM", GATOM2RVAL(GDK_SELECTION_TYPE_ATOM));
+    rb_define_const(mGdkSelection, "TYPE_BITMAP", GATOM2RVAL(GDK_SELECTION_TYPE_BITMAP));
+    rb_define_const(mGdkSelection, "TYPE_COLORMAP", GATOM2RVAL(GDK_SELECTION_TYPE_COLORMAP));
+    rb_define_const(mGdkSelection, "TYPE_DRAWABLE", GATOM2RVAL(GDK_SELECTION_TYPE_DRAWABLE));
+    rb_define_const(mGdkSelection, "TYPE_INTEGER", GATOM2RVAL(GDK_SELECTION_TYPE_INTEGER));
+    rb_define_const(mGdkSelection, "TYPE_PIXMAP", GATOM2RVAL(GDK_SELECTION_TYPE_PIXMAP));
+    rb_define_const(mGdkSelection, "TYPE_WINDOW", GATOM2RVAL(GDK_SELECTION_TYPE_WINDOW));
+    rb_define_const(mGdkSelection, "TYPE_STRING", GATOM2RVAL(GDK_SELECTION_TYPE_STRING));
+
+    /* GdkTarget */
+    rb_define_const(mGdkSelection, "TARGET_BITMAP", GATOM2RVAL(GDK_TARGET_BITMAP));
+    rb_define_const(mGdkSelection, "TARGET_COLORMAP", GATOM2RVAL(GDK_TARGET_COLORMAP));
+    rb_define_const(mGdkSelection, "TARGET_DRAWABLE", GATOM2RVAL(GDK_TARGET_DRAWABLE));
+    rb_define_const(mGdkSelection, "TARGET_PIXMAP", GATOM2RVAL(GDK_TARGET_PIXMAP));
+    rb_define_const(mGdkSelection, "TARGET_STRING", GATOM2RVAL(GDK_TARGET_STRING));
+
+}

data/src/rbgdkthreads.c

@@ -0,0 +1,68 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkthreads.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:00:50 $
+
+  Copyright (C) 2003-2005 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#ifdef   G_THREADS_ENABLED
+static VALUE
+rbgdk_threads_init(self)
+    VALUE self;
+{
+#ifndef GDK_WINDOWING_WIN32
+    if (!g_thread_supported()){
+        g_thread_init(NULL);
+    }
+    gdk_threads_init();
+#endif
+    return self;
+}
+
+static VALUE
+rbgdk_threads_enter(self)
+    VALUE self;
+{
+    gdk_threads_enter();
+    return self;
+}
+
+static VALUE
+rbgdk_threads_leave(self)
+    VALUE self;
+{
+    gdk_threads_leave();
+    return self;
+}
+
+static VALUE
+rbgdk_threads_synchronize(self)
+    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_gtk_gdk_threads()
+{
+#ifdef   G_THREADS_ENABLED
+    VALUE mGdkThreads = rb_define_module_under(mGdk, "Threads");
+
+    rb_define_module_function(mGdkThreads, "init",  rbgdk_threads_init, 0);
+    rb_define_module_function(mGdkThreads, "enter", rbgdk_threads_enter, 0);
+    rb_define_module_function(mGdkThreads, "leave", rbgdk_threads_leave, 0);
+    rb_define_module_function(mGdkThreads, "synchronize", rbgdk_threads_synchronize, 0);
+#endif
+}

data/src/rbgdktimecoord.c

@@ -0,0 +1,118 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdktimecoord.c -
+
+  $Author: sakai $
+  $Date: 2006/05/26 14:18:22 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+#include "global.h"
+
+#define _SELF(s) ((GdkTimeCoord*)RVAL2BOXED(s, GDK_TYPE_TIME_COORD))
+
+/**********************************/
+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
+timecoord_initialize(self, time, axes)
+    VALUE self, time, axes;
+{
+    GdkTimeCoord coord;
+    int i;
+    coord.time = NUM2UINT(time);
+
+    if (RARRAY_LEN(axes) > GDK_MAX_TIMECOORD_AXES){
+        rb_raise(rb_eArgError, "axes: Out of range: %ld", RARRAY_LEN(axes));
+    }
+
+    for (i = 0; i < RARRAY_LEN(axes); i++){
+        coord.axes[i] = NUM2DBL(RARRAY_PTR(axes)[i]);
+    }
+
+    G_INITIALIZE(self, &coord);
+
+    return Qnil;
+}
+
+static VALUE
+timecoord_time(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->time);
+}
+
+static VALUE
+timecoord_set_time(self, time)
+    VALUE self, time;
+{
+    _SELF(self)->time = NUM2UINT(time);
+    return self;
+}
+
+static VALUE
+timecoord_axes(self)
+    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
+timecoord_set_axes(self, axes)
+    VALUE self, axes;
+{
+    int i;
+    GdkTimeCoord* coord = _SELF(self);
+
+    if (RARRAY_LEN(axes) > GDK_MAX_TIMECOORD_AXES){
+        rb_raise(rb_eArgError, "axes: Out of range: %ld", RARRAY_LEN(axes));
+    }
+
+    for (i = 0; i < RARRAY_LEN(axes); i++){
+        coord->axes[i] = NUM2DBL(RARRAY_PTR(axes)[i]);
+    }
+    return self;
+}
+
+void
+Init_gtk_gdk_timecoord()
+{
+    VALUE tc = G_DEF_CLASS(GDK_TYPE_TIME_COORD, "TimeCoord", mGdk);
+
+    rb_define_method(tc, "initialize", timecoord_initialize, 2);
+    rb_define_method(tc, "time", timecoord_time, 0);
+    rb_define_method(tc, "set_time", timecoord_set_time, 1);
+    rb_define_method(tc, "axes", timecoord_axes, 0);
+    rb_define_method(tc, "set_axes", timecoord_set_axes, 1);
+
+    G_DEF_SETTERS(tc);
+
+    rb_define_const(tc, "MAX_AXES", INT2NUM(GDK_MAX_TIMECOORD_AXES));
+}

data/src/rbgdkvisual.c

@@ -0,0 +1,273 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkvisual.c -
+
+  $Author: mutoh $
+  $Date: 2004/08/01 07:10:03 $
+
+  Copyright (C) 2002-2004 Masao Mutoh
+
+  This file is devided from rbgdkcolor.c.
+  rbgdkcolor.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GDK_VISUAL(RVAL2GOBJ(self)))
+
+static VALUE
+gdkvisual_s_query_depths(self)
+    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
+gdkvisual_s_query_visual_types(self)
+    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, GENUM2RVAL((visual_types)[i], GDK_TYPE_VISUAL_TYPE));
+    }
+    return ary;
+}
+
+static VALUE
+gdkvisual_s_list_visuals(self)
+    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
+gdkvisual_s_get_best_depth(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_visual_get_best_depth());
+}
+
+static VALUE
+gdkvisual_s_get_best_type(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_visual_get_best_type());
+}
+
+static VALUE
+gdkvisual_s_get_system(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_visual_get_system());
+}
+
+static VALUE
+gdkvisual_s_get_best(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_visual_get_best());
+}
+
+static VALUE
+gdkvisual_s_get_best_with_depth(self, depth)
+    VALUE self, depth;
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_depth(NUM2INT(depth)));
+}
+
+static VALUE
+gdkvisual_s_get_best_with_type(self, type)
+    VALUE self, type;
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_depth(
+                                    (GdkVisualType)GENUM2RVAL(type, GDK_TYPE_VISUAL_TYPE)));
+}
+
+static VALUE
+gdkvisual_s_get_best_with_both(self, depth, type)
+    VALUE self, depth, type;
+{
+    return GOBJ2RVAL(gdk_visual_get_best_with_both(
+                                    NUM2INT(depth),
+                                    (GdkVisualType)RVAL2GENUM(type, GDK_TYPE_VISUAL_TYPE)));
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+gdkvisual_get_screen(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_visual_get_screen(_SELF(self)));
+}
+#endif
+
+/* Structure accessors */
+static VALUE
+gdkvisual_type(self)
+    VALUE self;
+{
+    return GENUM2RVAL(_SELF(self)->type, GDK_TYPE_VISUAL_TYPE);
+}
+
+static VALUE
+gdkvisual_depth(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->depth);
+}
+
+static VALUE
+gdkvisual_byte_order(self)
+    VALUE self;
+{
+    return GENUM2RVAL(_SELF(self)->byte_order, GDK_TYPE_BYTE_ORDER);
+}
+
+static VALUE
+gdkvisual_colormap_size(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->colormap_size);
+}
+
+static VALUE
+gdkvisual_bits_per_rgb(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->bits_per_rgb);
+}
+
+static VALUE
+gdkvisual_red_mask(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->red_mask);
+}
+
+static VALUE
+gdkvisual_red_shift(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->red_shift);
+}
+
+static VALUE
+gdkvisual_red_prec(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->red_prec);
+}
+
+static VALUE
+gdkvisual_green_mask(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->green_mask);
+}
+
+static VALUE
+gdkvisual_green_shift(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->green_shift);
+}
+
+static VALUE
+gdkvisual_green_prec(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->green_prec);
+}
+
+static VALUE
+gdkvisual_blue_mask(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->blue_mask);
+}
+
+static VALUE
+gdkvisual_blue_shift(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->blue_shift);
+}
+
+static VALUE
+gdkvisual_blue_prec(self)
+    VALUE self;
+{
+    return INT2FIX(_SELF(self)->blue_prec);
+}
+
+void
+Init_gtk_gdk_visual()
+{
+    VALUE gdkVisual = G_DEF_CLASS(GDK_TYPE_VISUAL, "Visual", mGdk);
+
+    /* class methods */
+    rb_define_singleton_method(gdkVisual, "query_depths", gdkvisual_s_query_depths, 0);
+    rb_define_singleton_method(gdkVisual, "query_visual_types", gdkvisual_s_query_visual_types, 0);
+    rb_define_singleton_method(gdkVisual, "visuals", gdkvisual_s_list_visuals, 0);
+    rb_define_singleton_method(gdkVisual, "best_depth", gdkvisual_s_get_best_depth, 0);
+    rb_define_singleton_method(gdkVisual, "best_type", gdkvisual_s_get_best_type, 0);
+    rb_define_singleton_method(gdkVisual, "system", gdkvisual_s_get_system, 0);
+    rb_define_singleton_method(gdkVisual, "best", gdkvisual_s_get_best, 0);
+    rb_define_singleton_method(gdkVisual, "best_with_depth", gdkvisual_s_get_best_with_depth, 1);
+    rb_define_singleton_method(gdkVisual, "best_with_type", gdkvisual_s_get_best_with_type, 1);
+    rb_define_singleton_method(gdkVisual, "best_with_both", gdkvisual_s_get_best_with_both, 2);
+
+    /* instance methods */
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gdkVisual, "screen", gdkvisual_get_screen, 0);
+#endif
+    rb_define_method(gdkVisual, "visual_type", gdkvisual_type, 0);
+    rb_define_method(gdkVisual, "depth", gdkvisual_depth, 0);
+    rb_define_method(gdkVisual, "byte_order", gdkvisual_byte_order, 0);
+    rb_define_method(gdkVisual, "colormap_size", gdkvisual_colormap_size, 0);
+    rb_define_method(gdkVisual, "bits_per_rgb", gdkvisual_bits_per_rgb, 0);
+    rb_define_method(gdkVisual, "red_mask", gdkvisual_red_mask, 0);
+    rb_define_method(gdkVisual, "red_shift", gdkvisual_red_shift, 0);
+    rb_define_method(gdkVisual, "red_prec", gdkvisual_red_prec, 0);
+    rb_define_method(gdkVisual, "green_mask", gdkvisual_green_mask, 0);
+    rb_define_method(gdkVisual, "green_shift", gdkvisual_green_shift, 0);
+    rb_define_method(gdkVisual, "green_prec", gdkvisual_green_prec, 0);
+    rb_define_method(gdkVisual, "blue_mask", gdkvisual_blue_mask, 0);
+    rb_define_method(gdkVisual, "blue_shift", gdkvisual_blue_shift, 0);
+    rb_define_method(gdkVisual, "blue_prec", gdkvisual_blue_prec, 0);
+
+    /* GdkVisualType */
+    G_DEF_CLASS(GDK_TYPE_VISUAL_TYPE, "Type", gdkVisual);
+    G_DEF_CONSTANTS(gdkVisual, GDK_TYPE_VISUAL_TYPE, "GDK_VISUAL_");
+
+    /* GdkByteOrder */
+    G_DEF_CLASS(GDK_TYPE_BYTE_ORDER, "ByteOrder", gdkVisual);
+    G_DEF_CONSTANTS(gdkVisual, GDK_TYPE_BYTE_ORDER, "GDK_");
+}