gtk2 0.20.0

data/src/rbgtkbuildable.c

@@ -0,0 +1,115 @@
+/* -*- c-file-style: "ruby" -*- */
+/************************************************
+
+  rbgtkbuildable.c -
+
+  Copyright (C) 2008 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+#define _SELF(self) (GTK_BUILDABLE(RVAL2GOBJ(self)))
+#define RVAL2BUILDER(obj) (GTK_BUILDER(RVAL2GOBJ(obj)))
+
+static VALUE
+buildable_get_name(VALUE self, VALUE name)
+{
+    return CSTR2RVAL(gtk_buildable_get_name(_SELF(self)));
+}
+
+static VALUE
+buildable_set_name(VALUE self, VALUE name)
+{
+    gtk_buildable_set_name(_SELF(self), RVAL2CSTR(name));
+    return self;
+}
+
+static VALUE
+buildable_add_child(int argc, VALUE *argv, VALUE self)
+{
+    VALUE builder, child, type;
+
+    rb_scan_args(argc, argv, "21", &builder, &child, &type);
+    gtk_buildable_add_child(_SELF(self), RVAL2BUILDER(builder), RVAL2GOBJ(child),
+                            RVAL2CSTR_ACCEPT_NIL(type));
+    return self;
+}
+
+static VALUE
+buildable_set_buildable_property(VALUE self, VALUE rb_builder,
+                                 VALUE rb_name, VALUE rb_value)
+{
+    GtkBuilder *builder;
+    const gchar *name;
+    GValue value = {0};
+
+    builder = RVAL2BUILDER(rb_builder);
+    name = RVAL2CSTR(rb_name);
+    rbgobj_initialize_gvalue(&value, rb_value);
+    gtk_buildable_set_buildable_property(_SELF(self), builder, name, &value);
+
+    return self;
+}
+
+static VALUE
+buildable_construct_child(VALUE self, VALUE builder, VALUE name)
+{
+    return GOBJ2RVAL(gtk_buildable_construct_child(_SELF(self),
+						   RVAL2BUILDER(builder),
+						   RVAL2CSTR(name)));
+}
+
+/*
+  customized buildable is not supported yet.
+
+gboolean  gtk_buildable_custom_tag_start       (GtkBuildable        *buildable,
+						GtkBuilder          *builder,
+						GObject             *child,
+						const gchar         *tagname,
+						GMarkupParser       *parser,
+						gpointer            *data);
+void      gtk_buildable_custom_tag_end         (GtkBuildable        *buildable,
+						GtkBuilder          *builder,
+						GObject             *child,
+						const gchar         *tagname,
+						gpointer            *data);
+void      gtk_buildable_custom_finished        (GtkBuildable        *buildable,
+						GtkBuilder          *builder,
+						GObject             *child,
+						const gchar         *tagname,
+						gpointer             data);
+void      gtk_buildable_parser_finished        (GtkBuildable        *buildable,
+						GtkBuilder          *builder);
+*/
+
+static VALUE
+buildable_get_internal_child(VALUE self, VALUE builder, VALUE child_name)
+{
+    return GOBJ2RVAL(gtk_buildable_get_internal_child(_SELF(self),
+						      RVAL2BUILDER(builder),
+						      RVAL2CSTR(child_name)));
+}
+#endif
+
+void
+Init_gtk_buildable()
+{
+#if GTK_CHECK_VERSION(2, 12, 0)
+    VALUE cGtkBuildable;
+
+    cGtkBuildable = G_DEF_CLASS(GTK_TYPE_BUILDABLE, "Buildable", mGtk);
+
+    rb_define_method(cGtkBuildable, "builder_name", buildable_get_name, 0);
+    rb_define_method(cGtkBuildable, "set_builder_name", buildable_set_name, 1);
+    rb_define_method(cGtkBuildable, "add_child", buildable_add_child, -1);
+    rb_define_method(cGtkBuildable, "set_buildable_property",
+                     buildable_set_buildable_property, 3);
+    rb_define_method(cGtkBuildable, "construct_child",
+                     buildable_construct_child, 2);
+    rb_define_method(cGtkBuildable, "get_internal_child",
+                     buildable_get_internal_child, 2);
+
+    G_DEF_SETTERS(cGtkBuildable);
+#endif
+}

data/src/rbgtkbuilder.c

