gtksourceview2 0.90.6-x86-mingw32

data/ChangeLog

@@ -0,0 +1,57 @@
+2011-01-30  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ./: support gem build for Windows.
+
+2011-01-22  Masaaki Aoyagi
+
+	* src/lib/: -> lib/.
+
+	* src/: -> ext/gtksourceview2/.
+
+	* extconf.rb: -> ext/gtksourceview2/extconf.rb
+
+	* ext/gtksourceview2/extconf.rb: support directory structure change.
+
+	* extconf.rb: add.
+
+	* Rakefile: add.
+
+2010-09-28  Kouhei Sutou  <kou@cozmixng.org>
+
+	* test/run-test.rb: fix path.
+
+2010-09-23  Kouhei Sutou  <kou@cozmixng.org>
+
+	* extconf.rb: support Ruby/GLib2 directory structure change.
+
+2008-11-09  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/rbgtksourcemain.h, src/rbgtksourceprintcompositor.c: remove
+	needless definitions.
+
+2008-11-01  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/: use RARRAY_PTR() and RARRAY_LEN().
+
+2008-09-30  Kouhei Sutou  <kou@cozmixng.org>
+
+	* src/rbgtksourceview.c: cleanup style.
+
+	* test/test_source_view.rb: add a test.
+
+	* test/run-test.rb: setup testing environment.
+
+	* src/rbgtksourceview.c, test/test_source_view.rb: fix
+	Gtk::SourceView#{get,set}_mark_category_background bugs.
+
+2008-09-21  yselkowitz
+
+	Wrap new features in 2.4.0.
+	* extconf.rb: Test for new functions in 2.4.
+	* src/rbgtksourceview.c: Add Gtk::SourceView#get_mark_category_background,
+	#set_mark_category_background, ::DRAW_SPACES_*.
+	* src/rbgtksourcelanguagemanager.c: Add Gtk::SourceLanguageManager#guess_language.
+
+2008-07-11  yselkowitz
+
+	Initial import of gtksourceview2.

data/README

@@ -0,0 +1,29 @@
+Ruby/GtkSourceView2
+===================
+Ruby/GtkSourceView2 is a Ruby binding of gtksourceview-2.x.
+
+Requirements
+------------
+   Ruby:          http://www.ruby-lang.org/
+   Ruby-GNOME2:   http://ruby-gnome2.sourceforge.jp/
+   GtkSourceView: ftp://ftp.gnome.org/pub/GNOME/sources/gtksourceview
+
+Install
+-------
+   0. install ruby 1.8.0 or newer, GtkSourceView 2.0.0 or newer, Ruby/GTK2.
+   1. ruby extconf.rb
+   2. make
+   3. su
+   4. make install
+
+Copying
+-------
+   Copyright (c) 2008 Ruby-GNOME2 Project Team
+
+   This program is free software.
+   You can distribute/modify this program under the terms of
+   the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
+
+Project Website
+---------------
+   http://ruby-gnome2.sourceforge.jp/

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+require './../glib2/lib/gnome2-raketask'
+
+package = GNOME2Package.new do |_package|
+  _package.summary = "Ruby/GtkSourceView2 is a Ruby binding of gtksourceview-2.x."
+  _package.description = "Ruby/GtkSourceView2 is a Ruby binding of gtksourceview-2.x."
+  _package.dependency.gem.runtime = ["gtk2"]
+  _package.win32.packages = ["gtksourceview"]
+  _package.win32.dependencies = ["libxml2"]
+  _package.post_install_message = "This library is experimental."
+end
+package.define_tasks
+

data/ext/gtksourceview2/depend

@@ -0,0 +1,5 @@
+install:
+	if test -n "$(pkgconfigdir)"; then				\
+	  $(MAKEDIRS) $(pkgconfigdir);					\
+	  $(INSTALL_DATA) ../ruby-gtksourceview2.pc $(pkgconfigdir);	\
+	fi

data/ext/gtksourceview2/extconf.rb

