gtk3 2.2.4-x64-mingw32

data/ext/gtk3/rbgtk-action.c

@@ -0,0 +1,205 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004-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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAction
+#define _SELF(self) (RVAL2GTKACTION(self))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, options, label, tooltip, stock_id, buffer;
+
+    rb_scan_args(argc, argv, "11", &name, &options);
+    rbg_scan_options(options,
+                     "label", &label,
+                     "tooltip", &tooltip,
+                     "stock_id", &stock_id,
+                     NULL);
+
+    G_INITIALIZE(self, gtk_action_new(RVAL2CSTR(name),
+                                      RVAL2CSTR_ACCEPT_NIL(label),
+                                      RVAL2CSTR_ACCEPT_NIL(tooltip),
+                                      RVAL2GLIBID_ACCEPT_NIL(stock_id, buffer)));
+
+    return Qnil;
+}
+
+static VALUE
+rg_is_sensitive_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_action_is_sensitive(_SELF(self)));
+}
+
+static VALUE
+rg_is_visible_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_action_is_visible(_SELF(self)));
+}
+
+static VALUE
+rg_activate(VALUE self)
+{
+    gtk_action_activate(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_create_icon(VALUE self, VALUE icon_size)
+{
+    return GOBJ2RVAL(gtk_action_create_icon(_SELF(self), 
+                                            RVAL2GTKICONSIZE(icon_size)));
+}
+
+static VALUE
+rg_create_menu_item(VALUE self)
+{
+    return GOBJ2RVAL(gtk_action_create_menu_item(_SELF(self)));
+}
+
+static VALUE
+rg_create_menu(VALUE self)
+{
+    return GOBJ2RVAL(gtk_action_create_menu(_SELF(self)));
+}
+
+static VALUE
+rg_create_tool_item(VALUE self)
+{
+    return GOBJ2RVAL(gtk_action_create_tool_item(_SELF(self)));
+}
+
+static VALUE
+rg_proxies(VALUE self)
+{
+    return GOBJGSLIST2RVAL(gtk_action_get_proxies(_SELF(self)));
+}
+
+static VALUE
+rg_connect_accelerator(VALUE self)
+{
+    gtk_action_connect_accelerator(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_disconnect_accelerator(VALUE self)
+{
+    gtk_action_disconnect_accelerator(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_set_accel_path(VALUE self, VALUE accel_path)
+{
+    gtk_action_set_accel_path(_SELF(self), RVAL2CSTR(accel_path));
+    return self;
+}
+
+static VALUE
+rg_set_accel_group(VALUE self, VALUE accel_group)
+{
+    gtk_action_set_accel_group(_SELF(self),
+                               NIL_P(accel_group) ? NULL : RVAL2GTKACCELGROUP(accel_group));
+    return self;
+}
+
+static VALUE
+rg_accel_path(VALUE self)
+{
+    return CSTR2RVAL(gtk_action_get_accel_path(_SELF(self)));
+}
+
+static VALUE
+rg_accel_closure(VALUE self)
+{
+    return GCLOSURE2RVAL(gtk_action_get_accel_closure(_SELF(self)));
+}
+
+static void
+action_mark(void *p)
+{
+    GtkAction *action;
+    GSList *node;
+
+    action = GTK_ACTION(p);
+    for (node = gtk_action_get_proxies(action);
+         node;
+         node = g_slist_next(node)) {
+        GtkWidget *proxy = node->data;
+        rbgobj_gc_mark_instance(proxy);
+    }
+}
+
+static VALUE
+rg_unblock_activate(VALUE self)
+{
+    gtk_action_unblock_activate(_SELF(self));
+
+    return self;
+}
+
+static VALUE
+rg_block_activate(VALUE self)
+{
+    gtk_action_block_activate(_SELF(self));
+    if (rb_block_given_p())
+        rb_ensure(rb_yield, self, rg_unblock_activate, self);
+
+    return self;
+}
+
+void
+Init_gtk_action(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(GTK_TYPE_ACTION, "Action", mGtk,
+                                                   action_mark, NULL);
+
+    RG_DEF_METHOD(initialize, -1);
+    /* (NOTICE) Gtk::Action#is_sensitive?, #is_visible are special.
+       Because there are also Gtk::Action#sensitive?, #visible? as property 
+       accessors. 
+       Gtk::Action#is_sensitive?, #is_visible? check its associated 
+       action group.
+       Gtk::Action#sensitive?, #visible? returns the value of the properties.
+    */
+    RG_DEF_METHOD_P(is_sensitive, 0);
+    RG_DEF_METHOD_P(is_visible, 0);
+    RG_DEF_METHOD(activate, 0);
+    RG_DEF_METHOD(create_icon, 1);
+    RG_DEF_METHOD(create_menu_item, 0);
+    RG_DEF_METHOD(create_menu, 0);
+    RG_DEF_METHOD(create_tool_item, 0);
+    RG_DEF_METHOD(proxies, 0);
+    RG_DEF_METHOD(connect_accelerator, 0);
+    RG_DEF_METHOD(disconnect_accelerator, 0);
+    RG_DEF_METHOD(set_accel_path, 1);
+    RG_DEF_METHOD(set_accel_group, 1);
+    RG_DEF_METHOD(accel_path, 0);
+    RG_DEF_METHOD(accel_closure, 0);
+    RG_DEF_METHOD(block_activate, 0);
+    RG_DEF_METHOD(unblock_activate, 0);
+
+    RG_REG_GLIBID_SETTER("stock-id");
+}

data/ext/gtk3/rbgtk-activatable.c

@@ -0,0 +1,30 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE mActivatable
+#define _SELF(self) (RVAL2GTKACTIVATABLE(self))
+
+void
+Init_gtk_activatable(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_ACTIVATABLE, "Activatable", mGtk);
+}

data/ext/gtk3/rbgtk-adjustment.c

@@ -0,0 +1,98 @@
+/* -*- 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAdjustment
+#define _SELF(self) (RVAL2GTKADJUSTMENT(self))
+
+static VALUE
+rg_initialize(VALUE self, VALUE value, VALUE lower, VALUE upper, VALUE step_inc, VALUE page_inc, VALUE page_size)
+{
+    RBGTK_INITIALIZE(self, gtk_adjustment_new(NUM2DBL(value),
+                                              NUM2DBL(lower),
+                                              NUM2DBL(upper),
+                                              NUM2DBL(step_inc),
+                                              NUM2DBL(page_inc),
+                                              NUM2DBL(page_size)));
+    return Qnil;
+}
+
+static VALUE
+rg_clamp_page(VALUE self, VALUE lower, VALUE upper)
+{
+    gtk_adjustment_clamp_page(_SELF(self), NUM2DBL(lower), NUM2DBL(upper));
+    return self;
+}
+
+static VALUE
+rg_changed(VALUE self)
+{
+    gtk_adjustment_changed(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_value_changed(VALUE self)
+{
+    gtk_adjustment_value_changed(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_configure(VALUE self, VALUE value, VALUE lower, VALUE upper, VALUE step_increment, VALUE page_increment, VALUE page_size)
+{
+    gtk_adjustment_configure(_SELF(self),
+                             NUM2DBL(value),
+                             NUM2DBL(lower),
+                             NUM2DBL(upper),
+                             NUM2DBL(step_increment),
+                             NUM2DBL(page_increment),
+                             NUM2DBL(page_size));
+
+    return self;
+}
+
+#if GTK_CHECK_VERSION(3, 2, 0)
+static VALUE
+rg_minimum_increment(VALUE self)
+{
+    return DBL2NUM(gtk_adjustment_get_minimum_increment(_SELF(self)));
+}
+#endif
+
+void
+Init_gtk_adjustment(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ADJUSTMENT, "Adjustment", mGtk);
+
+    RG_DEF_METHOD(initialize, 6);
+    RG_DEF_METHOD(clamp_page, 2);
+    RG_DEF_METHOD(changed, 0);
+    RG_DEF_METHOD(value_changed, 0);
+    RG_DEF_METHOD(configure, 6);
+#if GTK_CHECK_VERSION(3, 2, 0)
+    RG_DEF_METHOD(minimum_increment, 0);
+#endif
+}

data/ext/gtk3/rbgtk-alignment.c

@@ -0,0 +1,75 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2004 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAlignment
+
+static VALUE
+rg_initialize(VALUE self, VALUE xalign, VALUE yalign, VALUE xscale, VALUE yscale)
+{
+    RBGTK_INITIALIZE(self, gtk_alignment_new(NUM2DBL(xalign),
+                                             NUM2DBL(yalign),
+                                             NUM2DBL(xscale),
+                                             NUM2DBL(yscale)));
+    return Qnil;
+}
+
+static VALUE
+rg_set(VALUE self, VALUE xalign, VALUE yalign, VALUE xscale, VALUE yscale)
+{
+    gtk_alignment_set(RVAL2GTKALIGNMENT(self),
+                      NUM2DBL(xalign), NUM2DBL(yalign),
+                      NUM2DBL(xscale), NUM2DBL(yscale));
+    return self;
+}
+
+static VALUE
+rg_padding(VALUE self)
+{
+    guint top, bottom, left, right;
+    gtk_alignment_get_padding(RVAL2GTKALIGNMENT(self),
+                              &top, &bottom, &left, &right);
+    return rb_ary_new3(4, UINT2NUM(top), UINT2NUM(bottom), 
+                       UINT2NUM(left), UINT2NUM(right));
+}
+static VALUE
+rg_set_padding(VALUE self, VALUE top, VALUE bottom, VALUE left, VALUE right)
+{
+    gtk_alignment_set_padding(RVAL2GTKALIGNMENT(self),
+                              NUM2UINT(top), NUM2UINT(bottom),
+                              NUM2UINT(left), NUM2UINT(right));
+    return self;
+}
+
+void
+Init_gtk_alignment(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ALIGNMENT, "Alignment", mGtk);
+
+    RG_DEF_METHOD(initialize, 4);
+    RG_DEF_METHOD(set, 4);
+    RG_DEF_METHOD(padding, 0);
+    RG_DEF_METHOD(set_padding, 4);
+}

data/ext/gtk3/rbgtk-allocation.c

@@ -0,0 +1,166 @@
+/* -*- 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 "rbgtk3private.h"
+
+static GtkAllocation *
+gtk_allocation_copy(const GtkAllocation *alloc)
+{
+  GtkAllocation *result = g_new (GtkAllocation, 1);
+  *result = *alloc;
+
+  return result;
+}
+
+GType
+gtk_allocation_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GtkAllocation",
+                    (GBoxedCopyFunc)gtk_allocation_copy,
+                    (GBoxedFreeFunc)g_free);
+  return our_type;
+}
+
+#define RG_TARGET_NAMESPACE cAllocation
+#define _SELF(r) (RVAL2GTKALLOCATION(r))
+
+static VALUE
+rg_initialize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+    GtkAllocation allocation;
+
+    allocation.x = NUM2INT(x);
+    allocation.y = NUM2INT(y);
+    allocation.width = NUM2INT(width);
+    allocation.height = NUM2INT(height);
+
+    G_INITIALIZE(self, g_boxed_copy(GTK_TYPE_ALLOCATION, &allocation));
+    return Qnil;
+}
+
+static VALUE
+rg_intersect(VALUE self, VALUE other)
+{
+    GtkAllocation dest;
+    gboolean ret = gdk_rectangle_intersect(_SELF(self), _SELF(other), &dest);
+    return ret ? GTKALLOCATION2RVAL(&dest) : Qnil;
+}
+
+static VALUE
+rg_union(VALUE self, VALUE other)
+{
+    GtkAllocation dest;
+    gdk_rectangle_union(_SELF(self), _SELF(other), &dest);
+    return GTKALLOCATION2RVAL(&dest);
+}
+
+/* Struct accessors */
+static VALUE
+rg_x(VALUE self)
+{
+    return INT2NUM(_SELF(self)->x);
+}
+
+static VALUE
+rg_y(VALUE self)
+{
+    return INT2NUM(_SELF(self)->y);
+}
+
+static VALUE
+rg_width(VALUE self)
+{
+    return INT2NUM(_SELF(self)->width);
+}
+
+static VALUE
+rg_height(VALUE self)
+{
+    return INT2NUM(_SELF(self)->height);
+}
+
+static VALUE
+rg_set_x(VALUE self, VALUE x)
+{
+    _SELF(self)->x = NUM2INT(x);
+    return self;
+}
+
+static VALUE
+rg_set_y(VALUE self, VALUE y)
+{
+    _SELF(self)->y = NUM2INT(y);
+    return self;
+}
+
+static VALUE
+rg_set_width(VALUE self, VALUE width)
+{
+    _SELF(self)->width = NUM2INT(width);
+    return self;
+}
+
+static VALUE
+rg_set_height(VALUE self, VALUE height)
+{
+    _SELF(self)->height = NUM2INT(height);
+    return self;
+}
+
+static VALUE
+rg_to_a(VALUE self)
+{
+  GtkAllocation* a = _SELF(self);
+  return rb_ary_new3(4, INT2FIX(a->x), INT2FIX(a->y),
+                     INT2FIX(a->width), INT2FIX(a->height));
+}
+
+static VALUE
+rg_to_rect(VALUE self)
+{
+    return GDKRECTANGLE2RVAL(_SELF(self));
+}
+
+void
+Init_gtk_allocation(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ALLOCATION, "Allocation", mGtk);
+
+    RG_DEF_METHOD(initialize, 4);
+    RG_DEF_METHOD(intersect, 1);
+    RG_DEF_ALIAS("&", "intersect");
+    RG_DEF_METHOD(union, 1);
+    RG_DEF_ALIAS("|", "union");
+    RG_DEF_METHOD(x, 0);
+    RG_DEF_METHOD(y, 0);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(set_x, 1);
+    RG_DEF_METHOD(set_y, 1);
+    RG_DEF_METHOD(set_width, 1);
+    RG_DEF_METHOD(set_height, 1);
+    RG_DEF_METHOD(to_a, 0);
+    RG_DEF_METHOD(to_rect, 0);
+}