gtksourceview3 1.2.0-x86-mingw32

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,29 @@
+# -*- ruby -*-
+
+$LOAD_PATH.unshift("./../glib2/lib")
+require 'gnome2-raketask'
+
+package = GNOME2Package.new do |_package|
+  _package.summary = "Ruby/GtkSourceView3 is a Ruby binding of gtksourceview-3.x."
+  _package.description = "Ruby/GtkSourceView3 is a Ruby binding of gtksourceview-3.x."
+  _package.dependency.gem.runtime = ["gtk3"]
+  _package.win32.packages = []
+  _package.win32.dependencies = ["libxml2"]
+  _package.win32.build_dependencies = [
+    "glib2", "atk", "pango", "gdk_pixbuf2", "gdk3",
+  ]
+  _package.win32.build_packages = [
+    {
+      :name => "gtksourceview",
+      :download_site => :gnome,
+      :label => "GtkSourceView",
+      :version => "3.6.3",
+      :configure_args => [],
+      :compression_method => "xz",
+    }
+  ]
+  _package.required_ruby_version = ">= 1.9.2"
+  _package.post_install_message = "This library is experimental."
+end
+package.define_tasks
+

data/ext/gtksourceview3/depend

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

data/ext/gtksourceview3/extconf.rb

@@ -0,0 +1,76 @@
+=begin
+extconf.rb for Ruby/GtkSourceView3 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 = "gtksourceview3"
+package_id = "gtksourceview-3.0"
+
+begin
+  require 'mkmf-gnome2'
+rescue LoadError
+  require 'rubygems'
+  gem 'glib2'
+  require 'mkmf-gnome2'
+end
+
+["glib2", "atk", "pango", "gdk_pixbuf2", "gdk3", "gtk3"].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)
+
+unless required_pkg_config_package(package_id,
+                                   :debian => "libgtksourceview3.0-dev",
+                                   :fedora => "gtksourceview3-devel")
+  exit(false)
+end
+
+make_version_header("GTKSOURCEVIEW3", package_id, ".")
+
+create_pkg_config_file("Ruby/GtkSourceView3", package_id)
+$defs << "-DRUBY_GTKSOURCEVIEW3_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/gtksourceview3/gtksourceview3.def

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

data/ext/gtksourceview3/rbgtksource.c

@@ -0,0 +1,53 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004,2005 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003  Geoff Youngs, based on gtktextview.c by 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 "rbgtksourceview3private.h"
+
+#define RG_TARGET_NAMESPACE mGtkSource
+
+void
+Init_gtksourceview3 (void)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module("GtkSource");
+
+    rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
+                    rb_ary_new3(3,
+                                INT2FIX(GTKSOURCEVIEW3_MAJOR_VERSION),
+                                INT2FIX(GTKSOURCEVIEW3_MINOR_VERSION),
+                                INT2FIX(GTKSOURCEVIEW3_MICRO_VERSION)));
+
+    Init_gtksource_view (RG_TARGET_NAMESPACE);
+    Init_gtksource_buffer (RG_TARGET_NAMESPACE);
+    Init_gtksource_language (RG_TARGET_NAMESPACE);
+    Init_gtksource_languagemanager (RG_TARGET_NAMESPACE);
+    Init_gtksource_mark (RG_TARGET_NAMESPACE);
+    Init_gtksource_printcompositor (RG_TARGET_NAMESPACE);
+    Init_gtksource_style (RG_TARGET_NAMESPACE);
+    Init_gtksource_stylescheme (RG_TARGET_NAMESPACE);
+    Init_gtksource_styleschememanager (RG_TARGET_NAMESPACE);
+    Init_gtksource_gutter(RG_TARGET_NAMESPACE);
+    Init_gtksource_gutterrenderer(RG_TARGET_NAMESPACE);
+    Init_gtksource_gutterrendererpixbuf(RG_TARGET_NAMESPACE);
+    Init_gtksource_gutterrenderertext(RG_TARGET_NAMESPACE);
+    Init_gtksource_markattributes(RG_TARGET_NAMESPACE);
+    Init_gtksource_undomanager(RG_TARGET_NAMESPACE);
+}

data/ext/gtksourceview3/rbgtksourcebuffer.c

@@ -0,0 +1,318 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004,2005 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003  Geoff Youngs, based on gtktextview.c by 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 "rbgtksourceview3private.h"
+
+/* Class: Gtk::SourceBuffer
+ * Text buffer object for Gtk::SourceView.
+ */
+
+#define RG_TARGET_NAMESPACE cBuffer
+#define _SELF(self) (RVAL2GTKSOURCEBUFFER(self))
+
+#define RVAL2ITER(self, position) rval2iter(self, position)
+#define RVAL2STARTITER(self, iter, out) \
+        rval2iter_with_default(&(self), &(iter), &(out), gtk_text_buffer_get_start_iter)
+#define RVAL2ENDITER(self, iter, out) \
+        rval2iter_with_default(&(self), &(iter), &(out), gtk_text_buffer_get_end_iter)
+
+static GtkTextIter *
+rval2iter(VALUE self, VALUE position)
+{
+    if (!g_type_is_a(RVAL2GTYPE(position), GTK_TYPE_TEXT_ITER))
+        position = rb_funcall(self, rb_intern("get_iter_at"), 1, position);
+    return RVAL2GTKTEXTITER(position);
+}
+
+static GtkTextIter *
+rval2iter_with_default(VALUE *self, VALUE *iter, GtkTextIter *out,
+                       void (*default_func)(GtkTextBuffer *, GtkTextIter *))
+{
+    if (NIL_P(*iter)) {
+        default_func(RVAL2GTKTEXTBUFFER(*self), out);
+        return out;
+    } else {
+        return RVAL2ITER(*self, *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
+rg_initialize(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(RVAL2GTKTEXTTAGTABLE(val)));
+    } else
+        if (rb_obj_is_kind_of
+        (val, GTYPE2CLASS (GTK_SOURCE_TYPE_LANGUAGE))) {
+        G_INITIALIZE (self,
+                  gtk_source_buffer_new_with_language(RVAL2GTKSOURCELANGUAGE(val)));
+    } else {
+        rb_raise (rb_eArgError,
+              "invalid argument %s (expect nil, Gtk::TextTagTable or Gtk::SourceLanguage)",
+              rb_class2name (CLASS_OF (val)));
+    }
+    return Qnil;
+}
+
+/*
+ * 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
+rg_redo_bang(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
+rg_undo_bang(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
+rg_begin_not_undoable_action(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
+rg_end_not_undoable_action(VALUE self)
+{
+    gtk_source_buffer_end_not_undoable_action (_SELF (self));
+    return self;
+}
+
+/*
+ * 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
+rg_create_source_mark(int argc, VALUE *argv, VALUE 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_ACCEPT_SYMBOL (category),
+                               RVAL2ITER (self, where)));
+}
+
+static VALUE
+rg_get_source_marks_at_line(int argc, VALUE *argv, VALUE self)
+{
+    VALUE line, category;
+
+    rb_scan_args (argc, argv, "11", &line, &category);
+
+    /* TODO: need free? */
+    return GOBJGSLIST2RVAL_FREE(gtk_source_buffer_get_source_marks_at_line(_SELF(self),
+                                        NUM2INT(line),
+                                        RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL(category)),
+                                g_slist_free, NULL);
+}
+
+static VALUE
+rg_get_source_marks_at_iter(int argc, VALUE *argv, VALUE self)
+{
+    VALUE iter, category;
+
+    rb_scan_args (argc, argv, "11", &iter, &category);
+
+    /* TODO: need free? */
+    return GOBJGSLIST2RVAL_FREE(gtk_source_buffer_get_source_marks_at_iter(_SELF(self),
+                                        RVAL2ITER(self, iter),
+                                        RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL(category)),
+                                g_slist_free, NULL);
+}
+
+static VALUE
+rg_remove_source_marks(int argc, VALUE *argv, VALUE self)
+{
+    VALUE start, end, category;
+    GtkTextIter start_iter, end_iter;
+
+    rb_scan_args (argc, argv, "03", &start, &end, &category);
+
+    gtk_source_buffer_remove_source_marks (_SELF (self),
+                                           RVAL2STARTITER(self, start, start_iter),
+                                           RVAL2ENDITER(self, end, end_iter),
+                                           RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL (category));
+
+    return self;
+}
+
+static VALUE
+rg_forward_iter_to_source_mark(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), RVAL2ITER (self, iter),
+                                    RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL (category)));
+}
+
+static VALUE
+rg_backward_iter_to_source_mark(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), RVAL2ITER (self, iter),
+                                    RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL (category)));
+}
+
+static VALUE
+rg_ensure_highlight(VALUE self, VALUE start, VALUE end)
+{
+    gtk_source_buffer_ensure_highlight (_SELF (self), RVAL2ITER (self, start), RVAL2ITER (self, end));
+
+    return self;
+}
+
+void
+Init_gtksource_buffer (VALUE mGtkSource)
+{
+    VALUE RG_TARGET_NAMESPACE =
+        G_DEF_CLASS (GTK_SOURCE_TYPE_BUFFER, "Buffer", mGtkSource);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD_BANG(redo, 0);
+    RG_DEF_METHOD_BANG(undo, 0);
+    RG_DEF_METHOD(begin_not_undoable_action, 0);
+    RG_DEF_METHOD(end_not_undoable_action, 0);
+    RG_DEF_METHOD(create_source_mark, -1);
+    RG_DEF_METHOD(get_source_marks_at_line, -1);
+    RG_DEF_METHOD(get_source_marks_at_iter, -1);
+    RG_DEF_METHOD(remove_source_marks, -1);
+    RG_DEF_METHOD(forward_iter_to_source_mark, -1);
+    RG_DEF_METHOD(backward_iter_to_source_mark, -1);
+    RG_DEF_METHOD(ensure_highlight, 2);
+}