@@ -0,0 +1,73 @@
+=begin
+extconf.rb for Ruby/GtkSourceView2 extension library
+=end
+
+require 'pathname'
+
+base_dir = Pathname(__FILE__).dirname.parent.parent.expand_path
+top_dir = base_dir.parent
+top_build_dir = Pathname(".").parent.parent.parent.expand_path
+
+mkmf_gnome2_dir = top_dir + "glib2" + 'lib'
+version_suffix = ""
+unless mkmf_gnome2_dir.exist?
+  if /(-\d+\.\d+\.\d+)\z/ =~ base_dir.basename.to_s
+    version_suffix = $1
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+  end
+end
+
+$LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
+
+module_name = "gtksourceview2"
+package_id = "gtksourceview-2.0"
+
+require 'mkmf-gnome2'
+
+["glib2", "atk", "pango", "gdk_pixbuf2", "gtk2"].each do |package|
+  directory = "#{package}#{version_suffix}"
+  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"
+  add_depend_package(package, "#{directory}/ext/#{package}",
+                     top_dir.to_s,
+                     :top_build_dir => top_build_dir.to_s,
+                     :target_build_dir => build_dir)
+end
+
+rcairo_options = {}
+rcairo_source_dir_names = ["rcairo"]
+if /mingw|cygwin|mswin32/ =~ RUBY_PLATFORM
+  rcairo_source_dir_names.unshift("rcairo.win32")
+end
+rcairo_source_dir_names.each do |rcairo_source_dir_name|
+  rcairo_source_dir = top_dir.parent.expand_path + rcairo_source_dir_name
+  if rcairo_source_dir.exist?
+    rcairo_options[:rcairo_source_dir] = rcairo_source_dir.to_s
+    break
+  end
+end
+check_cairo(rcairo_options)
+
+setup_win32(module_name, base_dir)
+
+PKGConfig.have_package(package_id) or exit(false)
+
+# 2.2
+have_func('gtk_source_mark_get_type', "gtksourceview/gtksourcemark.h")
+have_func('gtk_source_print_compositor_get_type', "gtksourceview/gtksourceprintcompositor.h")
+# 2.4
+have_func('gtk_source_view_get_mark_category_background', "gtksourceview/gtksourceview.h")
+have_func('gtk_source_language_manager_guess_language', "gtksourceview/gtksourcelanguagemanager.h")
+
+make_version_header("GTKSOURCEVIEW2", package_id, ".")
+
+create_pkg_config_file("Ruby/GtkSourceView2", package_id)
+$defs << "-DRUBY_GTKSOURCEVIEW2_COMPILATION"
+create_makefile(module_name)
+pkg_config_dir = with_config("pkg-config-dir")
+if pkg_config_dir.is_a?(String)
+  File.open("Makefile", "ab") do |makefile|
+    makefile.puts
+    makefile.puts("pkgconfigdir=#{pkg_config_dir}")
+  end
+end
+

data/ext/gtksourceview2/gtksourceview2.def

@@ -0,0 +1,2 @@
+EXPORTS
+	Init_gtksourceview2

data/ext/gtksourceview2/rbgtksourcebuffer.c