@@ -0,0 +1,154 @@
+/* -*- c-file-style: "ruby" -*- */
+/************************************************
+
+  rbgtkbuilder.c -
+
+  Copyright (C) 2008 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+#include <glib-enum-types.h> /* From Ruby/GLib2 */
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+#define _SELF(self) (GTK_BUILDER(RVAL2GOBJ(self)))
+
+static ID id___connect_signals__;
+
+static void
+builder_mark(gpointer object)
+{
+    GtkBuilder *builder = object;
+    GSList *objects;
+
+    objects = gtk_builder_get_objects(builder);
+    g_slist_foreach(objects, (GFunc)rbgobj_gc_mark_instance, NULL);
+    g_slist_free(objects);
+}
+
+static VALUE
+builder_initialize(VALUE self)
+{
+    GtkBuilder *builder;
+
+    builder = gtk_builder_new();
+    G_INITIALIZE(self, builder);
+
+    return Qnil;
+}
+
+static VALUE
+builder_add_from_file(VALUE self, VALUE filename)
+{
+    GError *error = NULL;
+
+    if (gtk_builder_add_from_file(_SELF(self),
+                                  RVAL2CSTR(filename),
+                                  &error) == 0)
+        RAISE_GERROR(error);
+
+    return self;
+}
+
+static VALUE
+builder_add_from_string(VALUE self, VALUE string)
+{
+    GError *error = NULL;
+
+    if (gtk_builder_add_from_string(_SELF(self),
+                                    RVAL2CSTR(string),
+                                    RSTRING_LEN(string),
+                                    &error) == 0)
+        RAISE_GERROR(error);
+
+    return self;
+}
+
+static VALUE
+builder_add(VALUE self, VALUE filename_or_xml)
+{
+    const char xml_detect_re_str[] = "(?:\\A<|[\\r\\n])";
+    VALUE xml_detect_re;
+
+    xml_detect_re = rb_reg_new(xml_detect_re_str, strlen(xml_detect_re_str), 0);
+    if (NIL_P(rb_reg_match(xml_detect_re, filename_or_xml)))
+        return builder_add_from_file(self, filename_or_xml);
+    else
+        return builder_add_from_string(self, filename_or_xml);
+}
+
+static VALUE
+builder_get_object(VALUE self, VALUE name)
+{
+    return GOBJ2RVAL(gtk_builder_get_object(_SELF(self), RVAL2CSTR(name)));
+}
+
+static VALUE
+builder_get_objects(VALUE self)
+{
+    return GSLIST2ARY_FREE(gtk_builder_get_objects(_SELF(self)));
+}
+
+static void
+connect_signals(GtkBuilder *builder, GObject *object, const gchar *signal_name,
+		const gchar *handler_name, GObject *connect_object,
+		GConnectFlags flags, gpointer user_data)
+{
+    VALUE signal_connector = (VALUE)user_data;
+
+    rb_funcall(GOBJ2RVAL(builder), id___connect_signals__, 6,
+	       signal_connector, GOBJ2RVAL(object), CSTR2RVAL(signal_name),
+	       CSTR2RVAL(handler_name), GOBJ2RVAL(connect_object),
+	       GFLAGS2RVAL(flags, G_TYPE_CONNECT_FLAGS));
+}
+
+static VALUE
+builder_connect_signals(VALUE self)
+{
+    VALUE signal_connector;
+
+    signal_connector = rb_block_proc();
+    G_CHILD_ADD(self, signal_connector);
+    gtk_builder_connect_signals_full(_SELF(self), connect_signals,
+				     (gpointer)signal_connector);
+    G_CHILD_REMOVE(self, signal_connector);
+
+    return self;
+}
+
+static VALUE
+builder_get_type_from_name(VALUE self, VALUE name)
+{
+    return GTYPE2CLASS(gtk_builder_get_type_from_name(_SELF(self),
+						      RVAL2CSTR(name)));
+}
+#endif
+
+void
+Init_gtk_builder()
+{
+#if GTK_CHECK_VERSION(2, 12, 0)
+    VALUE gBuilder;
+
+    id___connect_signals__ = rb_intern("__connect_signals__");
+
+    gBuilder = G_DEF_CLASS_WITH_GC_FUNC(GTK_TYPE_BUILDER, "Builder", mGtk,
+					builder_mark, NULL);
+
+    G_DEF_CLASS(GTK_TYPE_BUILDER_ERROR, "BuilderError", mGtk);
+
+    rb_define_method(gBuilder, "initialize", builder_initialize, 0);
+
+    rb_define_method(gBuilder, "add_from_file", builder_add_from_file, 1);
+    rb_define_method(gBuilder, "add_from_string", builder_add_from_string, 1);
+    rb_define_method(gBuilder, "add", builder_add, 1);
+    rb_define_alias(gBuilder, "<<", "add");
+
+    rb_define_method(gBuilder, "get_object", builder_get_object, 1);
+    rb_define_alias(gBuilder, "[]", "get_object");
+    rb_define_method(gBuilder, "objects", builder_get_objects, 0);
+
+    rb_define_method(gBuilder, "connect_signals", builder_connect_signals, 0);
+
+    rb_define_method(gBuilder, "get_type", builder_get_type_from_name, 1);
+#endif
+}

