relisp 0.9.1 → 0.9.2

data/lib/relisp/type_conversion/editing_types.rb

@@ -0,0 +1,1178 @@
+#--
+# Copyright (C) 2009 <don@ohspite.net>
+#
+# This file is part of Relisp.
+#
+# Relisp is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#  
+# Relisp 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#++
+#
+# See the documentation in <tt>programming_types.rb</tt>.
+#
+# Elisp editing types as described in the elisp info manual:
+#
+#   Editing Types
+#
+#   Buffer Type::         The basic object of editing.
+#   Marker Type::         A position in a buffer.
+#   Window Type::         Buffers are displayed in windows.
+#   Frame Type::	    Windows subdivide frames.
+#   Window Configuration Type::   Recording the way a frame is subdivided.
+#   Frame Configuration Type::    Recording the status of all frames.
+#   Process Type::        A process running on the underlying OS.
+#   Stream Type::         Receive or send characters.
+#   Keymap Type::         What function a keystroke invokes.
+#   Overlay Type::        How an overlay is represented.  
+#
+# There are currently no Relisp classes for frame configurations,
+# streams, and keymaps.  Frame configurations and keymaps are just
+# +cons+ with a certain keyword in the +car+.  Streams are markers,
+# buffers, strings, and functions.
+#
+# Unlike with elisp programming data types, ruby does not translate
+# the editing data types to an equivalent ruby object; instead, the
+# class corresponding to each data type is just a proxy that acts on
+# the original object in elisp.
+
+module Relisp
+
+  # A proxy to an Emacs buffer.
+  #
+  class Buffer < Proxy
+
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (_string_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing bufer in the _slave_ process.  Otherwise a new
+    # buffer is created (<tt>generate-new-buffer</tt>).  The name is
+    # _string_, if given, and a variant of "relisp-buffer" otherwise.
+    #
+    def initialize(*args)
+      super do |args|
+        name = args[0] ? args[0] : "relisp-buffer"
+        raise ArgumentError unless name.kind_of?(String)
+        @slave.elisp_exec( "(setq #{@elisp_variable} (generate-new-buffer #{name.to_elisp}))" )
+      end
+    end
+
+    private
+
+    def eval_in_buffer(code)
+      @slave.elisp_eval <<-EOM
+         (save-excursion
+           (set-buffer #{@elisp_variable})
+           #{code})
+       EOM
+    end
+
+    public
+
+    def set
+      @slave.set_buffer(@elisp_variable.value)
+    end
+    
+    # Return the name of Buffer, as a string (<tt>buffer-name</tt>).
+    #
+    def name
+      call_on_self :buffer_name
+    end
+ 
+    # Change current buffer's name to _newname_ (a string).  If
+    # _unique_ is nil, it is an error if a buffer named _newname_
+    # already exists.  If _unique_ is non-nil, come up with a new name
+    # using <tt>generate-new-buffer-name'</tt>
+    # (<tt>rename-buffer</tt>).
+    #
+    def rename(newname, unique = false)
+      eval_in_buffer "(rename-buffer #{newname.to_elisp} #{unique.to_elisp})"
+    end
+
+    # Return name of file that the Buffer is visiting, or nil if none
+    # (<tt>buffer-file-name</tt>).
+    #
+    def filename
+      call_on_self :buffer_file_name
+    end
+
+    # Change name of file visited in the Buffer to _newname_.  This
+    # also renames the buffer to correspond to the new file.  The next
+    # time the buffer is saved it will go in the newly specified file.
+    # _newname_ nil or an empty string means mark buffer as not
+    # visiting any file.
+    #
+    # The optional <em>along_with_file</em>, if non-nil, means that
+    # the old visited file has been renamed to _newname_
+    # (<tt>set-visited-file-name</tt>).
+    #
+    def filename=(newname, along_with_file=false)
+      # the second argument here inhibits confirmation in the case
+      # where another buffer is already visiting _newname_.
+      eval_in_buffer "(set-visited-file-name #{newname.to_elisp} t #{along_with_file.to_elisp})"
+    end
+
+    def modified?
+      call_on_self :buffer_modified_p
+    end
+
+    def set_modified(flag=true)
+      eval_in_buffer "(set-buffer-modified-p #{flag.to_elisp})"
+    end
+
+    def modified=(flag)
+      set_modified(flag)
+    end
+
+    def modified_tick
+      call_on_self :buffer_modified_tick
+    end
+
+    def chars_modified_tick
+      call_on_self :buffer_chars_modified_tick
+    end
+
+    def read_only?
+      eval_in_buffer "buffer-read-only"
+    end
+
+    def read_only=(flag)
+      eval_in_buffer "(setq buffer-read-only #{flag.to_elisp})"
+    end
+
+    def bury
+      call_on_self :bury_buffer
+      if @slave.elisp_eval "(equal (current-buffer) #{self.to_elisp})"
+        @slave.elisp_exec "(switch-to-buffer (other-buffer))"
+      end
+    end
+
+    def kill
+      raise if modified?
+      call_on_self :kill_buffer
+    end
+
+    def kill!
+      set_modified(false)
+      kill
+    end
+
+    def alive?
+      call_on_self :buffer_live_p
+    end
+
+    # Save the buffer in its visited file, if it has been modified
+    # (<tt>save-buffer</tt>).
+    #
+    def save
+      raise "Attempt to save buffer with no filename." unless filename
+      eval_in_buffer "(with-output-to-string (save-buffer))"
+    end
+    
+    def write(newfile)
+      eval_in_buffer "(with-output-to-string (write-file #{newfile.to_elisp}))"
+    end
+
+    def size
+      call_on_self :buffer_size
+    end
+
+    def substring(start_position, end_position)
+      eval_in_buffer "(buffer-substring #{start_position} #{end_position})"
+    end
+
+    def substring_no_properties(start_position, end_position)
+      eval_in_buffer "(buffer-substring-no-properties #{start_position} #{end_position})"
+    end
+
+    def to_s
+      eval_in_buffer "(buffer-string)"
+    end
+
+    def erase
+      eval_in_buffer "(erase-buffer)"      
+    end
+
+    def window
+      call_on_self :get_buffer_window
+    end
+
+    def window=(new_window)
+      new_window.buffer = self
+    end
+
+    def windows
+      call_on_self :get_buffer_window_list
+    end
+
+    def insert(object)
+      eval_in_buffer "(insert #{object.to_elisp})"
+    end
+
+    alias print insert
+
+    def puts(object="")
+      line_number = @slave.line_number_at_pos
+      insert object
+      if line_number == @slave.line_number_at_pos
+        insert "\n"
+      end
+    end
+
+    def <<(object)
+      @slave.save_excursion do 
+        set
+        @slave.elisp_eval "(goto-char (point-max))"
+        insert object
+      end
+      return self
+    end
+
+    def ==(buffer2)
+      @slave.elisp_eval "(equal #{to_elisp} #{buffer2.to_elisp})"
+    end
+
+    def method_missing(method, *args)
+      @slave.save_excursion do 
+        set
+        @slave.send(method, *args)
+      end
+    end
+  end
+
+  # A  proxy to an Emacs marker.
+  #
+  class Marker < Proxy
+
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing marker in the _slave_ process.  Otherwise a new,
+    # empty marker is created (<tt>make-marker</tt>).
+    #
+    def initialize(*args)
+      super do 
+        @slave.elisp_exec( "(setq #{@elisp_variable} (make-marker))" )
+      end
+    end
+
+    def position
+      call_on_self :marker_position
+    end
+
+    def buffer
+      call_on_self :marker_buffer
+    end
+
+    def insertion_type
+      call_on_self :marker_insertion_type
+    end
+
+    def insertion_type=(type)
+      @slave.elisp_eval( "(set-marker-insertion-type #{@elisp_variable} #{type.to_elisp})" )
+    end
+
+    def set(new_position, new_buffer=nil)
+      @slave.elisp_exec( "(set-marker #{@elisp_variable} #{new_position} #{new_buffer})" )
+    end
+
+    alias move set
+    alias position= set
+  end
+
+  # A  proxy to an Emacs window
+  #
+  class Window < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing window in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create Window using 'new' method."
+      end
+    end
+
+    private
+
+    def eval_in_window(code)
+      @slave.elisp_eval <<-EOM
+         (with-selected-window #{@elisp_variable}
+           #{code})
+       EOM
+    end
+
+    public
+
+    def split(size=nil, horizontal=false)
+      call_on_self :split_window, size, horizontal
+    end
+
+    def split_horizontally(size=nil)
+      split(size, true)
+    end
+
+    def split_vertically(size=nil)
+      split(size, false)
+    end
+
+    def alive?
+      call_on_self :window_live_p
+    end
+
+    def delete
+      call_on_self :delete_window
+    end
+
+    def delete_others
+      call_on_self :delete_other_windows
+    end
+
+    def select
+      call_on_self :select_window
+    end
+
+    def buffer
+      call_on_self :window_buffer
+    end
+
+    def buffer=(new_buffer)
+      call_on_self :set_window_buffer, new_buffer
+    end
+
+    def dedicated
+      call_on_self :window_dedicated_p
+    end
+
+    def dedicated=(flag)
+      call_on_self :set_window_dedicated_p, flag
+    end
+
+    def point
+      call_on_self :window_point
+    end
+
+    def point=(position)
+      call_on_self :set_window_point, position
+    end
+
+    def start
+#      eval_in_window "(window-start)"
+      call_on_self :window_start
+    end
+
+    def start=(position)
+      call_on_self :set_window_start, position
+    end
+
+    def end 
+      call_on_self :window_end
+    end
+
+    def visible?(position)
+      @slave.elisp_eval( "(pos-visible-in-window-p #{position.to_elisp} #{@elisp_variable})" )
+    end
+
+    def scroll_up(count=nil)
+      eval_in_window "(scroll-up #{count.to_elisp})"
+    end
+
+    def scroll_down(count=nil)
+      eval_in_window "(scroll-down #{count.to_elisp})"
+    end
+
+    def recenter(count=nil)
+      eval_in_window "(recenter #{count.to_elisp})"
+    end
+
+    def vscroll
+      call_on_self :window_vscroll
+    end
+
+    def vscroll_in_pixels
+      call_on_self :window_vscroll, true
+    end
+
+    def vscroll=(lines)
+      call_on_self :set_window_vscroll, lines
+    end
+
+    def vscroll_in_pixels=(pixels)
+      call_on_self :set_window_vscroll, pixels, true
+    end
+
+    def scroll_left(count=nil)
+      eval_in_window "(scroll-left #{count.to_elisp})"
+    end
+
+    def scroll_right(count=nil)
+      eval_in_window "(scroll-right #{count.to_elisp})"
+    end
+    
+    def hscroll
+      call_on_self :window_hscroll
+    end
+
+    def hscroll=(columns)
+      call_on_self :set_window_hscroll, columns
+    end
+
+    def height
+      call_on_self :window_height
+    end
+
+    def body_height
+      call_on_self :window_body_height
+    end
+
+    def width
+      call_on_self :window_width
+    end
+
+    def edges
+      (call_on_self :window_edges).to_list
+    end
+
+    def inside_edges
+      (call_on_self :window_inside_edges).to_list
+    end
+
+    def pixel_edges
+      (call_on_self :window_pixel_edges).to_list
+    end
+
+    def inside_pixel_edges
+      (call_on_self :window_inside_pixel_edges).to_list
+    end
+
+    def enlarge(vertical, horizontal=0)
+      eval_in_window "(enlarge-window #{vertical.to_elisp})"
+      eval_in_window "(enlarge-window-horizontally #{horizontal.to_elisp})"
+    end
+
+    def shrink(vertical, horizontal=0)
+      eval_in_window "(shrink-window #{vertical.to_elisp})"
+      eval_in_window "(shrink-window-horizontally #{horizontal.to_elisp})"
+    end
+
+    def frame
+      call_on_self :window_frame
+    end
+
+    def ==(window2)
+      @slave.elisp_eval "(equal #{to_elisp} #{window2.to_elisp})"
+    end
+
+  end
+
+  # A proxy to an Emacs frame
+  #
+  class Frame < Proxy
+
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (<em>option_hash = {}</em>, <em>slave = Relisp.default_slave</em>)
+    # * (<em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing frame in the _slave_ process.  Otherwise a new
+    # frame is created using any options in (<tt>new-frame</tt>).
+    #
+    # The _option_hash_ can specify the following
+    # [<tt>:name =></tt> _string_] 
+    #      The frame should be named _string_.
+    # [<tt>:width =></tt> _fixnum_] 
+    #      The frame should be _fixnum_ characters in width.
+    # [<tt>:height =></tt> _fixnum_] 
+    #      The frame should be _fixnum_ text lines high.
+    #
+    # You cannot specify either :width or :height, you must use neither or both.
+    #
+    # [<tt>:minibuffer => true</tt>]
+    #      The frame should have a minibuffer.
+    # [<tt>:minibuffer => nil</tt>]
+    #      The frame should have no minibuffer.
+    # [<tt>:minibuffer => :only</tt>] 
+    #      The frame should contain only a minibuffer.
+    # [<tt>:minibuffer =></tt> _window_] 
+    #      The frame should use _window_ as its minibuffer window.
+    #
+    # [<tt>:"window-system" => nil</tt>] 
+    #      The frame should be displayed on a terminal device.
+    # [<tt>:"window-system" => :x</tt>] 
+    #      The frame should be displayed in an X window.
+    # [<tt>:terminal =></tt> _id_] 
+    #      The frame should use the terminal identified by _id_.
+    #
+    def initialize(*args)
+      super do |args|
+        hash = args[0]
+        alist = ""
+        if hash && hash.size > 1
+          alist << "'("
+          hash.each_pair do |key, val|
+            val = if val.kind_of?(Symbol)
+                    val.value.to_elisp
+                  else
+                    val.to_elisp
+                  end
+            alist << "(#{key} . #{val.to_s}) "
+          end
+          alist << ")"
+        end
+
+        @slave.elisp_exec( "(setq #{@elisp_variable} (make-frame #{alist}))" )
+      end
+    end
+
+    def delete
+      call_on_self :delete_frame
+    end
+
+    def alive?
+      call_on_self :frame_live_p
+    end
+
+    def selected_window
+      call_on_self :frame_selected_window
+    end
+
+    def selected_window=(window)
+      call_on_self :set_frame_selected_window, window
+    end
+    
+    def focus
+      call_on_self :select_frame_set_input_focus
+    end
+
+    def select
+      call_on_self :select_frame
+    end
+
+    def visible?
+      call_on_self :frame_visible_p
+    end
+
+    def show
+      call_on_self :make_frame_visible
+    end
+
+    def hide
+      call_on_self :make_frame_invisible
+    end
+
+    def iconify
+      call_on_self :inconify_frame
+    end
+
+    def raise
+      call_on_self :raise_frame
+    end
+
+    def lower
+      call_on_self :lower_frame
+    end
+
+    private
+    
+    def get_parameter(parameter)
+      call_on_self :frame_parameter, parameter
+    end
+
+    def set_parameter(parameter, new_value)
+      alist = Cons.new(Cons.new(parameter, new_value), nil)
+      call_on_self :modify_frame_parameters, alist
+    end
+
+    public
+
+    ######### begin frame parameters
+
+    #
+    def display
+      get_parameter :display
+    end
+
+    def display=(new_value)
+      set_parameter :display, new_value
+    end
+
+    def display_type
+      get_parameter :display_type
+    end
+
+    def display_type=(new_value)
+      set_parameter :display_type, new_value
+    end
+
+    def title
+      get_parameter :title
+    end
+
+    def title=(new_value)
+      set_parameter :title, new_value
+    end
+
+    def name
+      get_parameter :name, new_value
+    end
+
+    def name=(new_value)
+      set_parameter :name, new_value
+    end
+
+    def left
+      get_parameter :left
+    end
+
+    def left=(new_value)
+      set_parameter :left, new_value
+    end
+
+    def top
+      get_parameter :top
+    end
+    
+    def top=(new_value)
+      set_parameter :top, new_value
+    end
+
+    def height
+      get_parameter :height
+    end
+    
+    def height=(new_value)
+      set_parameter :height, new_value
+    end
+
+    def width
+      get_parameter :width
+    end
+
+    def width=(new_value)
+      set_parameter :width, new_value
+    end
+
+    def fullscreen
+      get_parameter :fullscreen
+    end
+
+    def fullscreen=(new_value)
+      set_parameter :fullscreen, new_value
+    end
+
+    def border_width
+      get_parameter :border_width
+    end
+
+    def border_width=(new_value)
+      set_parameter :border_width, new_value
+    end
+
+    def internal_border_width
+      get_parameter :internal_border_width
+    end
+
+    def internal_border_width=(new_value)
+      set_parameter :internal_border_width, new_value
+    end
+
+    def vertical_scroll_bars
+      get_parameter :vertical_scroll_bars
+    end
+
+    def vertical_scroll_bars=(new_value)
+      set_parameter :vertical_scroll_bars, new_value
+    end
+    
+    def scroll_bar_width
+      get_parameter :scroll_bar_width
+    end
+
+    def scroll_bar_width=(new_value)
+      set_parameter :scroll_bar_width, new_value
+    end
+
+    def left_fringe
+      get_parameter :left_fringe
+    end
+
+    def left_fringe=(new_value)
+      set_parameter :left_fringe, new_value
+    end
+
+    def right_fringe
+      get_parameter :right_fringe
+    end
+
+    def right_fringe=(new_value)
+      set_parameter :right_fringe, new_value
+    end
+
+    def menu_bar_lines
+      get_parameter :menu_bar_lines
+    end
+
+    def menu_bar_lines=(new_value)
+      set_parameter :menu_bar_lines, new_value
+    end
+    
+    def tool_bar_lines
+      get_parameter :tool_bar_lines
+    end
+
+    def tool_bar_lines=(new_value)
+      set_parameter :tool_bar_lines, new_value
+    end
+    
+    def line_spacing
+      get_parameter :line_spacing
+    end
+
+    def line_spacing=(new_value)
+      set_parameter :line_spacing, new_value
+    end
+    
+    def minibuffer
+      get_parameter :minibuffer
+    end
+
+    def minibuffer=(new_value)
+      set_parameter :minibuffer, new_value
+    end
+    
+    def unsplittable
+      get_parameter :unsplittable
+    end
+
+    def unsplittable=(new_value)
+      set_parameter :unsplittable, new_value
+    end
+
+    def visibility
+      get_parameter :visibility
+    end
+
+    def visibility=(new_value)
+      set_parameter :visibility, new_value
+    end
+    
+    def auto_raise
+      get_parameter :auto_raise
+    end
+
+    def auto_raise=(new_value)
+      set_parameter :auto_raise, new_value
+    end
+
+    def auto_lower
+      get_parameter :auto_lower
+    end
+
+    def auto_lower=(new_value)
+      set_parameter :auto_lower, new_value
+    end
+
+    def icon_type
+      get_parameter :icon_type
+    end
+
+    def icon_type=(new_value)
+      set_parameter :icon_type, new_value
+    end
+    
+    def icon_name
+      get_parameter :icon_name
+    end
+
+    def icon_name=(new_value)
+      set_parameter :icon_name, new_value
+    end
+    
+    def window_id
+      get_parameter :window_id
+    end
+
+    def window_id=(new_value)
+      set_parameter :window_id, new_value
+    end
+    
+    def outer_window_id
+      get_parameter :outer_window_id
+    end
+
+    def outer_window_id=(new_value)
+      set_parameter :outer_window_id, new_value
+    end
+    
+    def wait_for_wm
+      get_parameter :wait_for_wm
+    end
+
+    def wait_for_wm=(new_value)
+      set_parameter :wait_for_wm, new_value
+    end
+    
+    def cursor_type
+      get_parameter :cursor_type
+    end
+
+    def cursor_type=(new_value)
+      set_parameter :cursor_type, new_value
+    end
+    
+    def background_mode
+      get_parameter :background_mode
+    end
+
+    def background_mode=(new_value)
+      set_parameter :background_mode, new_value
+    end
+
+    def tty_color_mode
+      get_parameter :tty_color_mode
+    end
+
+    def tty_color_mode=(new_value)
+      set_parameter :tty_color_mode, new_value
+    end
+
+    def screen_gamma
+      get_parameter :screen_gamma
+    end
+
+    def screen_gamma=(new_value)
+      set_parameter :screen_gamma, new_value
+    end
+
+    def font
+      get_parameter :font
+    end
+
+    def font=(new_value)
+      set_parameter :font, new_value
+    end
+
+    def foreground_color
+      get_parameter :foreground_color
+    end
+
+    def foreground_color=(new_value)
+      set_parameter :foreground_color, new_value
+    end
+
+    def background_color
+      get_parameter :background_color
+    end
+
+    def background_color=(new_value)
+      set_parameter :background_color, new_value
+    end
+
+    def mouse_color
+      get_parameter :mouse_color
+    end
+
+    def mouse_color=(new_value)
+      set_parameter :mouse_color, new_value
+    end
+
+    def cursor_color
+      get_parameter :cursor_color
+    end
+
+    def cursor_color=(new_value)
+      set_parameter :cursor_color, new_value
+    end
+
+    def border_color
+      get_parameter :border_color
+    end
+
+    def border_color=(new_value)
+      set_parameter :border_color, new_value
+    end
+
+    def scroll_bar_foreground
+      get_parameter :scroll_bar_foreground
+    end
+
+    def scroll_bar_foreground=(new_value)
+      set_parameter :scroll_bar_foreground, new_value
+    end
+
+    def scroll_bar_background
+      get_parameter :scroll_bar_background
+    end
+
+    def scroll_bar_background=(new_value)
+      set_parameter :scroll_bar_background, new_value
+    end
+
+    ######### end frame parameters
+    
+  end
+  
+  # A  proxy to an Emacs window-configuration
+  #
+  class WindowConfiguration < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing window-configuration in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create WindowConfiguration using 'new' method."
+      end
+    end
+  end
+
+  # A  proxy to an Emacs process
+  #
+  class Process < Proxy
+
+    # _args_ must be of the form (_symbol_, <em>slave =
+    # Relisp.default_slave</em>)
+    #
+    # The _symbol_ argument is considered to be the name of a
+    # pre-existing process in the _slave_ process.  
+    #
+    def initialize(*args)
+      super do 
+        raise ArgumentError, "Cannot create Process using 'new' method."
+      end
+    end
+    
+    def name
+      call_on_self :process_name
+    end
+
+    def status
+      call_on_self :process_status
+    end
+
+    def exit_status
+      call_on_self :process_exit_status
+    end
+  end
+  
+  # A  proxy to an Emacs Overlay
+  #
+  class Overlay < Proxy
+    
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (_start_, _end_, <em>buffer = nil</em>, <em>front_advance = nil</em>, <em>rear_advance = nil</em>, <em>slave = Relisp.default_slave</em>)
+    # * (_start_, _end_, <em>buffer = nil</em>, <em>slave = Relisp.default_slave</em>)
+    # * (_start_, _end_, <em>slave = Relisp.default_slave</em>)
+    #
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing overlay in the _slave_ process.  Otherwise a new
+    # overlay is created (<tt>make-overlay</tt>).     
+    #
+    def initialize(*args)
+      super do |args|
+        @slave.elisp_exec( "(setq #{@elisp_variable} (make-overlay #{args.join(' ')}))" )
+      end
+    end
+
+    def start
+      call_on_self :overlay_start
+    end
+
+    def end
+      call_on_self :overlay_end
+    end
+
+    def buffer
+      call_on_self :overlay_buffer
+    end
+
+    def delete
+      call_on_self :delete_overlay
+    end
+
+    def move(new_start, new_end, new_buffer = nil)
+      call_on_self :move_overlay, new_start, new_end, new_buffer
+    end
+
+    def start=(new_start)
+      call_on_self :move_overlay, new_start, self.end
+    end
+
+    def end=(new_end)
+      call_on_self :move_overlay, self.start, new_end
+    end
+
+    private
+    
+    def get_property(property)
+      call_on_self :overlay_get, property
+    end
+
+    def set_property(property, new_value)
+      call_on_self :overlay_put, property, new_value
+    end
+
+    public
+    
+    def priority
+      get_property :priority
+    end
+
+    def priority=(new_value)
+      set_property :priority, new_value
+    end
+
+    def window
+      get_property :window
+    end
+
+    def window=(new_value)
+      set_property :window, new_value
+    end
+
+    def category
+      get_property :category
+    end
+
+    def category=(new_value)
+      set_property :category, new_value
+    end
+   
+    def face
+      get_property :face
+    end
+
+    def face=(new_value)
+      set_property :face, new_value
+    end
+
+    def mouse_face
+      get_property :mouse_face
+    end
+    
+    def mouse_face=(new_value)
+      set_property :mouse_face, new_value
+    end
+
+    def display
+      get_property :display
+    end
+
+    def display=(new_value)
+      set_property :display, new_value
+    end
+
+    def help_echo
+      get_property :help_echo
+    end
+
+    def help_echo=(new_value)
+      set_property :help_echo, new_value
+    end
+
+    def modification_hooks
+      get_property :help_echo
+    end
+
+    def modification_hooks=(new_value)
+      set_property :help_echo, new_value
+    end
+
+    def insert_in_front_hooks
+      get_property :insert_in_front_hooks
+    end
+
+    def insert_in_front_hooks=(new_value)
+      set_property :insert_in_front_hooks, new_value
+    end
+
+    def insert_behind_hooks
+      get_property :insert_behind_hooks
+    end
+
+    def insert_behind_hooks=(new_value)
+      set_property :insert_behind_hooks, new_value
+    end
+
+    def invisible
+      get_property :invisible
+    end
+
+    def invisible=(new_value)
+      set_property :invisible, new_value
+    end
+
+    def intangible
+      get_property :intangible
+    end
+
+    def intangible=(new_value)
+      set_property :intangible, new_value
+    end
+
+    def before_string
+      get_property :before_string
+    end
+
+    def before_string=(new_value)
+      set_property :before_string, new_value
+    end
+
+    def after_string
+      get_property :after_string
+    end
+
+    def after_string=(new_value)
+      set_property :after_string, new_value
+    end
+
+    def evaporate
+      get_property :evaporate
+    end
+
+    def evaporate=(new_value)
+      set_property :evaporate, new_value
+    end
+
+    def local_map
+      get_property :local_map
+    end
+
+    def local_map=(new_value)
+      set_property :local_map, new_value
+    end
+
+    def keymap
+      get_property :keymap
+    end
+
+    def keymap=(new_value)
+      set_property :keymap, new_value
+    end
+
+  end
+  
+end
+