@@ -0,0 +1,401 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtksourcebuffer.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 03:02:28 $
+
+  Copyright (C) 2004,2005 Ruby-GNOME2 Project Team
+  Copyright (C) 2003 Geoff Youngs, based on gtktextview.c by Masao Mutoh
+************************************************/
+#include "rbgtksourcemain.h"
+
+/* Class: Gtk::SourceBuffer
+ * Text buffer object for Gtk::SourceView.
+ */
+
+#define _SELF(self) (GTK_SOURCE_BUFFER(RVAL2GOBJ(self)))
+#define RVAL2ITR(i) ((GtkTextIter*)RVAL2BOXED(i, GTK_TYPE_TEXT_ITER))
+
+/*
+ * Class method: new(obj=nil)
+ * obj: either a Gtk::TextTagTable, a Gtk::SourceLanguage, or nil.
+ *
+ * Creates a new source buffer.  If a Gtk::SourceTagTable is provided, the
+ * buffer will use it, otherwise it will create a new one.
+ *
+ * If a Gtk::SourceLanguage object is given, the buffer will be created
+ * using highlightings patterns in this language. This is equivalent to
+ * creating a new source buffer with the default tag table and then setting
+ * the 'language' property.
+ *
+ * Returns: a newly created Gtk::SourceBuffer object.
+ */
+static VALUE
+sourcebuffer_new (argc, argv, self)
+	int argc;
+	VALUE *argv;
+	VALUE self;
+{
+	VALUE val;
+
+	rb_scan_args (argc, argv, "01", &val);
+	if (NIL_P (val)) {
+		G_INITIALIZE (self, gtk_source_buffer_new (NULL));
+	} else
+	    if (rb_obj_is_kind_of
+		(val, GTYPE2CLASS (GTK_TYPE_TEXT_TAG_TABLE))) {
+		G_INITIALIZE (self,
+			      gtk_source_buffer_new (GTK_TEXT_TAG_TABLE
+						     (RVAL2GOBJ (val))));
+	} else
+	    if (rb_obj_is_kind_of
+		(val, GTYPE2CLASS (GTK_TYPE_SOURCE_LANGUAGE))) {
+		G_INITIALIZE (self,
+			      gtk_source_buffer_new_with_language
+			      (GTK_SOURCE_LANGUAGE (RVAL2GOBJ (val))));
+	} else {
+		rb_raise (rb_eArgError,
+			  "invalid argument %s (expect nil, Gtk::TextTagTable or Gtk::SourceLanguage)",
+			  rb_class2name (CLASS_OF (val)));
+	}
+	return Qnil;
+}
+
+/* Defined as properties.
+void                gtk_source_buffer_set_highlight_syntax
+                                                        (GtkSourceBuffer *buffer,
+                                                         gboolean highlight);
+gboolean            gtk_source_buffer_get_highlight_syntax
+                                                        (GtkSourceBuffer *buffer);
+void                gtk_source_buffer_set_language      (GtkSourceBuffer *buffer,
+                                                         GtkSourceLanguage *language);
+GtkSourceLanguage*  gtk_source_buffer_get_language      (GtkSourceBuffer *buffer);
+void                gtk_source_buffer_set_highlight_matching_brackets
+                                                        (GtkSourceBuffer *buffer,
+                                                         gboolean highlight);
+gboolean            gtk_source_buffer_get_highlight_matching_brackets
+                                                        (GtkSourceBuffer *buffer);
+void                gtk_source_buffer_set_style_scheme  (GtkSourceBuffer *buffer,
+                                                         GtkSourceStyleScheme *scheme);
+GtkSourceStyleScheme* gtk_source_buffer_get_style_scheme
+                                                        (GtkSourceBuffer *buffer);
+gint                gtk_source_buffer_get_max_undo_levels
+                                                        (GtkSourceBuffer *buffer);
+void                gtk_source_buffer_set_max_undo_levels
+                                                        (GtkSourceBuffer *buffer,
+                                                         gint max_undo_levels);
+gboolean            gtk_source_buffer_can_redo          (GtkSourceBuffer *buffer);
+gboolean            gtk_source_buffer_can_undo          (GtkSourceBuffer *buffer);
+*/
+
+/*
+ * Method: redo!
+ *
+ * Redoes the last undo operation. Use Gtk::SourceBuffer#can_redo? to check
+ * whether a call to this function will have any effect.
+ *
+ * Returns: self.
+ */
+static VALUE
+sourcebuffer_redo (self)
+	VALUE self;
+{
+	gtk_source_buffer_redo (_SELF (self));
+	return self;
+}
+
+/*
+ * Method: undo!
+ *
+ * Undoes the last user action which modified the buffer.
+ * Use Gtk::SourceBuffer#can_undo? to check whether a call to this function
+ * will have any effect.
+ *
+ * Actions are defined as groups of operations between a call to 
+ * Gtk::TextBuffer#begin_user_action and Gtk::TextBuffer#end_user_action,
+ * or sequences of similar edits (inserts or deletes) on the same line.
+ *
+ * Returns: self.
+ */
+static VALUE
+sourcebuffer_undo (self)
+	VALUE self;
+{
+	gtk_source_buffer_undo (_SELF (self));
+	return self;
+}
+
+/*
+ * Method: begin_not_undoable_action
+ * Method: begin_not_undoable_action { ... }
+ *
+ * Marks the beginning of a not undoable action on the buffer, disabling the
+ * undo manager.
+ *
+ * If a block is given, the block is called after marking the beginning
+ * of a not undoable action on the buffer.
+ * At the end of the block, marks the end of a not undoable action on the
+ * buffer. When the last not undoable block is finished, the list of undo
+ * actions is cleared and the undo manager is re-enabled.
+ *
+ * Returns: self
+ */
+static VALUE
+sourcebuffer_begin_not_undoable_action(self)
+    VALUE self;
+{
+    gtk_source_buffer_begin_not_undoable_action (_SELF (self));
+
+    if (rb_block_given_p()) {
+	VALUE block = rb_block_proc ();
+	rb_funcall (block, rb_intern ("call"), 0);
+	gtk_source_buffer_end_not_undoable_action (_SELF (self));
+    }
+    return self;
+}
+
+/*
+ * Method: end_not_undoable_action
+ *
+ * Marks the end of a not undoable action on the buffer.
+ * When the last not undoable block is finished, the list of undo
+ * actions is cleared and the undo manager is re-enabled.
+ *
+ * Returns: self
+ */
+static VALUE
+sourcebuffer_end_not_undoable_action(self)
+    VALUE self;
+{
+    gtk_source_buffer_end_not_undoable_action (_SELF (self));
+    return self;
+}
+
+
+/*
+ * Method: not_undoable_action { ... }
+ *
+ * Marks the beginning of a not undoable action on the buffer, disabling the
+ * undo manager, then calls the provided block of code.
+ *
+ * At the end of the block, marks the end of a not undoable action on the
+ * buffer. When the last not undoable block is finished, the list of undo
+ * actions is cleared and the undo manager is re-enabled.
+ *
+ * ((*Deprecated*)). Use Gtk::SourceView#begin_not_undoable_action{ ... } instead.
+ *
+ * Returns: the return value of the provided block.
+ */
+static VALUE
+sourcebuffer_not_undoable_action (self)
+	VALUE self;
+{
+	VALUE block, ret;
+
+	block = rb_block_proc ();
+	gtk_source_buffer_begin_not_undoable_action (_SELF (self));
+	ret = rb_funcall (block, rb_intern ("call"), 0);
+	gtk_source_buffer_end_not_undoable_action (_SELF (self));
+	return ret;
+}
+
+#ifdef HAVE_GTK_SOURCE_MARK_GET_TYPE
+/*
+ * Method: create_source_mark(name=nil, category, where)
+ * name: the name of the mark.
+ * type: a string defining the mark type.
+ * where: a location to place the mark, as a Gtk::TreeIter object.
+ *
+ * Creates a mark in the buffer of the given type. A mark is semantically
+ * very similar to a Gtk::TextMark, except it has a type which is used by the
+ * Gtk::SourceView object displaying the buffer to show a pixmap on the left
+ * margin, at the line the mark is in. Because of this, a mark is generally
+ * associated to a line and not a character position. Marks are also
+ * accessible through a position or range in the buffer.
+ *
+ * Marks are implemented using Gtk::TextMark, so all characteristics and
+ * restrictions to marks apply to marks too. These includes life cycle issues
+ * and "mark-set" and "mark-deleted" signal emissions.
+ *
+ * Like a Gtk::TextMark, a Gtk::SourceMark can be anonymous if the passed
+ * name is nil.
+ *
+ * Marks always have left gravity and are moved to the beginning of the line
+ * when the user deletes the line they were in. Also, if the user deletes a
+ * region of text which contained lines with marks, those are deleted.
+ *
+ * Typical uses for a mark are bookmarks, breakpoints, current executing
+ * instruction indication in a source file, etc..
+ *
+ * Returns: a new Gtk::SourceMark object, owned by the buffer.
+ */
+static VALUE
+sourcebuffer_create_source_mark (argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	VALUE name, category, where;
+
+	if (argc == 2)
+		rb_scan_args (argc, argv, "21", &where, &category, &name);
+	else
+		rb_scan_args (argc, argv, "30", &name, &category, &where);
+
+	return GOBJ2RVAL (gtk_source_buffer_create_source_mark (_SELF (self),
+							   RVAL2CSTR (name),
+							   RVAL2CSTR (category),
+							   RVAL2ITR (where)));
+}
+
+static VALUE
+sourcebuffer_get_source_marks_at_line (argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    GSList *list, *p;
+    VALUE line, category;
+    VALUE ary;
+
+    rb_scan_args (argc, argv, "11", &line, &category);
+
+    list =
+        gtk_source_buffer_get_source_marks_at_line (_SELF (self),
+                          NUM2INT (line),
+                          NIL_P (category) ? NULL : RVAL2CSTR (category));
+    ary = rb_ary_new ();
+
+    p = (GSList *) list;
+    while (p) {
+        rb_ary_push (ary, GOBJ2RVAL (p->data));
+        p = g_slist_next (p);
+    }
+
+    return ary;
+}
+
+static VALUE
+sourcebuffer_get_source_marks_at_iter (argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    GSList *list, *p;
+    VALUE iter, category;
+    VALUE ary;
+
+    rb_scan_args (argc, argv, "11", &iter, &category);
+
+    list =
+        gtk_source_buffer_get_source_marks_at_iter (_SELF (self),
+                          RVAL2ITR (iter),
+                          NIL_P (category) ? NULL : RVAL2CSTR (category));
+    ary = rb_ary_new ();
+
+    p = (GSList *) list;
+    while (p) {
+        rb_ary_push (ary, GOBJ2RVAL (p->data));
+        p = g_slist_next (p);
+    }
+
+    return ary;
+}
+
+static VALUE
+sourcebuffer_remove_source_marks (argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE start, end, category;
+
+    rb_scan_args (argc, argv, "21", &start, &end, &category);
+
+    gtk_source_buffer_remove_source_marks (_SELF (self),
+                            RVAL2ITR (start),
+                            RVAL2ITR (end),
+                            NIL_P (category) ? NULL : RVAL2CSTR (category));
+
+    return self;
+}
+
+static VALUE
+sourcebuffer_forward_iter_to_source_mark (argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE iter, category;
+
+    rb_scan_args (argc, argv, "11", &iter, &category);
+
+    return
+        CBOOL2RVAL (gtk_source_buffer_forward_iter_to_source_mark
+                                   (_SELF (self), RVAL2ITR (iter),
+                                    NIL_P (category) ? NULL : RVAL2CSTR (category)));
+}
+
+static VALUE
+sourcebuffer_backward_iter_to_source_mark (argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE iter, category;
+
+    rb_scan_args (argc, argv, "11", &iter, &category);
+
+    return
+        CBOOL2RVAL (gtk_source_buffer_backward_iter_to_source_mark
+                                   (_SELF (self), RVAL2ITR (iter),
+                                    NIL_P (category) ? NULL : RVAL2CSTR (category)));
+}
+
+#endif /* HAVE_GTK_SOURCE_MARK_GET_TYPE */
+
+static VALUE
+sourcebuffer_ensure_highlight (self, start, end)
+    VALUE self, start, end;
+{
+    gtk_source_buffer_ensure_highlight (_SELF (self), RVAL2ITR (start), RVAL2ITR (end));
+
+    return self;
+}
+
+void
+Init_gtk_sourcebuffer ()
+{
+	VALUE cbuffer =
+	    G_DEF_CLASS (GTK_TYPE_SOURCE_BUFFER, "SourceBuffer", mGtk);
+
+	rb_define_method (cbuffer, "initialize", sourcebuffer_new, -1);
+	rb_define_method (cbuffer, "redo!", sourcebuffer_redo, 0);
+	rb_define_method (cbuffer, "undo!", sourcebuffer_undo, 0);
+	rb_define_method (cbuffer, "begin_not_undoable_action",
+			          sourcebuffer_begin_not_undoable_action, 0);
+	rb_define_method (cbuffer, "end_not_undoable_action",
+			          sourcebuffer_end_not_undoable_action, 0);
+	rb_define_method (cbuffer, "not_undoable_action",
+			          sourcebuffer_not_undoable_action, 0);
+	rb_define_alias (cbuffer, "non_undoable_action", "not_undoable_action");
+#ifdef HAVE_GTK_SOURCE_MARK_GET_TYPE
+    rb_define_method (cbuffer, "create_source_mark",
+                      sourcebuffer_create_source_mark, -1);
+    rb_define_method (cbuffer, "get_source_marks_at_line",
+                      sourcebuffer_get_source_marks_at_line, -1);
+    rb_define_method (cbuffer, "get_source_marks_at_iter",
+                      sourcebuffer_get_source_marks_at_iter, -1);
+    rb_define_method (cbuffer, "remove_source_marks",
+                      sourcebuffer_remove_source_marks, -1);
+    rb_define_method (cbuffer, "forward_iter_to_source_mark",
+                      sourcebuffer_forward_iter_to_source_mark, -1);
+    rb_define_method (cbuffer, "backward_iter_to_source_mark",
+                      sourcebuffer_backward_iter_to_source_mark, -1);
+#endif
+    rb_define_method (cbuffer, "ensure_highlight",
+                      sourcebuffer_ensure_highlight, 2);
+
+	G_DEF_SETTERS (cbuffer);
+}