data/src/rbgtkbutton.c

@@ -0,0 +1,151 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkbutton.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GTK_BUTTON(RVAL2GOBJ(self)))
+
+static VALUE
+button_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE label, use_underline;
+    GtkWidget *widget = NULL;
+
+    if (rb_scan_args(argc, argv, "02", &label, &use_underline) > 0) {
+        if (TYPE(label) == T_STRING){
+            if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
+                widget = gtk_button_new_with_mnemonic(RVAL2CSTR(label));
+            } else {
+                widget = gtk_button_new_with_label(RVAL2CSTR(label));
+            }
+        } else if (TYPE(label) == T_SYMBOL){
+            widget = gtk_button_new_from_stock(rb_id2name(SYM2ID(label)));
+        } else {
+            rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)", 
+                     rb_class2name(CLASS_OF(label)));
+        }
+    } else {
+	widget = gtk_button_new();
+    }
+
+    RBGTK_INITIALIZE(self, widget); 
+    return Qnil;
+}
+
+static VALUE
+button_pressed(self)
+    VALUE self;
+{
+    gtk_button_pressed(GTK_BUTTON(RVAL2GOBJ(self)));
+    return self;
+}
+
+static VALUE
+button_released(self)
+    VALUE self;
+{
+    gtk_button_released(_SELF(self));
+    return self;
+}
+
+static VALUE
+button_clicked(self)
+    VALUE self;
+{
+    gtk_button_clicked(_SELF(self));
+    return self;
+}
+
+static VALUE
+button_enter(self)
+    VALUE self;
+{
+    gtk_button_enter(_SELF(self));
+    return self;
+}
+
+static VALUE
+button_leave(self)
+    VALUE self;
+{
+    gtk_button_leave(_SELF(self));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+button_set_alignment(self, xalign, yalign)
+    VALUE self, xalign, yalign;
+{
+    gtk_button_set_alignment(_SELF(self), NUM2DBL(xalign), NUM2DBL(yalign));
+    return self;
+}
+
+static VALUE
+button_get_alignment(self)
+    VALUE self;
+{
+    gfloat xalign, yalign;
+    gtk_button_get_alignment(_SELF(self), &xalign, &yalign);
+
+    return rb_assoc_new(rb_float_new(xalign), rb_float_new(yalign));
+}
+#endif
+
+/* Defined as properties.
+void        gtk_button_set_relief           (GtkButton *button,
+                                             GtkReliefStyle newstyle);
+GtkReliefStyle gtk_button_get_relief        (GtkButton *button);
+const gchar* gtk_button_get_label           (GtkButton *button);
+void        gtk_button_set_label            (GtkButton *button,
+                                             const gchar *label);
+gboolean    gtk_button_get_use_stock        (GtkButton *button);
+void        gtk_button_set_use_stock        (GtkButton *button,
+                                             gboolean use_stock);
+gboolean    gtk_button_get_use_underline    (GtkButton *button);
+void        gtk_button_set_use_underline    (GtkButton *button,
+                                             gboolean use_underline);
+void        gtk_button_set_focus_on_click   (GtkButton *button,
+                                             gboolean focus_on_click);
+gboolean    gtk_button_get_focus_on_click   (GtkButton *button);
+void        gtk_button_set_image            (GtkButton *button,
+                                             GtkWidget *image);
+GtkWidget*  gtk_button_get_image            (GtkButton *button);
+void        gtk_button_set_image_position   (GtkButton *button,
+                                             GtkPositionType position);
+GtkPositionType gtk_button_get_image_position
+                                            (GtkButton *button);
+*/
+
+void 
+Init_gtk_button()
+{
+    VALUE gButton = G_DEF_CLASS(GTK_TYPE_BUTTON, "Button", mGtk);
+
+    rb_define_method(gButton, "initialize", button_initialize, -1);
+    rb_define_method(gButton, "pressed", button_pressed, 0);
+    rb_define_method(gButton, "released", button_released, 0);
+    rb_define_method(gButton, "clicked", button_clicked, 0);
+    rb_define_method(gButton, "enter", button_enter, 0);
+    rb_define_method(gButton, "leave", button_leave, 0);
+
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gButton, "set_alignment", button_set_alignment, 2);
+    rb_define_method(gButton, "alignment", button_get_alignment, 0);
+#endif
+    G_DEF_SETTERS(gButton);
+}

data/src/rbgtkcalendar.c

