gtk3 2.2.4-x64-mingw32

data/ext/gtk3/rbgtk-drawing-area.c

@@ -0,0 +1,42 @@
+/* -*- 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cDrawingArea
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_drawing_area_new());
+    return Qnil;
+}
+
+void
+Init_gtk_drawing_area(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_DRAWING_AREA, "DrawingArea", mGtk);
+
+    RG_DEF_METHOD(initialize, 0);
+}

data/ext/gtk3/rbgtk-editable.c

@@ -0,0 +1,149 @@
+/* -*- 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE mEditable
+
+static VALUE
+rg_select_region(VALUE self, VALUE start, VALUE end)
+{
+    gtk_editable_select_region(RVAL2GTKEDITABLE(self),
+                               NUM2INT(start), NUM2INT(end));
+    return self;
+}
+
+static VALUE
+rg_selection_bounds(VALUE self)
+{
+    gint start, end;
+    gboolean ret;
+    ret = gtk_editable_get_selection_bounds(RVAL2GTKEDITABLE(self),
+                                            &start, &end);
+    return ret ? rb_ary_new3(2, INT2NUM(start), INT2NUM(end)) : Qnil;
+}
+
+static VALUE
+rg_insert_text(VALUE self, VALUE new_text, VALUE pos)
+{
+    gint p = NUM2INT(pos);
+
+    StringValue(new_text);
+    gtk_editable_insert_text(RVAL2GTKEDITABLE(self),
+                             RSTRING_PTR(new_text),
+                             RSTRING_LEN(new_text),
+                             &p);
+    return INT2NUM(p);
+}
+
+static VALUE
+rg_delete_text(VALUE self, VALUE start, VALUE end)
+{
+    gtk_editable_delete_text(RVAL2GTKEDITABLE(self),
+                             NUM2INT(start), NUM2INT(end));
+    return self;
+}
+
+static VALUE
+rg_get_chars(VALUE self, VALUE start, VALUE end)
+{
+    return CSTR2RVAL_FREE(
+            gtk_editable_get_chars(RVAL2GTKEDITABLE(self),   /* check s */
+                                   NUM2INT(start), NUM2INT(end)));  /* check start,end */
+}
+
+static VALUE
+rg_delete_selection(VALUE self)
+{
+    gtk_editable_delete_selection(RVAL2GTKEDITABLE(self));
+    return self;
+}
+
+static VALUE
+rg_position(VALUE self)
+{
+    return INT2NUM(gtk_editable_get_position(RVAL2GTKEDITABLE(self)));
+}
+
+static VALUE
+rg_set_position(VALUE self, VALUE position)
+{
+    gtk_editable_set_position(RVAL2GTKEDITABLE(self),
+                              NUM2INT(position));
+    return self;
+}
+
+static VALUE
+rg_set_editable(VALUE self, VALUE editable)
+{
+    gtk_editable_set_editable(RVAL2GTKEDITABLE(self), RVAL2CBOOL(editable));
+    return self;
+}
+
+static VALUE
+rg_editable_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_editable_get_editable(RVAL2GTKEDITABLE(self)));
+}
+
+static VALUE
+rg_cut_clipboard(VALUE self)
+{
+    gtk_editable_cut_clipboard(RVAL2GTKEDITABLE(self));
+    return self;
+}
+
+static VALUE
+rg_copy_clipboard(VALUE self)
+{
+    gtk_editable_copy_clipboard(RVAL2GTKEDITABLE(self));
+    return self;
+}
+
+static VALUE
+rg_paste_clipboard(VALUE self)
+{
+    gtk_editable_paste_clipboard(RVAL2GTKEDITABLE(self));
+    return self;
+}
+
+void
+Init_gtk_editable(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(GTK_TYPE_EDITABLE, "Editable", mGtk);
+
+    RG_DEF_METHOD(select_region, 2);
+    RG_DEF_METHOD(selection_bounds, 0);
+    RG_DEF_METHOD(insert_text, 2);
+    RG_DEF_METHOD(delete_text, 2);
+    RG_DEF_METHOD(get_chars, 2);
+    RG_DEF_METHOD(delete_selection, 0);
+    RG_DEF_METHOD(position, 0);
+    RG_DEF_METHOD(set_position, 1);
+    RG_DEF_METHOD(set_editable, 1);
+    RG_DEF_METHOD_P(editable, 0);
+    RG_DEF_METHOD(copy_clipboard, 0);
+    RG_DEF_METHOD(cut_clipboard, 0);
+    RG_DEF_METHOD(paste_clipboard, 0);
+}

data/ext/gtk3/rbgtk-entry-buffer.c

@@ -0,0 +1,87 @@
+/* -*- 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 cEntryBuffer
+#define _SELF(self) (RVAL2GTKENTRYBUFFER(self))
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE initial_chars;
+    GtkEntryBuffer *buffer = NULL;
+
+    rb_scan_args(argc, argv, "01", &initial_chars);
+
+    if (NIL_P(initial_chars)) {
+        buffer = gtk_entry_buffer_new(NULL, -1);
+    } else {
+        StringValue(initial_chars);
+        buffer = gtk_entry_buffer_new(RSTRING_PTR(initial_chars),
+                                      RSTRING_LEN(initial_chars));
+    }
+    G_INITIALIZE(self, buffer);
+
+    return Qnil;
+}
+
+static VALUE
+rg_delete_text(VALUE self, VALUE position, VALUE n_chars)
+{
+    guint result;
+
+    result = gtk_entry_buffer_delete_text(_SELF(self),
+                                          NUM2UINT(position),
+                                          NUM2INT(n_chars));
+
+    return UINT2NUM(result);
+}
+
+static VALUE
+rg_bytes(VALUE self)
+{
+    return ULONG2NUM(gtk_entry_buffer_get_bytes(_SELF(self)));
+}
+
+static VALUE
+rg_insert_text(VALUE self, VALUE position, VALUE chars)
+{
+    guint result;
+
+    StringValue(chars);
+    result = gtk_entry_buffer_insert_text(_SELF(self),
+                                          NUM2UINT(position),
+                                          RSTRING_PTR(chars),
+                                          RSTRING_LEN(chars));
+
+    return UINT2NUM(result);
+}
+
+void
+Init_gtk_entrybuffer(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ENTRY_BUFFER, "EntryBuffer", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(delete_text, 2);
+    RG_DEF_METHOD(bytes, 0);
+    RG_DEF_METHOD(insert_text, 2);
+}

data/ext/gtk3/rbgtk-entry-completion.c

@@ -0,0 +1,122 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004,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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cEntryCompletion
+#define _SELF(self) (RVAL2GTKENTRYCOMPLETION(self))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    G_INITIALIZE(self, gtk_entry_completion_new());
+    return Qnil;
+}
+
+static VALUE
+rg_entry(VALUE self)
+{
+    return GOBJ2RVAL(gtk_entry_completion_get_entry(_SELF(self)));
+}
+
+static gboolean
+entryc_match_func(GtkEntryCompletion *completion, const gchar *key, GtkTreeIter *iter, gpointer func)
+{
+    iter->user_data3 = gtk_entry_completion_get_model(completion);
+    return RVAL2CBOOL(rb_funcall((VALUE)func, id_call, 3, GOBJ2RVAL(completion),
+                            CSTR2RVAL(key), GTKTREEITER2RVAL(iter)));
+}
+
+static VALUE
+rg_set_match_func(VALUE self)
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_entry_completion_set_match_func(_SELF(self), 
+                                        (GtkEntryCompletionMatchFunc)entryc_match_func,
+                                        (gpointer)func, NULL);
+    return self;
+}
+
+static VALUE
+rg_complete(VALUE self)
+{
+    gtk_entry_completion_complete(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_insert_prefix(VALUE self)
+{
+    gtk_entry_completion_insert_prefix(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_insert_action_text(VALUE self, VALUE index, VALUE text)
+{
+    gtk_entry_completion_insert_action_text(_SELF(self), NUM2INT(index), RVAL2CSTR(text));
+    return self;
+}
+
+static VALUE
+rg_insert_action_markup(VALUE self, VALUE index, VALUE markup)
+{
+    gtk_entry_completion_insert_action_markup(_SELF(self), NUM2INT(index), RVAL2CSTR(markup));
+    return self;
+}
+
+static VALUE
+rg_delete_action(VALUE self, VALUE index)
+{
+    gtk_entry_completion_delete_action(_SELF(self), NUM2INT(index));
+    return self;
+}
+
+static VALUE
+entryc_set_text_column(VALUE self, VALUE column)
+{
+    gtk_entry_completion_set_text_column(_SELF(self), NUM2INT(column));
+    return self;
+}
+
+static VALUE
+rg_completion_prefix(VALUE self)
+{
+    return CSTR2RVAL(gtk_entry_completion_get_completion_prefix(_SELF(self)));
+}
+
+void
+Init_gtk_entry_completion(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ENTRY_COMPLETION, "EntryCompletion", mGtk);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(entry, 0);
+    RG_DEF_METHOD(set_match_func, 0);
+    RG_DEF_METHOD(complete, 0);
+    RG_DEF_METHOD(insert_prefix, 0);
+    RG_DEF_METHOD(insert_action_text, 2);
+    RG_DEF_METHOD(insert_action_markup, 2);
+    RG_DEF_METHOD(delete_action, 1);
+    G_REPLACE_SET_PROPERTY(RG_TARGET_NAMESPACE, "text_column", entryc_set_text_column, 1);
+    RG_DEF_METHOD(completion_prefix, 0);
+}

data/ext/gtk3/rbgtk-entry.c

@@ -0,0 +1,184 @@
+/* -*- 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 cEntry
+#define _SELF(self) (RVAL2GTKENTRY(self))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_entry_new());
+    return Qnil;
+}
+
+static VALUE
+rg_layout(VALUE self)
+{
+    return GOBJ2RVAL(gtk_entry_get_layout(_SELF(self)));
+}
+
+static VALUE
+rg_layout_offsets(VALUE self)
+{
+    int x, y;
+    gtk_entry_get_layout_offsets(_SELF(self), &x, &y);
+    return rb_ary_new3(2, INT2NUM(x), INT2NUM(y));
+}
+
+static VALUE
+rg_layout_index_to_text_index(VALUE self, VALUE layout_index)
+{
+    return INT2NUM(gtk_entry_layout_index_to_text_index(_SELF(self), NUM2INT(layout_index)));
+}
+
+static VALUE
+rg_text_index_to_layout_index(VALUE self, VALUE text_index)
+{
+    return INT2NUM(gtk_entry_text_index_to_layout_index(_SELF(self), NUM2INT(text_index)));
+}
+
+static VALUE
+rg_cursor_hadjustment(VALUE self)
+{
+    return GOBJ2RVAL(gtk_entry_get_cursor_hadjustment(_SELF(self)));
+}
+
+static VALUE
+rg_set_cursor_hadjustment(VALUE self, VALUE adjustment)
+{
+    gtk_entry_set_cursor_hadjustment(_SELF(self), RVAL2GTKADJUSTMENT(adjustment));
+    return self;
+}
+
+static VALUE
+rg_current_icon_drag_source(VALUE self)
+{
+    return INT2NUM(gtk_entry_get_current_icon_drag_source(_SELF(self)));
+}
+
+static VALUE
+rg_get_icon_area(VALUE self, VALUE icon_pos)
+{
+    GdkRectangle icon_area;
+
+    gtk_entry_get_icon_area(_SELF(self),
+                            RVAL2GTKENTRYICONPOSITION(icon_pos),
+                            &icon_area);
+
+    return GOBJ2RVAL(&icon_area);
+}
+
+static VALUE
+rg_get_icon_at_pos(VALUE self, VALUE x, VALUE y)
+{
+    return INT2NUM(gtk_entry_get_icon_at_pos(_SELF(self), NUM2INT(x), NUM2INT(y)));
+}
+
+static VALUE
+rg_text_area(VALUE self)
+{
+    GdkRectangle text_area;
+
+    gtk_entry_get_text_area(_SELF(self), &text_area);
+
+    return GOBJ2RVAL(&text_area);
+}
+
+static VALUE
+rg_im_context_filter_keypress(VALUE self, VALUE event)
+{
+    gboolean result;
+
+    result = gtk_entry_im_context_filter_keypress(_SELF(self),
+                                                  RVAL2GDKEVENTKEY(event));
+
+    return CBOOL2RVAL(result);
+}
+
+static VALUE
+rg_progress_pulse(VALUE self)
+{
+    gtk_entry_progress_pulse(_SELF(self));
+
+    return self;
+}
+
+static VALUE
+rg_reset_im_context(VALUE self)
+{
+    gtk_entry_reset_im_context(_SELF(self));
+
+    return self;
+}
+
+static VALUE
+rg_set_icon_drag_source(VALUE self, VALUE icon_pos, VALUE target_list, VALUE actions)
+{
+    gtk_entry_set_icon_drag_source(_SELF(self),
+                                   RVAL2GTKENTRYICONPOSITION(icon_pos),
+                                   RVAL2GTKTARGETLIST(target_list),
+                                   RVAL2GDKDRAGACTION(actions));
+
+    return self;
+}
+
+static VALUE
+rg_unset_invisible_char(VALUE self)
+{
+    gtk_entry_unset_invisible_char(_SELF(self));
+
+    return self;
+}
+
+void 
+Init_gtk_entry(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ENTRY, "Entry", mGtk);
+
+#if GTK_CHECK_VERSION(3, 6, 0)
+    G_DEF_CLASS(GTK_TYPE_INPUT_PURPOSE, "InputPurpose", mGtk);
+    G_DEF_CLASS(GTK_TYPE_INPUT_HINTS, "InputHints", mGtk);
+#endif
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(layout, 0);
+    RG_DEF_METHOD(layout_offsets, 0);
+    RG_DEF_METHOD(layout_index_to_text_index, 1);
+    RG_DEF_METHOD(text_index_to_layout_index, 1);
+    RG_DEF_METHOD(cursor_hadjustment, 0);
+    RG_DEF_METHOD(set_cursor_hadjustment, 1);
+    RG_DEF_METHOD(current_icon_drag_source, 0);
+    RG_DEF_METHOD(get_icon_area, 1);
+    RG_DEF_METHOD(get_icon_at_pos, 2);
+    RG_DEF_METHOD(text_area, 0);
+    RG_DEF_METHOD(im_context_filter_keypress, 1);
+    RG_DEF_METHOD(progress_pulse, 0);
+    RG_DEF_METHOD(reset_im_context, 0);
+    RG_DEF_METHOD(set_icon_drag_source, 3);
+    RG_DEF_METHOD(unset_invisible_char, 0);
+
+    RG_REG_GLIBID_SETTER("primary-icon-stock");
+    RG_REG_GLIBID_SETTER("secondary-icon-stock");
+}