data/ext/gtksourceview2/rbgtksourceiter.c

@@ -0,0 +1,110 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtksourceiter.c -
+
+  $Author: mutoh $
+  $Date: 2005/01/03 15:33:56 $
+
+  Copyright (C) 2004 Ruby-GNOME2 Project Team
+************************************************/
+#include "rbgtksourcemain.h"
+
+#define _SELF(s) ((GtkTextIter*)RVAL2BOXED(s, GTK_TYPE_TEXT_ITER))
+#define ITR2RVAL(i) (BOXED2RVAL(i, GTK_TYPE_TEXT_ITER))
+
+/* Method: forward_search(str, flags, limit)
+ * str: the search string (string)
+ * flags: flags affecting the search (Gtk::SourceSearchFlags)
+ * limit: location of last possible match start, or NULL for start of buffer
+ * Returns: locations of start and end of match.
+ */
+static VALUE
+forward_search (argc, argv, self)
+	int argc;
+	VALUE *argv;
+	VALUE self;
+{
+	GtkTextIter m_start, m_end;
+	VALUE str, flags, limit;
+	VALUE ret = Qnil;
+
+	rb_scan_args (argc, argv, "21", &str, &flags, &limit);
+
+	if (rb_obj_is_kind_of
+	    (flags, GTYPE2CLASS (GTK_TYPE_SOURCE_SEARCH_FLAGS))) {
+		if (gtk_source_iter_forward_search
+		    (_SELF (self), RVAL2CSTR (str),
+		     RVAL2GFLAGS (flags, GTK_TYPE_SOURCE_SEARCH_FLAGS),
+		     &m_start, &m_end, NIL_P (limit) ? NULL : _SELF (limit)))
+			ret =
+			    rb_ary_new3 (2, ITR2RVAL (&m_start),
+					 ITR2RVAL (&m_end));
+	} else
+	    if (rb_obj_is_kind_of
+		(flags, GTYPE2CLASS (GTK_TYPE_TEXT_SEARCH_FLAGS))) {
+		if (gtk_text_iter_forward_search
+		    (_SELF (self), RVAL2CSTR (str),
+		     RVAL2GFLAGS (flags, GTK_TYPE_TEXT_SEARCH_FLAGS), &m_start,
+		     &m_end, NIL_P (limit) ? NULL : _SELF (limit)))
+			ret =
+			    rb_ary_new3 (2, ITR2RVAL (&m_start),
+					 ITR2RVAL (&m_end));
+	}
+	return ret;
+}
+
+/* Method: backward_search(str, flags, limit)
+ * str: the search string (string)
+ * flags: flags affecting the search (Gtk::SourceSearchFlags)
+ * limit: location of last possible match end, or NULL for end of buffer
+ * Returns: locations of start and end of match.
+ */
+static VALUE
+backward_search (argc, argv, self)
+	int argc;
+	VALUE *argv;
+	VALUE self;
+{
+	GtkTextIter m_start, m_end;
+	VALUE str, flags, limit;
+	VALUE ret = Qnil;
+
+	rb_scan_args (argc, argv, "21", &str, &flags, &limit);
+	if (rb_obj_is_kind_of
+	    (flags, GTYPE2CLASS (GTK_TYPE_SOURCE_SEARCH_FLAGS))) {
+		if (gtk_source_iter_backward_search
+		    (_SELF (self), RVAL2CSTR (str),
+		     RVAL2GFLAGS (flags, GTK_TYPE_SOURCE_SEARCH_FLAGS),
+		     &m_start, &m_end, NIL_P (limit) ? NULL : _SELF (limit)))
+			ret =
+			    rb_ary_new3 (2, ITR2RVAL (&m_start),
+					 ITR2RVAL (&m_end));
+	} else
+	    if (rb_obj_is_kind_of
+		(flags, GTYPE2CLASS (GTK_TYPE_TEXT_SEARCH_FLAGS))) {
+		if (gtk_text_iter_backward_search
+		    (_SELF (self), RVAL2CSTR (str),
+		     RVAL2GFLAGS (flags, GTK_TYPE_TEXT_SEARCH_FLAGS), &m_start,
+		     &m_end, NIL_P (limit) ? NULL : _SELF (limit)))
+			ret =
+			    rb_ary_new3 (2, ITR2RVAL (&m_start),
+					 ITR2RVAL (&m_end));
+	}
+	return ret;
+}
+
+void
+Init_gtk_sourceiter ()
+{
+	VALUE cTextIter = GTYPE2CLASS (GTK_TYPE_TEXT_ITER);
+
+	/*
+	 * They are override original Gtk::TextIter#[for|back]ward_search
+	 */
+	rb_define_method (cTextIter, "forward_search", forward_search, -1);
+	rb_define_method (cTextIter, "backward_search", backward_search, -1);
+
+	G_DEF_CLASS(GTK_TYPE_SOURCE_SEARCH_FLAGS, "SourceSearchFlags", cTextIter);
+	G_DEF_CONSTANTS(cTextIter, GTK_TYPE_SOURCE_SEARCH_FLAGS, "GTK_");
+}