@@ -0,0 +1,159 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcalendar.c -
+
+  $Author: mutoh $
+  $Date: 2004/07/31 05:44:45 $
+
+  Copyright (C) 2002-2004 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GTK_CALENDAR(RVAL2GOBJ(self)))
+
+static VALUE
+cal_init(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_calendar_new());
+    return Qnil;
+}
+
+static VALUE
+cal_select_month(self, month, year)
+    VALUE self, month, year;
+{
+    gint ret = gtk_calendar_select_month(_SELF(self),
+                                         NUM2INT(month)-1,
+                                         NUM2INT(year));
+    return INT2FIX(ret);
+}
+
+static VALUE
+cal_select_day(self, day)
+    VALUE self, day;
+{
+    gtk_calendar_select_day(_SELF(self), NUM2INT(day));
+    return self;
+}
+
+static VALUE
+cal_mark_day(self, day)
+    VALUE self, day;
+{
+    gtk_calendar_mark_day(_SELF(self), NUM2INT(day));
+    return self;
+}
+
+static VALUE
+cal_unmark_day(self, day)
+    VALUE self, day;
+{
+    gtk_calendar_unmark_day(_SELF(self), NUM2INT(day));
+    return self;
+}
+
+static VALUE
+cal_clear_marks(self)
+    VALUE self;
+{
+    gtk_calendar_clear_marks(_SELF(self));
+    return self;
+}
+
+static VALUE
+cal_get_date(self)
+    VALUE self;
+{
+    VALUE ret;
+    guint year, month, day;
+
+    gtk_calendar_get_date(_SELF(self), &year, &month, &day);
+    ret = rb_ary_new();
+    rb_ary_push(ret, INT2FIX(year));
+    rb_ary_push(ret, INT2FIX(month+1));
+    rb_ary_push(ret, INT2FIX(day));
+    return ret;
+}
+
+static VALUE
+cal_freeze(self)
+    VALUE self;
+{
+    gtk_calendar_freeze(_SELF(self));
+    return self;
+}
+
+static VALUE
+cal_thaw(self)
+    VALUE self;
+{
+    gtk_calendar_thaw(_SELF(self));
+    return self;
+}
+
+static VALUE
+cal_get_display_options(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE flags;
+    rb_scan_args(argc, argv, "01", &flags);
+
+    if NIL_P(flags){
+#if GTK_CHECK_VERSION(2,4,0)
+        return GFLAGS2RVAL(gtk_calendar_get_display_options(_SELF(self)),
+                           GTK_TYPE_CALENDAR_DISPLAY_OPTIONS);
+#else
+        rb_warn("Gtk::Calendar#display_options has supported since GTK+-2.4.");
+#endif
+    } else {
+        /* This is for backward compatibility. */
+        rb_warning("Gtk::Calendar#display_options(flags) has been deprecated. Use Gtk::Calendar#set_display_options(flags).");
+        gtk_calendar_display_options(_SELF(self), 
+                                     RVAL2GFLAGS(flags, GTK_TYPE_CALENDAR_DISPLAY_OPTIONS));
+    }
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+cal_set_display_options(self, flags)
+    VALUE self, flags;
+{
+    gtk_calendar_set_display_options(_SELF(self), 
+                                     RVAL2GFLAGS(flags, 
+                                                 GTK_TYPE_CALENDAR_DISPLAY_OPTIONS));
+    return self;
+}
+#endif
+
+void 
+Init_gtk_calendar()
+{
+    VALUE gCalendar = G_DEF_CLASS(GTK_TYPE_CALENDAR, "Calendar", mGtk);
+
+    rb_define_method(gCalendar, "initialize", cal_init, 0);
+    rb_define_method(gCalendar, "select_month", cal_select_month, 2);
+    rb_define_method(gCalendar, "select_day", cal_select_day, 1);
+    rb_define_method(gCalendar, "mark_day", cal_mark_day, 1);
+    rb_define_method(gCalendar, "unmark_day", cal_unmark_day, 1);
+    rb_define_method(gCalendar, "clear_marks", cal_clear_marks, 0);
+    rb_define_method(gCalendar, "date", cal_get_date, 0);
+    rb_define_method(gCalendar, "freeze", cal_freeze, 0);
+    rb_define_method(gCalendar, "thaw", cal_thaw, 0);
+    rb_define_method(gCalendar, "display_options", cal_get_display_options, -1);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gCalendar, "set_display_options", cal_set_display_options, 1);
+#endif
+    G_DEF_SETTERS(gCalendar);
+
+    G_DEF_CLASS(GTK_TYPE_CALENDAR_DISPLAY_OPTIONS, "DisplayOptions", gCalendar);
+    G_DEF_CONSTANTS(gCalendar, GTK_TYPE_CALENDAR_DISPLAY_OPTIONS, "GTK_CALENDAR_");
+}