vte 1.0.0 → 1.0.1

data/ChangeLog

@@ -1,3 +1,57 @@
+2011-09-15  Kouhei Sutou  <kou@cozmixng.org>
+
+	* lib/vte/deprecated.rb (GLib::Deprecatable#const_missing): don't
+	shadow real const_missing error.
+
+2011-09-13  Masaaki Aoyagi
+
+	* lib/vte/deprecated.rb:
+	- change module name to GLib::Deprecatable(TODO: move to glib).
+	- improve warning message.
+	- fix constant_get
+
+2011-09-11  Masaaki Aoyagi
+
+	* ext/vte/rbvte-terminal.c:
+	- add constants(EraseBinding,CursorBlinkMode,CursorShape).
+	* ext/vte/rbvte.c:
+	- delete deprecated constants(TerminalEraseBinding,TerminalCursorBlinkMode,TerminalCursorShape).
+	* lib/vte/deprecated.rb:
+	- define deprecated constants.
+
+2011-09-11  Masaaki Aoyagi
+
+	* ext/vte/rbvte-terminal.c: merge 'match_set_cursor*' methods.
+	* lib/vte.rb: add require "vte/deprecated".
+	* lib/vte/deprecated.rb: add.
+
+2011-09-11  Masaaki Aoyagi
+
+	* ext/vte/rbvte-terminal.c: not define method if property exist.
+
+2011-09-11  Masaaki Aoyagi
+
+	* ext/vte/rbvte-terminal.c: change return value to self
+
+2011-09-11  Masaaki Aoyagi
+
+	* ext/vte/rbvte.c,rbvte-pty.c,rbvte-terminal.c:
+	- implement version 0.26.2(exclude regular expressions)
+
+2011-08-28  Masaaki Aoyagi
+
+	* ext/vte/rbvte-access.c: -> ext/vte/rbvte-terminalaccessible.c
+
+2011-07-24  Masaaki Aoyagi
+
+	* ext/vte/*:
+	- divide by namespace.
+	- apply naming rules.
+
+2011-07-23  Masaaki Aoyagi
+
+	* ext/vte/*.c: change file header comment.
+
 2011-03-04  Kouhei Sutou  <kou@clear-code.com>
 
 	* ext/vte/depend: fix .pc path. #3199587

data/ext/vte/rbvte-charattributes.c

@@ -0,0 +1,76 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2006-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 "rbvte.h"
+
+#define RG_TARGET_NAMESPACE cCharAttributes
+
+static ID id_row, id_column, id_fore, id_back, id_underline, id_strikethrough;
+
+static VALUE
+rg_initialize(VALUE self, VALUE row, VALUE column, VALUE fore, VALUE back,
+              VALUE underline, VALUE strikethrough)
+{
+    rb_ivar_set(self, id_row, row);
+    rb_ivar_set(self, id_column, column);
+    rb_ivar_set(self, id_fore, fore);
+    rb_ivar_set(self, id_back, back);
+    rb_ivar_set(self, id_underline, underline);
+    rb_ivar_set(self, id_strikethrough, strikethrough);
+    return Qnil;
+}
+
+static VALUE
+rg_underline_p(VALUE self)
+{
+    return rb_ivar_get(self, id_underline);
+}
+
+static VALUE
+rg_strikethrough_p(VALUE self)
+{
+    return rb_ivar_get(self, id_strikethrough);
+}
+
+void
+Init_vte_charattributes(VALUE mVte)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    id_row = rb_intern("@row");
+    id_column = rb_intern("@column");
+    id_fore = rb_intern("@fore");
+    id_back = rb_intern("@back");
+    id_underline = rb_intern("@underline");
+    id_strikethrough = rb_intern("@strikethrough");
+
+    RG_TARGET_NAMESPACE = rb_define_class_under(mVte, "CharAttributes", rb_cObject);
+
+    RG_DEF_METHOD(initialize, 6);
+    RG_DEF_ATTR("row", TRUE, FALSE, TRUE);
+    RG_DEF_ATTR("column", TRUE, FALSE, TRUE);
+    RG_DEF_ATTR("fore", TRUE, FALSE, TRUE);
+    RG_DEF_ATTR("back", TRUE, FALSE, TRUE);
+    RG_DEF_ALIAS("foreground", "fore");
+    RG_DEF_ALIAS("background", "back");
+    RG_DEF_METHOD_P(underline, 0);
+    RG_DEF_METHOD_P(strikethrough, 0);
+}
+

data/ext/vte/rbvte-pty.c

@@ -0,0 +1,120 @@
+/* -*- 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 "rbvte.h"
+
+#define RG_TARGET_NAMESPACE cPty
+#define _SELF(s) (VTE_PTY(RVAL2GOBJ(s)))
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_initialize(VALUE self, VALUE flags_or_fd)
+{
+    VtePty *pty = NULL;
+    GError *error = NULL;
+
+    if (TYPE(flags_or_fd) == T_FIXNUM) {
+        pty = vte_pty_new_foreign(NUM2INT(flags_or_fd), &error);
+    } else {
+        pty = vte_pty_new(RVAL2GFLAGS(flags_or_fd, VTE_TYPE_PTY_FLAGS), &error);
+    }
+    if (error)
+        RAISE_GERROR(error);
+
+    G_INITIALIZE(self, pty);
+
+    return Qnil;
+}
+
+static VALUE
+rg_child_setup(VALUE self)
+{
+    vte_pty_child_setup(_SELF(self));
+
+    return self;
+}
+
+static VALUE
+rg_close(VALUE self)
+{
+    vte_pty_close(_SELF(self));
+
+    return self;
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    int rows, columns;
+    gboolean result;
+    GError *error = NULL;
+
+    result = vte_pty_get_size(_SELF(self), &rows, &columns, &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return rb_ary_new3(2, INT2NUM(rows), INT2NUM(columns));
+}
+
+static VALUE
+rg_set_size(VALUE self, VALUE rows, VALUE columns)
+{
+    gboolean result;
+    GError *error = NULL;
+
+    result = vte_pty_set_size(_SELF(self), NUM2INT(rows), NUM2INT(columns), &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return self;
+}
+
+static VALUE
+rg_set_utf8(VALUE self, VALUE utf8)
+{
+    gboolean result;
+    GError *error = NULL;
+
+    result = vte_pty_set_utf8(_SELF(self), RVAL2CBOOL(utf8), &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return self;
+}
+#endif
+
+void
+Init_vte_pty(VALUE mVte)
+{
+#if VTE_CHECK_VERSION(0, 26, 0)
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(VTE_TYPE_PTY, "Pty", mVte);
+    G_DEF_CLASS(VTE_TYPE_PTY_ERROR, "Error", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(VTE_TYPE_PTY_FLAGS, "Flags", RG_TARGET_NAMESPACE);
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(child_setup, 0);
+    RG_DEF_METHOD(close, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(set_size, 2);
+    RG_DEF_METHOD(set_utf8, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+#endif
+}

data/ext/vte/rbvte-reaper.c

@@ -1,19 +1,29 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  rbvte-reaper.c -
-
-  $Author: ktou $
-  $Date: 2006/05/17 12:40:47 $
-
-  Copyright (C) 2006 Ruby-GNOME2 Project Team
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2006-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 "rbvte.h"
 
+#define RG_TARGET_NAMESPACE cReaper
+
 static VALUE
-reaper_get(VALUE self)
+rg_m_get(VALUE self)
 {
     return GOBJ2RVAL(vte_reaper_get());
 }
@@ -21,11 +31,11 @@ reaper_get(VALUE self)
 void
 Init_vte_reaper(VALUE mVte)
 {
-    VALUE cReaper;
+    VALUE RG_TARGET_NAMESPACE;
 
-    cReaper = G_DEF_CLASS(VTE_TYPE_REAPER, "Reaper", mVte);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(VTE_TYPE_REAPER, "Reaper", mVte);
 
-    rb_define_module_function(cReaper, "get", reaper_get, 0);
+    RG_DEF_MODFUNC(get, 0);
 
-    G_DEF_SETTERS(cReaper);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }

data/ext/vte/rbvte-terminal.c

@@ -1,21 +1,32 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
+/*
+ *  Copyright (C) 2006-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
+ */
 
-  rbvte-terminal.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:34 $
-
-  Copyright (C) 2006 Ruby-GNOME2 Project Team
+#include "rbvte.h"
 
-**********************************************************************/
+#include <stdarg.h>
+#include <pwd.h>
 
-#include "rbvte.h"
+#define RG_TARGET_NAMESPACE cTerminal
+#define _SELF(s) (VTE_TERMINAL(RVAL2GOBJ(s)))
 
-static VALUE cCharAttributes;
 static ID id_new, id_call;
-static ID id_row, id_column, id_fore, id_back, id_underline, id_strikethrough;
-
 
 static char **
 rval2cstrary(VALUE ary)
@@ -53,15 +64,16 @@ static VALUE
 attrary2rval(GArray *attrs)
 {
     long i, len;
-    VALUE rb_attrs;
+    VALUE rb_attrs, rb_class;
 
     len = attrs->len;
     rb_attrs = rb_ary_new2(len);
+    rb_class = rb_const_get(rb_const_get(rb_cObject, rb_intern("Vte")), rb_intern("CharAttributes"));
 
     for (i = 0; i < len; i++) {
         VteCharAttributes *attr;
         attr = &g_array_index(attrs, VteCharAttributes, i);
-        rb_ary_push(rb_attrs, rb_funcall(cCharAttributes, id_new, 6,
+        rb_ary_push(rb_attrs, rb_funcall(rb_class, id_new, 6,
                                          LONG2NUM(attr->row),
                                          LONG2NUM(attr->column),
                                          COLOR2RVAL(&(attr->fore)),
@@ -73,44 +85,130 @@ attrary2rval(GArray *attrs)
     return rb_attrs;
 }
 
-
-
 static VALUE
-ca_initialize(VALUE self, VALUE row, VALUE column, VALUE fore, VALUE back,
-              VALUE underline, VALUE strikethrough)
+rg_initialize(VALUE self)
 {
-    rb_ivar_set(self, id_row, row);
-    rb_ivar_set(self, id_column, column);
-    rb_ivar_set(self, id_fore, fore);
-    rb_ivar_set(self, id_back, back);
-    rb_ivar_set(self, id_underline, underline);
-    rb_ivar_set(self, id_strikethrough, strikethrough);
+    RBGTK_INITIALIZE(self, vte_terminal_new());
     return Qnil;
 }
 
-static VALUE
-ca_get_underline(VALUE self)
+#if VTE_CHECK_VERSION(0, 26, 0)
+static const char *
+rb_grn_inspect (VALUE object)
 {
-    return rb_ivar_get(self, id_underline);
+    VALUE inspected;
+
+    inspected = rb_funcall(object, rb_intern("inspect"), 0);
+    return StringValueCStr(inspected);
+}
+
+
+static void
+rb_grn_scan_options (VALUE options, ...)
+{
+    VALUE original_options = options;
+    VALUE available_keys;
+    const char *key;
+    VALUE *value;
+    va_list args;
+
+    options = rb_check_convert_type(options, T_HASH, "Hash", "to_hash");
+    if (NIL_P(options)) {
+        options = rb_hash_new();
+    } else if (options == original_options) {
+        options = rb_funcall(options, rb_intern("dup"), 0);
+    }
+
+    available_keys = rb_ary_new();
+    va_start(args, options);
+    key = va_arg(args, const char *);
+    while (key) {
+        VALUE rb_key;
+        value = va_arg(args, VALUE *);
+
+        rb_key = ID2SYM(rb_intern(key));
+        rb_ary_push(available_keys, rb_key);
+        *value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
+
+        key = va_arg(args, const char *);
+    }
+    va_end(args);
+
+    if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
+        return;
+
+    rb_raise(rb_eArgError,
+             "unexpected key(s) exist: %s: available keys: %s",
+             rb_grn_inspect(rb_funcall(options, rb_intern("keys"), 0)),
+             rb_grn_inspect(available_keys));
 }
 
 static VALUE
-ca_get_strikethrough(VALUE self)
+fork_command_default_argv(void)
 {
-    return rb_ivar_get(self, id_strikethrough);
-}
+    struct passwd *pwd;
+    const char *shell = NULL;
 
+    pwd = getpwuid(getuid());
+    if (pwd != NULL)
+        shell = pwd->pw_shell;
+    if (shell == NULL)
+        shell = g_getenv("SHELL") ? g_getenv("SHELL") : "/bin/sh";
+
+    return rb_ary_new3(1, CSTR2RVAL(shell));
+}
 
-
 static VALUE
-term_initialize(VALUE self)
+fork_command_full(int argc, VALUE *argv, VALUE self)
 {
-    RBGTK_INITIALIZE(self, vte_terminal_new());
-    return Qnil;
+    VALUE options, rb_pty_flags, rb_working_directory, rb_command_argv, rb_envv, rb_spawn_flags;
+    int pty_flags, spawn_flags;
+    char *working_directory;
+    char **command_argv;
+    char **envv;
+    GPid child_pid;
+    gboolean result;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "01", &options);
+    rb_grn_scan_options(options,
+                        "pty_flags", &rb_pty_flags,
+                        "working_directory", &rb_working_directory,
+                        "argv", &rb_command_argv,
+                        "envv", &rb_envv,
+                        "spawn_flags", &rb_spawn_flags,
+                        NULL);
+    pty_flags = NIL_P(rb_pty_flags) ?
+                VTE_PTY_DEFAULT :
+                RVAL2GFLAGS(rb_pty_flags, VTE_TYPE_PTY_FLAGS);
+    working_directory = NIL_P(rb_working_directory) ? NULL : RVAL2CSTR(rb_working_directory);
+    command_argv = rval2cstrary(NIL_P(rb_command_argv) ? fork_command_default_argv() : rb_command_argv);
+    envv = rval2cstrary(rb_envv);
+    spawn_flags = NIL_P(rb_spawn_flags) ?
+                G_SPAWN_CHILD_INHERITS_STDIN | G_SPAWN_SEARCH_PATH :
+                NUM2INT(rb_spawn_flags);
+
+    result = vte_terminal_fork_command_full(_SELF(self),
+                                            pty_flags,
+                                            working_directory,
+                                            command_argv,
+                                            envv,
+                                            spawn_flags,
+                                            NULL,
+                                            NULL,
+                                            &child_pid,
+                                            &error);
+    free_cstrary(command_argv);
+    free_cstrary(envv);
+    if (error)
+        RAISE_GERROR(error);
+
+    return INT2NUM(child_pid);
 }
+#endif
 
 static VALUE
-term_fork_command(int argc, VALUE *argv, VALUE self)
+rg_fork_command(int argc, VALUE *argv, VALUE self)
 {
     VALUE rb_command, rb_command_argv, rb_envv, rb_directory;
     VALUE lastlog, utmp, wtmp;
@@ -123,6 +221,15 @@ term_fork_command(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "07", &rb_command, &rb_command_argv,
                  &rb_envv, &rb_directory, &lastlog, &utmp, &wtmp);
 
+#if VTE_CHECK_VERSION(0, 26, 0)
+    if (argc == 0 || TYPE(rb_command) == T_HASH)
+        return fork_command_full(1, &rb_command, self);
+
+    rb_warn("'fork_commad(command, argv, envv, directory, lastlog, utmp, wtmp)' style"
+            " has been deprecated since version 0.26."
+            " Use 'fork_commad(options = {})' style.");
+#endif
+
     command = NIL_P(rb_command) ? NULL : RVAL2CSTR(rb_command);
     command_argv = rval2cstrary(rb_command_argv);
     envv = rval2cstrary(rb_envv);
@@ -139,7 +246,7 @@ term_fork_command(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-term_fork_pty(int argc, VALUE *argv, VALUE self)
+rg_fork_pty(int argc, VALUE *argv, VALUE self)
 {
     VALUE rb_envv, rb_directory, lastlog, utmp, wtmp;
     char **envv;
@@ -161,7 +268,7 @@ term_fork_pty(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-term_feed(VALUE self, VALUE data)
+rg_feed(VALUE self, VALUE data)
 {
     glong length;
 
@@ -171,11 +278,11 @@ term_feed(VALUE self, VALUE data)
         vte_terminal_feed(RVAL2TERM(self), RSTRING_PTR(data), length);
     }
 
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_feed_child(VALUE self, VALUE data)
+rg_feed_child(VALUE self, VALUE data)
 {
     glong length;
 
@@ -185,11 +292,11 @@ term_feed_child(VALUE self, VALUE data)
         vte_terminal_feed_child(RVAL2TERM(self), RSTRING_PTR(data), length);
     }
 
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_feed_child_binary(VALUE self, VALUE data)
+rg_feed_child_binary(VALUE self, VALUE data)
 {
     glong length;
 
@@ -200,138 +307,138 @@ term_feed_child_binary(VALUE self, VALUE data)
                                        RSTRING_PTR(data), length);
     }
 
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_copy_clipboard(VALUE self)
+rg_copy_clipboard(VALUE self)
 {
     vte_terminal_copy_clipboard(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_paste_clipboard(VALUE self)
+rg_paste_clipboard(VALUE self)
 {
     vte_terminal_paste_clipboard(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_copy_primary(VALUE self)
+rg_copy_primary(VALUE self)
 {
     vte_terminal_copy_primary(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_paste_primary(VALUE self)
+rg_paste_primary(VALUE self)
 {
     vte_terminal_paste_primary(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_size(VALUE self, VALUE columns, VALUE rows)
+rg_set_size(VALUE self, VALUE columns, VALUE rows)
 {
     vte_terminal_set_size(RVAL2TERM(self), NUM2LONG(columns), NUM2LONG(rows));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_audible_bell(VALUE self, VALUE is_audible)
+rg_set_audible_bell(VALUE self, VALUE is_audible)
 {
     vte_terminal_set_audible_bell(RVAL2TERM(self), RVAL2CBOOL(is_audible));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_audible_bell(VALUE self)
+rg_audible_bell_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_audible_bell(RVAL2TERM(self)));
 }
 
 static VALUE
-term_set_visible_bell(VALUE self, VALUE is_visible)
+rg_set_visible_bell(VALUE self, VALUE is_visible)
 {
     vte_terminal_set_visible_bell(RVAL2TERM(self), RVAL2CBOOL(is_visible));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_visible_bell(VALUE self)
+rg_visible_bell_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_visible_bell(RVAL2TERM(self)));
 }
 
 static VALUE
-term_set_scroll_background(VALUE self, VALUE scroll)
+rg_set_scroll_background(VALUE self, VALUE scroll)
 {
     vte_terminal_set_scroll_background(RVAL2TERM(self), RVAL2CBOOL(scroll));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_scroll_on_output(VALUE self, VALUE scroll)
+rg_set_scroll_on_output(VALUE self, VALUE scroll)
 {
     vte_terminal_set_scroll_on_output(RVAL2TERM(self), RVAL2CBOOL(scroll));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_scroll_on_keystroke(VALUE self, VALUE scroll)
+rg_set_scroll_on_keystroke(VALUE self, VALUE scroll)
 {
     vte_terminal_set_scroll_on_keystroke(RVAL2TERM(self), RVAL2CBOOL(scroll));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_dim(VALUE self, VALUE dim)
+rg_set_color_dim(VALUE self, VALUE dim)
 {
     vte_terminal_set_color_dim(RVAL2TERM(self), RVAL2COLOR(dim));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_bold(VALUE self, VALUE bold)
+rg_set_color_bold(VALUE self, VALUE bold)
 {
     vte_terminal_set_color_bold(RVAL2TERM(self), RVAL2COLOR(bold));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_foreground(VALUE self, VALUE foreground)
+rg_set_color_foreground(VALUE self, VALUE foreground)
 {
     vte_terminal_set_color_foreground(RVAL2TERM(self), RVAL2COLOR(foreground));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_background(VALUE self, VALUE background)
+rg_set_color_background(VALUE self, VALUE background)
 {
     vte_terminal_set_color_background(RVAL2TERM(self), RVAL2COLOR(background));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_cursor(VALUE self, VALUE cursor)
+rg_set_color_cursor(VALUE self, VALUE cursor)
 {
     vte_terminal_set_color_cursor(RVAL2TERM(self),
                                   NIL_P(cursor) ? NULL : RVAL2COLOR(cursor));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_color_highlight(VALUE self, VALUE highlight)
+rg_set_color_highlight(VALUE self, VALUE highlight)
 {
     vte_terminal_set_color_highlight(RVAL2TERM(self),
                                      NIL_P(highlight) ?
                                        NULL : RVAL2COLOR(highlight));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_colors(VALUE self, VALUE foreground, VALUE background,
+rg_set_colors(VALUE self, VALUE foreground, VALUE background,
                 VALUE rb_palette)
 {
     glong i, len;
@@ -355,18 +462,18 @@ term_set_colors(VALUE self, VALUE foreground, VALUE background,
 
     vte_terminal_set_colors(RVAL2TERM(self), RVAL2COLOR(foreground),
                             RVAL2COLOR(background), palette, len);
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_default_colors(VALUE self)
+rg_set_default_colors(VALUE self)
 {
     vte_terminal_set_default_colors(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_background_image(VALUE self, VALUE image_or_path)
+rg_set_background_image(VALUE self, VALUE image_or_path)
 {
     if (RVAL2CBOOL(rb_obj_is_kind_of(image_or_path, rb_cString))) {
         vte_terminal_set_background_image_file(RVAL2TERM(self),
@@ -376,34 +483,34 @@ term_set_background_image(VALUE self, VALUE image_or_path)
                                           RVAL2GOBJ(image_or_path));
     }
 
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_background_tint_color(VALUE self, VALUE color)
+rg_set_background_tint_color(VALUE self, VALUE color)
 {
     vte_terminal_set_background_tint_color(RVAL2TERM(self), RVAL2COLOR(color));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_background_saturation(VALUE self, VALUE saturation)
+rg_set_background_saturation(VALUE self, VALUE saturation)
 {
     vte_terminal_set_background_saturation(RVAL2TERM(self),
                                            NUM2DBL(saturation));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_background_transparent(VALUE self, VALUE transparent)
+rg_set_background_transparent(VALUE self, VALUE transparent)
 {
     vte_terminal_set_background_transparent(RVAL2TERM(self),
                                             RVAL2CBOOL(transparent));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_cursor_blinks(VALUE self, VALUE blink)
+rg_set_cursor_blinks(VALUE self, VALUE blink)
 {
 #if VTE_CHECK_VERSION(0, 18, 0)
     VteTerminalCursorBlinkMode mode;
@@ -413,22 +520,22 @@ term_set_cursor_blinks(VALUE self, VALUE blink)
 #else
     vte_terminal_set_cursor_blinks(RVAL2TERM(self), RVAL2CBOOL(blink));
 #endif
-    return Qnil;
+    return self;
 }
 
 #if VTE_CHECK_VERSION(0, 18, 0)
 static VALUE
-term_set_cursor_blink_mode(VALUE self, VALUE rb_mode)
+rg_set_cursor_blink_mode(VALUE self, VALUE rb_mode)
 {
     VteTerminalCursorBlinkMode mode;
 
     mode = RVAL2GENUM(rb_mode, VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE);
     vte_terminal_set_cursor_blink_mode(RVAL2TERM(self), mode);
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_cursor_blink_mode(VALUE self)
+rg_cursor_blink_mode(VALUE self)
 {
     VteTerminalCursorBlinkMode mode;
 
@@ -439,17 +546,17 @@ term_get_cursor_blink_mode(VALUE self)
 
 #if VTE_CHECK_VERSION(0, 19, 1)
 static VALUE
-term_set_cursor_shape(VALUE self, VALUE rb_shape)
+rg_set_cursor_shape(VALUE self, VALUE rb_shape)
 {
     VteTerminalCursorShape shape;
 
     shape = RVAL2GENUM(rb_shape, VTE_TYPE_TERMINAL_CURSOR_SHAPE);
     vte_terminal_set_cursor_shape(RVAL2TERM(self), shape);
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_cursor_shape(VALUE self)
+rg_cursor_shape(VALUE self)
 {
     VteTerminalCursorShape shape;
 
@@ -457,35 +564,37 @@ term_get_cursor_shape(VALUE self)
     return GENUM2RVAL(shape, VTE_TYPE_TERMINAL_CURSOR_SHAPE);
 }
 
+#if !VTE_CHECK_VERSION(0, 20, 0)
 static VALUE
-term_get_pty(VALUE self)
+rg_pty(VALUE self)
 {
     return INT2NUM(vte_terminal_get_pty(RVAL2TERM(self)));
 }
+#endif
 
 static VALUE
-term_get_child_exit_status(VALUE self)
+rg_child_exit_status(VALUE self)
 {
     return INT2NUM(vte_terminal_get_child_exit_status(RVAL2TERM(self)));
 }
 #endif
 
 static VALUE
-term_set_scrollback_lines(VALUE self, VALUE lines)
+rg_set_scrollback_lines(VALUE self, VALUE lines)
 {
     vte_terminal_set_scrollback_lines(RVAL2TERM(self), NUM2LONG(lines));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_im_append_menuitems(VALUE self, VALUE menushell)
+rg_im_append_menuitems(VALUE self, VALUE menushell)
 {
     vte_terminal_im_append_menuitems(RVAL2TERM(self), RVAL2GOBJ(menushell));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_font(int argc, VALUE *argv, VALUE self)
+rg_set_font(int argc, VALUE *argv, VALUE self)
 {
     VALUE font_desc_or_name, rb_antialias;
     VteTerminalAntiAlias antialias = VTE_ANTI_ALIAS_USE_DEFAULT;
@@ -513,11 +622,11 @@ term_set_font(int argc, VALUE *argv, VALUE self)
             vte_terminal_set_font_full(term, font_desc, antialias);
     }
 
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_font(VALUE self)
+rg_font(VALUE self)
 {
     PangoFontDescription *font_desc;
     font_desc = (PangoFontDescription *)vte_terminal_get_font(RVAL2TERM(self));
@@ -525,78 +634,78 @@ term_get_font(VALUE self)
 }
 
 static VALUE
-term_get_using_xft(VALUE self)
+rg_using_xft_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_using_xft(RVAL2TERM(self)));
 }
 
 static VALUE
-term_set_allow_bold(VALUE self, VALUE allow_bold)
+rg_set_allow_bold(VALUE self, VALUE allow_bold)
 {
     vte_terminal_set_allow_bold(RVAL2TERM(self), RVAL2CBOOL(allow_bold));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_allow_bold(VALUE self)
+rg_allow_bold_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_allow_bold(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_has_selection(VALUE self)
+rg_has_selection_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_has_selection(RVAL2TERM(self)));
 }
 
 static VALUE
-term_set_word_chars(VALUE self, VALUE word_chars)
+rg_set_word_chars(VALUE self, VALUE word_chars)
 {
     vte_terminal_set_word_chars(RVAL2TERM(self),
                                 NIL_P(word_chars) ?
                                   NULL : RVAL2CSTR(word_chars));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_is_word_char(VALUE self, VALUE c)
+rg_word_char_p(VALUE self, VALUE c)
 {
     return CBOOL2RVAL(vte_terminal_is_word_char(RVAL2TERM(self), NUM2UINT(c)));
 }
 
 static VALUE
-term_set_backspace_binding(VALUE self, VALUE binding)
+rg_set_backspace_binding(VALUE self, VALUE binding)
 {
     vte_terminal_set_backspace_binding(RVAL2TERM(self), RVAL2EB(binding));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_set_delete_binding(VALUE self, VALUE binding)
+rg_set_delete_binding(VALUE self, VALUE binding)
 {
     vte_terminal_set_delete_binding(RVAL2TERM(self), RVAL2EB(binding));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_mouse_autohide(VALUE self)
+rg_mouse_autohide_p(VALUE self)
 {
     return CBOOL2RVAL(vte_terminal_get_mouse_autohide(RVAL2TERM(self)));
 }
 
 static VALUE
-term_set_mouse_autohide(VALUE self, VALUE setting)
+rg_set_mouse_autohide(VALUE self, VALUE setting)
 {
     vte_terminal_set_mouse_autohide(RVAL2TERM(self), RVAL2CBOOL(setting));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_reset(VALUE self, VALUE full, VALUE clear_history)
+rg_reset(VALUE self, VALUE full, VALUE clear_history)
 {
     vte_terminal_reset(RVAL2TERM(self), RVAL2CBOOL(full),
                        RVAL2CBOOL(clear_history));
-    return Qnil;
+    return self;
 }
 
 static gboolean
@@ -617,7 +726,7 @@ term_is_selected_cb(VteTerminal *terminal, glong column, glong row,
 }
 
 static VALUE
-term_get_text(int argc, VALUE *argv, VALUE self)
+rg_get_text(int argc, VALUE *argv, VALUE self)
 {
     VALUE get_attrs, include_trailing_spaces, proc, rb_text;
     GArray *attrs = NULL;
@@ -650,7 +759,7 @@ term_get_text(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-term_get_text_range(int argc, VALUE *argv, VALUE self)
+rg_get_text_range(int argc, VALUE *argv, VALUE self)
 {
     VALUE start_row, start_col, end_row, end_col, get_attrs, proc, rb_text;
     GArray *attrs = NULL;
@@ -684,7 +793,7 @@ term_get_text_range(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-term_get_cursor_position(VALUE self)
+rg_cursor_position(VALUE self)
 {
     glong column, row;
     vte_terminal_get_cursor_position(RVAL2TERM(self), &column, &row);
@@ -692,43 +801,43 @@ term_get_cursor_position(VALUE self)
 }
 
 static VALUE
-term_match_clear_all(VALUE self)
+rg_match_clear_all(VALUE self)
 {
     vte_terminal_match_clear_all(RVAL2TERM(self));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_match_add(VALUE self, VALUE match)
+rg_match_add(VALUE self, VALUE match)
 {
     return INT2NUM(vte_terminal_match_add(RVAL2TERM(self), RVAL2CSTR(match)));
 }
 
 static VALUE
-term_match_set_cursor(VALUE self, VALUE tag, VALUE cursor)
+rg_match_set_cursor(VALUE self, VALUE tag, VALUE cursor)
 {
-    vte_terminal_match_set_cursor(RVAL2TERM(self), NUM2INT(tag),
-                                  RVAL2GOBJ(cursor));
-    return Qnil;
-}
+    if (NIL_P(cursor) || RVAL2GTYPE(cursor) == GDK_TYPE_CURSOR) {
+        vte_terminal_match_set_cursor(RVAL2TERM(self), NUM2INT(tag), RVAL2GOBJ(cursor));
+    } else if (RVAL2GTYPE(cursor) == GDK_TYPE_CURSOR_TYPE) {
+        vte_terminal_match_set_cursor_type(RVAL2TERM(self), NUM2INT(tag), RVAL2CT(cursor));
+#if VTE_CHECK_VERSION(0, 17, 1)
+    } else {
+        vte_terminal_match_set_cursor_name(_SELF(self), NUM2INT(tag), RVAL2CSTR(cursor));
+#endif
+    }
 
-static VALUE
-term_match_set_cursor_type(VALUE self, VALUE tag, VALUE cursor_type)
-{
-    vte_terminal_match_set_cursor_type(RVAL2TERM(self), NUM2INT(tag),
-                                       RVAL2CT(cursor_type));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_match_remove(VALUE self, VALUE tag)
+rg_match_remove(VALUE self, VALUE tag)
 {
     vte_terminal_match_remove(RVAL2TERM(self), NUM2INT(tag));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_match_check(VALUE self, VALUE column, VALUE row)
+rg_match_check(VALUE self, VALUE column, VALUE row)
 {
     char *string;
     int tag;
@@ -745,286 +854,389 @@ term_match_check(VALUE self, VALUE column, VALUE row)
     }
 }
 
+#if !VTE_CHECK_VERSION(0, 20, 0)
 static VALUE
-term_set_emulation(VALUE self, VALUE emulation)
+rg_set_emulation(VALUE self, VALUE emulation)
 {
     vte_terminal_set_emulation(RVAL2TERM(self), RVAL2CSTR(emulation));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_emulation(VALUE self)
+rg_emulation(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_emulation(RVAL2TERM(self)));
 }
+#endif
 
 static VALUE
-term_get_default_emulation(VALUE self)
+rg_default_emulation(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_default_emulation(RVAL2TERM(self)));
 }
 
+#if !VTE_CHECK_VERSION(0, 20, 0)
 static VALUE
-term_set_encoding(VALUE self, VALUE encoding)
+rg_set_encoding(VALUE self, VALUE encoding)
 {
     vte_terminal_set_encoding(RVAL2TERM(self), RVAL2CSTR(encoding));
-    return Qnil;
+    return self;
 }
 
 static VALUE
-term_get_encoding(VALUE self)
+rg_encoding(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_encoding(RVAL2TERM(self)));
 }
+#endif
 
 static VALUE
-term_get_status_line(VALUE self)
+rg_status_line(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_status_line(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_padding(VALUE self)
+rg_padding(VALUE self)
 {
     int xpad, ypad;
     vte_terminal_get_padding(RVAL2TERM(self), &xpad, &ypad);
     return rb_ary_new3(2, INT2NUM(xpad), INT2NUM(ypad));
 }
 
+#if !VTE_CHECK_VERSION(0, 20, 0)
 static VALUE
-term_set_pty(VALUE self, VALUE pty_master)
+rg_set_pty(VALUE self, VALUE pty_master)
 {
     vte_terminal_set_pty(RVAL2TERM(self), NUM2INT(pty_master));
-    return Qnil;
+    return self;
 }
+#endif
 
 static VALUE
-term_get_adjustment(VALUE self)
+rg_adjustment(VALUE self)
 {
     return GOBJ2RVAL(vte_terminal_get_adjustment(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_char_width(VALUE self)
+rg_char_width(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_char_width(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_char_height(VALUE self)
+rg_char_height(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_char_height(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_char_descent(VALUE self)
+rg_char_descent(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_char_descent(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_char_ascent(VALUE self)
+rg_char_ascent(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_char_ascent(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_row_count(VALUE self)
+rg_row_count(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_row_count(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_column_count(VALUE self)
+rg_column_count(VALUE self)
 {
     return LONG2NUM(vte_terminal_get_column_count(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_window_title(VALUE self)
+rg_window_title(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_window_title(RVAL2TERM(self)));
 }
 
 static VALUE
-term_get_icon_title(VALUE self)
+rg_icon_title(VALUE self)
 {
     return CSTR2RVAL(vte_terminal_get_icon_title(RVAL2TERM(self)));
 }
 
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_pty_new(VALUE self, VALUE flags)
+{
+    VtePty *result;
+    GError *error = NULL;
 
-void
-Init_vte_terminal(VALUE mVte)
+    result = vte_terminal_pty_new(_SELF(self), RVAL2GFLAGS(flags, VTE_TYPE_PTY_FLAGS), &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return GOBJ2RVAL(result);
+}
+#endif
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_search_find_next(VALUE self)
 {
-    VALUE cTerminal, cTerminalEraseBinding, cTerminalAntiAlias;
-#if VTE_CHECK_VERSION(0, 18, 0)
-    VALUE cTerminalCursorBlinkMode;
+    gboolean result;
+
+    result = vte_terminal_search_find_next(_SELF(self));
+
+    return CBOOL2RVAL(result);
+}
 #endif
-#if VTE_CHECK_VERSION(0, 19, 1)
-    VALUE cTerminalCursorShape;
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_search_find_previous(VALUE self)
+{
+    gboolean result;
+
+    result = vte_terminal_search_find_previous(_SELF(self));
+
+    return CBOOL2RVAL(result);
+}
+#endif
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_search_get_wrap_around_p(VALUE self)
+{
+    gboolean result;
+
+    result = vte_terminal_search_get_wrap_around(_SELF(self));
+
+    return CBOOL2RVAL(result);
+}
+#endif
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_search_set_wrap_around(VALUE self, VALUE wrap_around)
+{
+    vte_terminal_search_set_wrap_around(_SELF(self), RVAL2CBOOL(wrap_around));
+
+    return self;
+}
+#endif
+
+#if VTE_CHECK_VERSION(0, 16, 0)
+static VALUE
+rg_select_all(VALUE self)
+{
+    vte_terminal_select_all(_SELF(self));
+
+    return self;
+}
 #endif
 
+#if VTE_CHECK_VERSION(0, 16, 0)
+static VALUE
+rg_select_none(VALUE self)
+{
+    vte_terminal_select_none(_SELF(self));
+
+    return self;
+}
+#endif
+
+static VALUE
+rg_set_opacity(VALUE self, VALUE opacity)
+{
+    vte_terminal_set_opacity(_SELF(self), NUM2UINT(opacity));
+
+    return self;
+}
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+static VALUE
+rg_watch_child(VALUE self, VALUE child_pid)
+{
+    vte_terminal_watch_child(_SELF(self), NUM2INT(child_pid));
+
+    return self;
+}
+#endif
+
+#if VTE_CHECK_VERSION(0, 24, 0)
+static VALUE
+rg_write_contents(int argc, VALUE *argv, VALUE self)
+{
+    VALUE stream, flags, rb_cancellable;
+    GCancellable *cancellable;
+    gboolean result;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "21", &stream, &flags, &rb_cancellable);
+    cancellable = NIL_P(rb_cancellable) ? NULL : RVAL2GOBJ(rb_cancellable);
+
+    result = vte_terminal_write_contents(_SELF(self),
+                                        RVAL2GOBJ(stream),
+                                        RVAL2GENUM(flags, VTE_TYPE_TERMINAL_WRITE_FLAGS),
+                                        cancellable,
+                                        &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(result);
+}
+#endif
+
+void
+Init_vte_terminal(VALUE mVte)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
     id_new = rb_intern("new");
     id_call = rb_intern("call");
 
-    id_row = rb_intern("@row");
-    id_column = rb_intern("@column");
-    id_fore = rb_intern("@fore");
-    id_back = rb_intern("@back");
-    id_underline = rb_intern("@underline");
-    id_strikethrough = rb_intern("@strikethrough");
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(VTE_TYPE_TERMINAL, "Terminal", mVte);
 
-    cTerminal = G_DEF_CLASS(VTE_TYPE_TERMINAL, "Terminal", mVte);
-    cTerminalEraseBinding = G_DEF_CLASS(VTE_TYPE_TERMINAL_ERASE_BINDING,
-                                        "TerminalEraseBinding", mVte);
+    G_DEF_CLASS(VTE_TYPE_TERMINAL_ERASE_BINDING, "EraseBinding", RG_TARGET_NAMESPACE);
 #if VTE_CHECK_VERSION(0, 18, 0)
-    cTerminalCursorBlinkMode = G_DEF_CLASS(VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE,
-					   "TerminalCursorBlinkMode", mVte);
+    G_DEF_CLASS(VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE, "CursorBlinkMode", RG_TARGET_NAMESPACE);
 #endif
 #if VTE_CHECK_VERSION(0, 19, 1)
-    cTerminalCursorShape = G_DEF_CLASS(VTE_TYPE_TERMINAL_CURSOR_SHAPE,
-				       "TerminalCursorShape", mVte);
+    G_DEF_CLASS(VTE_TYPE_TERMINAL_CURSOR_SHAPE, "CursorShape", RG_TARGET_NAMESPACE);
 #endif
-    cTerminalAntiAlias = G_DEF_CLASS(VTE_TYPE_TERMINAL_ANTI_ALIAS,
-                                     "TerminalAntiAlias", mVte);
-
-    cCharAttributes = rb_define_class_under(mVte, "CharAttributes", rb_cObject);
-
-    rb_define_method(cCharAttributes, "initialize", ca_initialize, 6);
-    rb_attr(cCharAttributes, rb_intern("row"), TRUE, FALSE, TRUE);
-    rb_attr(cCharAttributes, rb_intern("column"), TRUE, FALSE, TRUE);
-    rb_attr(cCharAttributes, rb_intern("fore"), TRUE, FALSE, TRUE);
-    rb_attr(cCharAttributes, rb_intern("back"), TRUE, FALSE, TRUE);
-    rb_define_alias(cCharAttributes, "foreground", "fore");
-    rb_define_alias(cCharAttributes, "background", "back");
-    rb_define_method(cCharAttributes, "underline?", ca_get_underline, 0);
-    rb_define_method(cCharAttributes, "strikethrough?",
-                     ca_get_strikethrough, 0);
-
-
-    rb_define_method(cTerminal, "initialize", term_initialize, 0);
-
-    rb_define_method(cTerminal, "fork_command", term_fork_command, -1);
-    rb_define_method(cTerminal, "fork_pty", term_fork_pty, -1);
-
-    rb_define_method(cTerminal, "feed", term_feed, 1);
-    rb_define_method(cTerminal, "feed_child", term_feed_child, 1);
-    rb_define_method(cTerminal, "feed_child_binary", term_feed_child_binary, 1);
-
-    rb_define_method(cTerminal, "copy_clipboard", term_copy_clipboard, 0);
-    rb_define_method(cTerminal, "paste_clipboard", term_paste_clipboard, 0);
-    rb_define_method(cTerminal, "copy_primary", term_copy_primary, 0);
-    rb_define_method(cTerminal, "paste_primary", term_paste_primary, 0);
-
-    rb_define_method(cTerminal, "set_size", term_set_size, 2);
-
-    rb_define_method(cTerminal, "set_audible_bell", term_set_audible_bell, 1);
-    rb_define_method(cTerminal, "audible_bell?", term_get_audible_bell, 0);
-    rb_define_method(cTerminal, "set_visible_bell", term_set_visible_bell, 1);
-    rb_define_method(cTerminal, "visible_bell?", term_get_visible_bell, 0);
-
-    rb_define_method(cTerminal, "set_scroll_background",
-                     term_set_scroll_background, 1);
-    rb_define_method(cTerminal, "set_scroll_on_output",
-                     term_set_scroll_on_output, 1);
-    rb_define_method(cTerminal, "set_scroll_on_keystroke",
-                     term_set_scroll_on_keystroke, 1);
-
-    rb_define_method(cTerminal, "set_color_dim", term_set_color_dim, 1);
-    rb_define_method(cTerminal, "set_color_bold", term_set_color_bold, 1);
-    rb_define_method(cTerminal, "set_color_foreground",
-                     term_set_color_foreground, 1);
-    rb_define_method(cTerminal, "set_color_background",
-                     term_set_color_background, 1);
-    rb_define_method(cTerminal, "set_color_cursor", term_set_color_cursor, 1);
-    rb_define_method(cTerminal, "set_color_highlight",
-                     term_set_color_highlight, 1);
-    rb_define_method(cTerminal, "set_colors", term_set_colors, 3);
-    rb_define_method(cTerminal, "set_default_colors",
-                     term_set_default_colors, 0);
-    rb_define_method(cTerminal, "set_background_image",
-                     term_set_background_image, 1);
-    rb_define_method(cTerminal, "set_background_tint_color",
-                     term_set_background_tint_color, 1);
-    rb_define_method(cTerminal, "set_background_saturation",
-                     term_set_background_saturation, 1);
-    rb_define_method(cTerminal, "set_background_transparent",
-                     term_set_background_transparent, 1);
-    rb_define_method(cTerminal, "set_cursor_blinks", term_set_cursor_blinks, 1);
+    G_DEF_CLASS(VTE_TYPE_TERMINAL_WRITE_FLAGS, "WriteFlags", RG_TARGET_NAMESPACE);
+
+    RG_DEF_METHOD(initialize, 0);
+
+    RG_DEF_METHOD(fork_command, -1);
+    RG_DEF_METHOD(fork_pty, -1);
+
+    RG_DEF_METHOD(feed, 1);
+    RG_DEF_METHOD(feed_child, 1);
+    RG_DEF_METHOD(feed_child_binary, 1);
+
+    RG_DEF_METHOD(copy_clipboard, 0);
+    RG_DEF_METHOD(paste_clipboard, 0);
+    RG_DEF_METHOD(copy_primary, 0);
+    RG_DEF_METHOD(paste_primary, 0);
+
+    RG_DEF_METHOD(set_size, 2);
+
+    RG_DEF_METHOD(set_audible_bell, 1);
+    RG_DEF_METHOD_P(audible_bell, 0);
+    RG_DEF_METHOD(set_visible_bell, 1);
+    RG_DEF_METHOD_P(visible_bell, 0);
+
+    RG_DEF_METHOD(set_scroll_background, 1);
+    RG_DEF_METHOD(set_scroll_on_output, 1);
+    RG_DEF_METHOD(set_scroll_on_keystroke, 1);
+
+    RG_DEF_METHOD(set_color_dim, 1);
+    RG_DEF_METHOD(set_color_bold, 1);
+    RG_DEF_METHOD(set_color_foreground, 1);
+    RG_DEF_METHOD(set_color_background, 1);
+    RG_DEF_METHOD(set_color_cursor, 1);
+    RG_DEF_METHOD(set_color_highlight, 1);
+    RG_DEF_METHOD(set_colors, 3);
+    RG_DEF_METHOD(set_default_colors, 0);
+    RG_DEF_METHOD(set_background_image, 1);
+    RG_DEF_METHOD(set_background_tint_color, 1);
+    RG_DEF_METHOD(set_background_saturation, 1);
+    RG_DEF_METHOD(set_background_transparent, 1);
+    RG_DEF_METHOD(set_cursor_blinks, 1);
 #if VTE_CHECK_VERSION(0, 18, 0)
-    rb_define_method(cTerminal, "set_cursor_blink_mode",
-		     term_set_cursor_blink_mode, 1);
-    rb_define_method(cTerminal, "cursor_blink_mode",
-		     term_get_cursor_blink_mode, 0);
+    RG_DEF_METHOD(set_cursor_blink_mode, 1);
+    RG_DEF_METHOD(cursor_blink_mode, 0);
 #endif
 #if VTE_CHECK_VERSION(0, 19, 1)
-    rb_define_method(cTerminal, "set_cursor_shape", term_set_cursor_shape, 1);
-    rb_define_method(cTerminal, "cursor_shape", term_get_cursor_shape, 0);
-    rb_define_method(cTerminal, "pty", term_get_pty, 0);
-    rb_define_method(cTerminal, "child_exit_status",
-		     term_get_child_exit_status, 0);
+    RG_DEF_METHOD(set_cursor_shape, 1);
+    RG_DEF_METHOD(cursor_shape, 0);
+#if !VTE_CHECK_VERSION(0, 20, 0)
+    RG_DEF_METHOD(pty, 0);
+#endif
+    RG_DEF_METHOD(child_exit_status, 0);
 #endif
-    rb_define_method(cTerminal, "set_scrollback_lines",
-                     term_set_scrollback_lines, 1);
-
-    rb_define_method(cTerminal, "im_append_menuitems",
-                     term_im_append_menuitems, 1);
-
-    rb_define_method(cTerminal, "set_font", term_set_font, -1);
-    rb_define_method(cTerminal, "font", term_get_font, 0);
-    rb_define_method(cTerminal, "using_xft?", term_get_using_xft, 0);
-    rb_define_method(cTerminal, "set_allow_bold", term_set_allow_bold, 1);
-    rb_define_method(cTerminal, "allow_bold?", term_get_allow_bold, 0);
-    rb_define_method(cTerminal, "has_selection?", term_get_has_selection, 0);
-    rb_define_alias(cTerminal, "have_selection?", "has_selection?");
-    rb_define_method(cTerminal, "set_word_chars", term_set_word_chars, 1);
-    rb_define_method(cTerminal, "word_char?", term_is_word_char, 1);
-    rb_define_method(cTerminal, "set_backspace_binding",
-                     term_set_backspace_binding, 1);
-    rb_define_method(cTerminal, "set_delete_binding",
-                     term_set_delete_binding, 1);
-    rb_define_method(cTerminal, "mouse_autohide?", term_get_mouse_autohide, 0);
-    rb_define_method(cTerminal, "set_mouse_autohide",
-                     term_set_mouse_autohide, 1);
-
-    rb_define_method(cTerminal, "reset", term_reset, 2);
-
-    rb_define_method(cTerminal, "get_text", term_get_text, -1);
-    rb_define_method(cTerminal, "get_text_range", term_get_text_range, -1);
-
-    rb_define_method(cTerminal, "cursor_position", term_get_cursor_position, 0);
-
-    rb_define_method(cTerminal, "match_clear_all", term_match_clear_all, 0);
-    rb_define_method(cTerminal, "match_add", term_match_add, 1);
-    rb_define_method(cTerminal, "match_set_cursor",
-                     term_match_set_cursor, 2);
-    rb_define_method(cTerminal, "match_set_cursor_type",
-                     term_match_set_cursor_type, 2);
-    rb_define_method(cTerminal, "match_remove", term_match_remove, 1);
-    rb_define_method(cTerminal, "match_check", term_match_check, 2);
-
-    rb_define_method(cTerminal, "set_emulation", term_set_emulation, 1);
-    rb_define_method(cTerminal, "emulation", term_get_emulation, 0);
-    rb_define_method(cTerminal, "default_emulation",
-                     term_get_default_emulation, 0);
-
-    rb_define_method(cTerminal, "set_encoding", term_set_encoding, 1);
-    rb_define_method(cTerminal, "encoding", term_get_encoding, 0);
-
-    rb_define_method(cTerminal, "status_line", term_get_status_line, 0);
-    rb_define_method(cTerminal, "padding", term_get_padding, 0);
-
-    rb_define_method(cTerminal, "set_pty", term_set_pty, 1);
-
-    rb_define_method(cTerminal, "adjustment", term_get_adjustment, 0);
-    rb_define_method(cTerminal, "char_width", term_get_char_width, 0);
-    rb_define_method(cTerminal, "char_height", term_get_char_height, 0);
-    rb_define_method(cTerminal, "char_descent", term_get_char_descent, 0);
-    rb_define_method(cTerminal, "char_ascent", term_get_char_ascent, 0);
-    rb_define_method(cTerminal, "row_count", term_get_row_count, 0);
-    rb_define_method(cTerminal, "column_count", term_get_column_count, 0);
-    rb_define_method(cTerminal, "window_title", term_get_window_title, 0);
-    rb_define_method(cTerminal, "icon_title", term_get_icon_title, 0);
-
-    G_DEF_SETTERS(cTerminal);
+    RG_DEF_METHOD(set_scrollback_lines, 1);
+
+    RG_DEF_METHOD(im_append_menuitems, 1);
+
+    RG_DEF_METHOD(set_font, -1);
+    RG_DEF_METHOD(font, 0);
+    RG_DEF_METHOD_P(using_xft, 0);
+    RG_DEF_METHOD(set_allow_bold, 1);
+    RG_DEF_METHOD_P(allow_bold, 0);
+    RG_DEF_METHOD_P(has_selection, 0);
+    RG_DEF_ALIAS("have_selection?", "has_selection?");
+    RG_DEF_METHOD(set_word_chars, 1);
+    RG_DEF_METHOD_P(word_char, 1);
+    RG_DEF_METHOD(set_backspace_binding, 1);
+    RG_DEF_METHOD(set_delete_binding, 1);
+    RG_DEF_METHOD_P(mouse_autohide, 0);
+    RG_DEF_METHOD(set_mouse_autohide, 1);
+
+    RG_DEF_METHOD(reset, 2);
+
+    RG_DEF_METHOD(get_text, -1);
+    RG_DEF_METHOD(get_text_range, -1);
+
+    RG_DEF_METHOD(cursor_position, 0);
+
+    RG_DEF_METHOD(match_clear_all, 0);
+    RG_DEF_METHOD(match_add, 1);
+    RG_DEF_METHOD(match_set_cursor, 2);
+    RG_DEF_METHOD(match_remove, 1);
+    RG_DEF_METHOD(match_check, 2);
+
+#if !VTE_CHECK_VERSION(0, 20, 0)
+    RG_DEF_METHOD(set_emulation, 1);
+    RG_DEF_METHOD(emulation, 0);
+#endif
+    RG_DEF_METHOD(default_emulation, 0);
+
+#if !VTE_CHECK_VERSION(0, 20, 0)
+    RG_DEF_METHOD(set_encoding, 1);
+    RG_DEF_METHOD(encoding, 0);
+#endif
+
+    RG_DEF_METHOD(status_line, 0);
+    RG_DEF_METHOD(padding, 0);
+
+#if !VTE_CHECK_VERSION(0, 20, 0)
+    RG_DEF_METHOD(set_pty, 1);
+#endif
+
+    RG_DEF_METHOD(adjustment, 0);
+    RG_DEF_METHOD(char_width, 0);
+    RG_DEF_METHOD(char_height, 0);
+    RG_DEF_METHOD(char_descent, 0);
+    RG_DEF_METHOD(char_ascent, 0);
+    RG_DEF_METHOD(row_count, 0);
+    RG_DEF_METHOD(column_count, 0);
+    RG_DEF_METHOD(window_title, 0);
+    RG_DEF_METHOD(icon_title, 0);
+
+#if VTE_CHECK_VERSION(0, 26, 0)
+    RG_DEF_METHOD(pty_new, 1);
+    RG_DEF_METHOD(search_find_next, 0);
+    RG_DEF_METHOD(search_find_previous, 0);
+    RG_DEF_METHOD_P(search_get_wrap_around, 0);
+    RG_DEF_METHOD(search_set_wrap_around, 1);
+    RG_DEF_ALIAS("search_wrap_around=", "search_set_wrap_around");
+#endif
+#if VTE_CHECK_VERSION(0, 16, 0)
+    RG_DEF_METHOD(select_all, 0);
+    RG_DEF_METHOD(select_none, 0);
+#endif
+    RG_DEF_METHOD(set_opacity, 1);
+#if VTE_CHECK_VERSION(0, 26, 0)
+    RG_DEF_METHOD(watch_child, 1);
+#endif
+#if VTE_CHECK_VERSION(0, 24, 0)
+    RG_DEF_METHOD(write_contents, -1);
+#endif
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }