gtk_app 0.1.2 → 0.2.0

data/lib/gtk_app.rb

@@ -12,24 +12,34 @@ module GtkApp
   autoload :SignalSupport, "#{lib}/gtk_app/signal_support"
   autoload :TextBuffer,    "#{lib}/gtk_app/text_buffer"
   autoload :Observer,      "#{lib}/gtk_app/observer"
+  autoload :Drawer,        "#{lib}/gtk_app/drawer"
   autoload :Version,       "#{lib}/gtk_app/version"
 
+  # Start the main Gtk loop.
   def self.run
     Gtk::main
   end
-  
+
+  # Stop the main Gtk loop.
   def self.quit
     Gtk::main_quit
   end
-  
+
+  # Run a single iteration of the main loop while there are pending events 
+  # without blocking.
   def self.refresh
     Gtk::main_iteration_do(false) while Gtk::events_pending?
   end
 
+  # Establish a controller method to be invoked at regular intervals.
+  # @param [Fixnum] time_in_milliseconds Time between calls to the receiver method.
+  # @param [Object] controller The class in which the method exists.
+  # @param [String] callback  Receiver method name.
   def self.add_timeout(time_in_milliseconds, controller, callback)
     GLib::Timeout.add(time_in_milliseconds){ controller.method(:"#{callback}") }
   end
 
 end
 
-require 'gtk_app/dialog'
+require 'gtk_app/ext/text_view'
+# require 'gtk_app/dialog'

data/lib/gtk_app/application.rb

@@ -0,0 +1,13 @@
+module GtkApp
+  module Application
+
+    def run
+      Gtk.main
+    end
+    
+    def quit
+      Gtk.main_quit
+    end
+
+  end
+end

data/lib/gtk_app/callback_support.rb

@@ -0,0 +1,5 @@
+module GtkApp
+module CallbackSupport
+  include ActiveSupport::Callbacks
+end
+end

data/lib/gtk_app/controller.rb

@@ -3,14 +3,18 @@ class Controller
   include GtkApp::Helpers
   include GtkApp::SignalSupport
 
-  attr_accessor :model, :view
+  # @attribute [rw] model
+  attr_accessor :model
+  # @attr_accessor [rw] view
+  attr_accessor :view
 
   def initialize(&block)
     instance_eval(&block) if block_given?
-    
+
     establish_signal_connections
   end
 
+  # @param [Boolean] with_validations
   def quit(with_validations=true)
     # TODO: if with_validations
     # end

data/lib/gtk_app/ext/combo_box.rb

@@ -0,0 +1,11 @@
+module Gtk
+  class ComboBox
+ 
+    # @param [Object, #to_s] text
+    def <<(text)
+      append_text(text.to_s)
+    end
+
+  end
+end
+  

data/lib/gtk_app/ext/text_buffer.rb

@@ -0,0 +1,272 @@
+require 'raspell'
+
+module Gtk
+class TextBuffer
+
+  # @attr_accessor [Aspell] spell_check
+  attr_accessor:spell_check
+  # @attr_accessor [Array] undo_stack
+  attr_accessor:undo_stack
+  # @attr_accessor [Array] redo_stack
+  attr_accessor:redo_stack
+  # @attr_accessor [Gtk::TextMark] insert_start
+  attr_accessor:insert_start
+  # @attr_accessor [Gtk::TextMark] insert_end
+  attr_accessor:insert_end
+
+  DEFAULT_LANG = "en_US"
+  DEFAULT_TAGS = %w[bold italic strikethrough underline error spell_error]
+
+  def initialize(tag_table=nil, options={})
+    super(tag_table)
+    @undo_stack, @redo_stack = [], []
+    @spell_check = Aspell.new(options[:lang] || DEFAULT_LANG)
+    setup_default_tags
+    setup_spell_check_marks
+    setup_signals
+  end
+
+  # Pop the last action off the undo stack and rewind changes. If an action was
+  # performed, the cursor is placed at the actions starting 
+  # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter].
+  def undo
+    if @undo_stack.empty?
+      Gdk.beep
+    else
+      action = @undo_stack.pop
+      s_iter = get_iter_at_offset(action[1])
+      case action[0]
+      when :insert then delete(s_iter, get_iter_at_offset(action[2]))
+      when :delete then insert(s_iter, action[3])
+      end
+      @redo_stack.push(action)
+      place_cursor(s_iter)
+    end
+  end
+
+  # Pop the last action off the redo stack and apply the changes.  If and action
+  # was performed, the cursor is placed at the actions starting 
+  # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter].
+  def redo
+    if @redo_stack.empty?
+      Gdk.beep
+    else
+      action = @redo_stack.pop
+      s_iter = get_iter_at_offset(action[1])
+      e_iter = get_iter_at_offset(action[2])
+      case action[0]
+      when :insert then insert(s_iter, action[3])
+      when :delete then delete(s_iter, e_iter)
+      end
+      @undo_stack.push(action)
+      place_cursor(s_iter)
+    end
+  end
+
+  # Retrieve the word at the current cursor position
+  # @return [String] The word.
+  def word_at_cursor
+    get_text(*word_bounds).strip
+  end
+
+  # Determine the boudaries of the word at the current cursor position.
+  # @return [Array] The start and end iter.
+  def word_bounds
+    iter = get_iter_at_offset(cursor_position)
+    s_iter, e_iter = iter.clone, iter.clone
+    s_iter.backward_word_start unless s_iter.starts_word?
+    e_iter.forward_word_end unless e_iter.ends_word?
+
+    [s_iter, e_iter]
+  end
+
+  def check_spelling(s_iter=nil, e_iter=nil)
+    s_iter = bounds.first if s_iter.nil?
+    e_iter = bounds.last  if e_iter.nil?
+
+    e_iter.forward_word_end if e_iter.inside_word?
+
+    unless s_iter.starts_word?
+      if s_iter.inside_word? || s_iter.ends_word?
+        s_iter.backward_word_start
+      elsif s_iter.forward_word_end
+        s_iter.backward_word_start
+      end
+    end
+
+    cursor = get_iter_at_offset(cursor_position)
+    precursor = cursor.clone
+    precursor.backward_char
+    tag = tag_table.lookup('spell_error')
+    has_error = cursor.has_tag?(tag) || precursor.has_tag?(tag)
+
+    unformat(:spell_error, s_iter, e_iter)
+
+    word_start = s_iter.clone
+    while (word_start <=> e_iter) < 0 do
+      word_end = word_start.clone
+      word_end.forward_word_end
+
+      word = get_text(word_start, word_end)
+      if !has_error && word =~ /[A-Za-z]/ && !@spell_check.check(word)
+        # puts "[#{word}]"
+        format(:spell_error, word_start, word_end)
+      end
+
+      # => meow point to the beginning of the next word.
+      word_end.forward_word_end
+      word_end.backward_word_start
+
+      break if word_start == word_end
+
+      word_start = word_end.clone
+    end
+  end
+
+  # Does the 
+  # Gtk::TextTagTable[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextTagTable] 
+  # contain any 'spell_error' tags?
+  def spelling_errors?
+    !tag_table.lookup('spell_error').nil?
+  end
+
+  # Locate text in selection or the entire buffer.  If found, a 
+  # Gtk::TextMark[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextMark]
+  # is returned.  Else, nil.
+  # @param [String] string Text to search.
+  def find(string)
+    s_iter, e_iter, text_selected = selection_bounds
+    s_iter = start_iter unless text_selected
+    s_iter, e_iter = s_iter.forward_search(string, Gtk::TextIter::SEARCH_TEXT_ONLY, e_iter)
+    s_iter ? create_mark(nil, s_iter, false) : nil
+  end
+
+  # @param [String] string Text to replace the selection with.
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def replace(string, s_iter, e_iter)
+    begin_user_action
+    delete(s_iter, e_iter)
+    insert(s_iter, string)
+    end_user_action
+    place_cursor(s_iter)
+  end
+
+  # Format text in the current selection range with a 
+  # Gtk::TextTag[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextTag] 
+  # identified by the given name.
+  # @param [String] tag_name
+  def format_selection(tag_name)
+    s_iter, e_iter, text_selected = selection_bounds
+    format(tag_name, s_iter, e_iter) if text_selected
+  end
+  
+  # This is a small wrapper around the 
+  # Gtk::TextBuffer#apply_tag[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextBuffer#apply_tag] 
+  # method.  It  allows the Gtk::TextTag name to be passed as a symbol.
+  # @param [] tag_name
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def format(tag_name, s_iter, e_iter)
+    apply_tag(tag_name.to_s, s_iter, e_iter)
+  end
+
+  # Remove all tags of a given name from from one
+  # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter] 
+  # to another.
+  # @param [] tag_name
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def unformat(tag_name, s_iter, e_iter)
+    remove_tag(tag_name.to_s, s_iter, e_iter)
+  end
+
+  # Remove all occurrences of a 
+  # Gtk::TextTag[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextTag] 
+  # in the given selection range.
+  def unformat_selection(*tag_names)
+    s_iter, e_iter, text_selected = selection_bounds
+    if text_selected
+      if tag_names.empty?
+        clear_all(s_iter, e_iter)
+      else
+        tag_names.each { |tag_name| unformat(tag_name, s_iter, e_iter) }
+      end
+    end
+  end
+
+  # Remove all Gtk::TextTag's from one 
+  # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter] 
+  # to another.
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def unformat_all(s_iter, e_iter)
+    remove_all_tags(s_iter, e_iter)
+  end
+
+  private
+
+    # Establish default tag names for everyday text formatting.
+    def setup_default_tags
+      DEFAULT_TAGS.each do |name|
+        attibs = case name
+        when 'bold'          then { weight: Pango::WEIGHT_BOLD }
+        when 'italic'        then { style: Pango::STYLE_ITALIC }
+        when 'strikethrough' then { strikethrough: true }
+        when 'underline'     then { underline: Pango::UNDERLINE_SINGLE }
+        when 'error'         then { underline: Pango::UNDERLINE_ERROR }
+        when 'spell_error'   then { underline: Pango::UNDERLINE_ERROR }
+        end
+        create_tag(name, attibs)
+      end
+    end
+
+    def setup_spell_check_marks
+      s_iter, e_iter = bounds
+      @insert_start = create_mark('insert-start', s_iter, true)
+      @insert_end   = create_mark('insert-end',   s_iter, true)
+    end
+
+    # Establish base signal handlers.  Here we track user actions and...
+    def setup_signals
+      signal_connect('begin-user-action') { |me| @user_action = true  }
+      signal_connect('end-user-action')   { |me| @user_action = false }
+
+      signal_connect('insert-text') do |me, iter, text, len|
+        if user_action?
+          me.undo_stack << [ :insert, iter.offset, 
+                           (iter.offset + text.scan(/./).size), text ]
+          me.redo_stack.clear
+        end
+        me.move_mark(me.insert_start, iter)
+      end
+
+      signal_connect_after('insert-text') do |me, iter, text, len|
+        s_iter = me.get_iter_at_mark(me.insert_start)
+        me.check_spelling(s_iter, iter)
+        me.insert_end = iter
+      end
+
+      signal_connect('delete-range') do |me, s_iter, e_iter|
+        if user_action?
+          me.undo_stack << [ :delete, s_iter.offset, e_iter.offset, text, 
+                             me.get_text(s_iter, e_iter) ]
+        end
+      end
+
+      signal_connect_after('delete-range') do |me, s_iter, e_iter|
+        me.check_spelling(s_iter, e_iter)
+      end
+
+      # TODO: Add suggestion popups for spelling erros.
+      # tag_table.lookup('spell_error').signal_connect('event') do |tag|
+      #   p tag
+      # end
+    end
+
+    def user_action?
+      @user_action
+    end
+
+end
+end

data/lib/gtk_app/ext/text_view.rb

@@ -0,0 +1,55 @@
+module Gtk
+  class TextView
+
+    alias_method :gtk2_initialize, :initialize
+    alias_method :gtk2_buffer=, :buffer=
+
+    def initialize(buffer = nil)
+      self.buffer = buffer
+      self.gtk2_initialize(nil)
+    end
+
+    def buffer=(buffer)
+      buffer.view = self if buffer.is_a?(GtkApp::TextBuffer)
+      self.gtk2_buffer = buffer
+    end
+    
+    # @api private
+    def __button_press_event(event)
+      if event.button == 3
+        x, y = window_to_buffer_coords(Gtk::TextView::WINDOW_TEXT, *event.coords)
+        iter, _ = get_iter_at_position(x, y)
+        buffer.move_mark('click', iter)
+      end
+      false
+    end
+
+    # @api private
+    def __populate_popup(menu)
+      iter = buffer.get_iter_at_mark(buffer.text_marks[:click])
+      s_iter, e_iter = iter.clone, iter.clone
+      
+      s_iter.backward_word_start unless s_iter.starts_word?
+      e_iter.forward_word_end if e_iter.inside_word?
+    
+      word = buffer.get_text(s_iter, e_iter)
+
+      menu_item = Gtk::MenuItem.new("Spelling Suggestions")
+      submenu   = Gtk::Menu.new
+      buffer.spell_check.send(:suggestions, word).each_with_index do |wurd, ndx|
+        _menu_item = Gtk::MenuItem.new(wurd)
+        _menu_item.signal_connect('activate') do |mi|
+          buffer.begin_user_action
+          buffer.delete(s_iter, e_iter)
+          buffer.insert(s_iter, mi.label)
+          buffer.end_user_action
+        end
+        submenu.append(_menu_item)
+      end 
+      menu_item.submenu = submenu
+      menu.prepend(menu_item)
+      menu.show_all
+    end
+
+  end
+end

data/lib/gtk_app/ext/tree_view.rb

@@ -0,0 +1,11 @@
+module Gtk
+  class TreeView
+
+    # @param [] row
+    # @returns [Gtk::TreeIter]  Newly appended iter.
+    def <<(row)
+      iter = model.append
+    end
+
+  end
+end

data/lib/gtk_app/helpers.rb

@@ -4,9 +4,14 @@ module Helpers
   def log
     GtkApp.logger
   end
-  
-  # def config
-  # end
+
+  class Array
+
+    def extract_options!
+      last.is_a?(Hash) && last.extractable_options? ? pop : {}
+    end
+
+  end
   
 end
 end

data/lib/gtk_app/list_control.rb

@@ -0,0 +1,7 @@
+module GtkApp
+module ListControlSupport
+  
+  
+  
+end
+end

data/lib/gtk_app/signal_support.rb

@@ -9,6 +9,10 @@ module SignalSupport
   module ClassMethods
     attr_reader :signal_connections
 
+    # @param [Symbol] widget_name
+    # @param [String] signal_name
+    # @param [Symbol] receiver_method
+    # @yield [...]
     def on(widget_name, signal_name, receiver_method=nil, &block)
 
       sc = SignalConnection.new do

data/lib/gtk_app/text_buffer.rb

@@ -1,9 +1,27 @@
-require 'raspell'
+require 'ffi/aspell'
 
 module GtkApp
 class TextBuffer < Gtk::TextBuffer
+ 
+  # !@attribute [r] spell_check
+  # Aspell object
+  # @return [FFI::Aspell::Speller]
   attr_reader :spell_check
-  attr_reader :undo_stack, :redo_stack
+
+  # !@attribute [r] undo_stack
+  # Collection of actions performed
+  # @return [Array]
+  attr_reader :undo_stack 
+    
+  # !@attribute [r] redo_stack
+  # Collection of actions undone
+  # @return [Array]
+  attr_reader :redo_stack
+  
+  # !@attribute [r] text_marks
+  # Collection of named text marks used to track user input
+  # @return [Hash]
+  attr_reader :text_marks
 
   DEFAULT_LANG = "en_US"
   DEFAULT_TAGS = %w[bold italic strikethrough underline error spell_error]
@@ -11,11 +29,23 @@ class TextBuffer < Gtk::TextBuffer
   def initialize(tag_table=nil, options={})
     super(tag_table)
     @undo_stack, @redo_stack = [], []
-    @spell_check = Aspell.new(options[:lang] || DEFAULT_LANG)
+    
+    options[:lang] ||= DEFAULT_LANG
+    @spell_check = FFI::Aspell::Speller.new(options[:lang])
+    
     setup_default_tags
+    setup_text_marks
     setup_signals
   end
 
+  # @param [Gtk::TextView]
+  def view=(text_view)
+    text_view.instance_eval do
+      signal_connect('button-press-event', &:__button_press_event)
+      signal_connect('populate-popup', &:__populate_popup)
+    end
+  end
+
   # Pop the last action off the undo stack and rewind changes. If an action was
   # performed, the cursor is placed at the actions starting 
   # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter].
@@ -52,11 +82,15 @@ class TextBuffer < Gtk::TextBuffer
       place_cursor(s_iter)
     end
   end
-  
+
+  # Retrieve the word at the current cursor position
+  # @return [String] The word.
   def word_at_cursor
     get_text(*word_bounds).strip
   end
 
+  # Determine the boudaries of the word at the current cursor position.
+  # @return [Array] The start and end iter.
   def word_bounds
     iter = get_iter_at_offset(cursor_position)
     s_iter, e_iter = iter.clone, iter.clone
@@ -66,15 +100,69 @@ class TextBuffer < Gtk::TextBuffer
     [s_iter, e_iter]
   end
 
-  def check_spelling(word=nil, s_iter=nil, e_iter=nil)
-    if word.nil?
-      text.gsub(/[\w\']+/) do |w| check_spelling(w); end
-    elsif !@spell_check.check(word)
-      s, e = start_iter.forward_search(word, Gtk::TextIter::SEARCH_TEXT_ONLY, nil)
-      format(:spell_error, s, e)
+  # Helper method to check the spelling of every word in the buffer.
+  def check_spelling
+    check_range(*bounds)
+  end
+
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def check_range(s_iter, e_iter)
+    e_iter.forward_word_end if e_iter.inside_word?
+    unless s_iter.starts_word?
+      if s_iter.inside_word? || s_iter.ends_word?
+        s_iter.backward_word_start
+      elsif s_iter.forward_word_end
+        s_iter.backward_word_start
+      end
+    end
+    # Get the iter at the current cursor position and the pre cursor.
+    c_iter  = get_iter_at_offset(cursor_position)
+    pc_iter = c_iter.clone
+    pc_iter.backward_char
+    
+    spell_error = tag_table.lookup('spell_error')
+    has_error = (c_iter.has_tag?(spell_error) || pc_iter.has_tag?(spell_error))
+    clear(:spell_error, s_iter, e_iter)
+    
+    # NOTE: From GtkSpell, catch rare cases when the replacement occurs at the
+    # beginning of the buffer.  An iter at offset 0 seems to always be inside a
+    # word even if it's not.
+    if get_iter_at_offset(0) == s_iter
+      s_iter.forward_word_end
+      s_iter.backward_word_start
+    end
+    
+    ws_iter = s_iter.clone # => Word start iter
+    while (ws_iter <=> e_iter) < 0 do
+      we_iter = ws_iter.clone  # => Word end iter
+      we_iter.forward_word_end
+      
+      if ((ws_iter <=> c_iter) < 0) && ((c_iter <=> we_iter) <= 0)
+        # The current word is being actively edited.  Only check it if it's
+        # already been identified as incorrect.  Else, check later.
+        check_word(ws_iter, we_iter) if has_error  
+      else
+        check_word(ws_iter, we_iter)
+      end
+      # Move the word end iter the the beginning of the next word.
+      we_iter.forward_word_end
+      we_iter.backward_word_start
+      break if we_iter == ws_iter
+
+      ws_iter = we_iter.clone
     end
   end
-  
+
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
+  def check_word(s_iter, e_iter)
+    word = get_text(s_iter, e_iter)
+    unless @spell_check.correct?(word)
+      format(:spell_error, s_iter, e_iter)
+    end
+  end
+
   # Does the 
   # Gtk::TextTagTable[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextTagTable] 
   # contain any 'spell_error' tags?
@@ -85,13 +173,17 @@ class TextBuffer < Gtk::TextBuffer
   # Locate text in selection or the entire buffer.  If found, a 
   # Gtk::TextMark[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextMark]
   # is returned.  Else, nil.
+  # @param [String] string Text to search.
   def find(string)
     s_iter, e_iter, text_selected = selection_bounds
     s_iter = start_iter unless text_selected
     s_iter, e_iter = s_iter.forward_search(string, Gtk::TextIter::SEARCH_TEXT_ONLY, e_iter)
     s_iter ? create_mark(nil, s_iter, false) : nil
   end
-  
+
+  # @param [String] string Text to replace the selection with.
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
   def replace(string, s_iter, e_iter)
     begin_user_action
     delete(s_iter, e_iter)
@@ -103,6 +195,7 @@ class TextBuffer < Gtk::TextBuffer
   # Format text in the current selection range with a 
   # Gtk::TextTag[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextTag] 
   # identified by the given name.
+  # @param [String] tag_name
   def format_selection(tag_name)
     s_iter, e_iter, text_selected = selection_bounds
     format(tag_name, s_iter, e_iter) if text_selected
@@ -111,6 +204,9 @@ class TextBuffer < Gtk::TextBuffer
   # This is a small wrapper around the 
   # Gtk::TextBuffer#apply_tag[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextBuffer#apply_tag] 
   # method.  It  allows the Gtk::TextTag name to be passed as a symbol.
+  # @param [] tag_name
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
   def format(tag_name, s_iter, e_iter)
     apply_tag(tag_name.to_s, s_iter, e_iter)
   end
@@ -132,6 +228,9 @@ class TextBuffer < Gtk::TextBuffer
   # Remove all tags of a given name from from one
   # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter] 
   # to another.
+  # @param [] tag_name
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
   def clear(tag_name, s_iter, e_iter)
     remove_tag(tag_name.to_s, s_iter, e_iter)
   end
@@ -139,6 +238,8 @@ class TextBuffer < Gtk::TextBuffer
   # Remove all Gtk::TextTag's from one 
   # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter] 
   # to another.
+  # @param [Gtk::TextIter] s_iter
+  # @param [Gtk::TextIter] e_iter
   def clear_all(s_iter, e_iter)
     remove_all_tags(s_iter, e_iter)
   end
@@ -160,6 +261,14 @@ class TextBuffer < Gtk::TextBuffer
       end
     end
 
+    def setup_text_marks
+      @text_marks = { 
+        insert_start: create_mark('insert_start', start_iter, true),
+        insert_end: create_mark('insert_end', start_iter, true),
+        click: create_mark('click', start_iter, true)
+      }
+    end
+
     # Establish base signal handlers.  Here we track user actions and...
     def setup_signals
       signal_connect('begin-user-action') { |me| @user_action = true  }
@@ -171,6 +280,13 @@ class TextBuffer < Gtk::TextBuffer
             (iter.offset + text.scan(/./).size), text]
           @redo_stack.clear
         end
+        move_mark(me.text_marks[:insert_start], iter) 
+      end
+
+      signal_connect_after('insert-text') do |me, iter, text, len|
+        s_iter = get_iter_at_mark(me.text_marks[:insert_start])
+        check_range(s_iter, iter)
+        move_mark(me.text_marks[:insert_end], iter)
       end
       
       signal_connect('delete-range') do |me, s_iter, e_iter|
@@ -180,14 +296,14 @@ class TextBuffer < Gtk::TextBuffer
         end
       end
 
-      # TODO: Add suggestion popups for spelling erros.
-      # tag_table.lookup('spell_error').signal_connect('event') do |tag|
-      # end
+      signal_connect_after('delete-range') do |me, s_iter, e_iter|
+        check_range(s_iter, e_iter)
+      end
     end
     
     def user_action?
       @user_action
     end
-
+    
+end
 end
-end

data/lib/gtk_app/version.rb

@@ -1,3 +1,3 @@
 module GtkApp
-  Version = VERSION = '0.1.2'
-end
+  Version = VERSION = '0.2.0'
+end

data/lib/gtk_app/view.rb

@@ -3,12 +3,17 @@ class View < Gtk::Builder
   include GtkApp::Helpers
   include GtkApp::ViewHelpers
 
+  # @param [GtkApp::Controller] controller
+  # @param [String] builder_file Path the Gtk builder file
   def initialize(controller, builder_file, *args)
     super()
+    # options = args.extract_options!
     self.add_from_file(builder_file)
     self.connect_signals { |handler| controller.method(handler) }
+
+    # self.title = options[:title] if options.key?(:title)
   end
-  
+
   def method_missing(id, *args, &block)
     method_name = id.to_s
 
@@ -44,7 +49,11 @@ class View < Gtk::Builder
         nil,
         lambda do |row|
           iter = widget.model.append
-          row.each_with_index { |v,i| iter[i] = v }
+          if row.is_a?(Gtk::TreeIter)
+            (0..model.n_columns).each { |i| iter[i] = row[i] }
+          else
+            row.each_with_index { |v,i| iter[i] = v }
+          end
           iter
         end ]
     else
@@ -54,13 +63,13 @@ class View < Gtk::Builder
           lambda { |text| widget.text = ("#{widget.text}" << text) } ]
       else [nil, nil, nil]; end
     end
-    
-    self.class.class_eval do
+
+    class_eval do
       define_method(:"#{widget_name}", lambda { widget })
       define_method(:"#{widget_name}!", bang_proc) if bang_proc
       define_method(:"#{widget_name}=", equal_proc) if equal_proc
     end
-    
+
     widget.class_eval do
       define_method("<<", append_proc)
     end if append_proc

data/lib/gtk_app/view_helpers.rb

@@ -1,29 +1,43 @@
 module GtkApp
 module ViewHelpers
-  
-  def build_listview(widget_name, columns, options={}, &block) # :yields: index, header, column, renderer
+
+  # Simple way to setup a listview.
+  # @param [Symbol] Widget name
+  # @param [Hash]   
+  # @param [Hash] options
+  # @option options [Proc] :formatter
+  # @option options [Array]
+  # @yield [iter, header, column, renderer]  Core listview elements are yielded for each column.
+  # @yieldparam [Integer] iter Column index
+  # @yieldparam [String] header Column header text
+  # @yieldparam [Gtk::TreeViewColumn] column The current column
+  # @yieldparam [Gtk::CellRenderer]  renderer Current column cell renderer
+  # @raise [ExceptionClass] If an unhandled column data type is provided, an 
+  #   exception is raised.
+  # @example Build a simple listview.
+  #   @view.build_listview(:listThings, {id: Integer, name: String})
+  def build_listview(widget_name, columns, options={}, &block)
     list = self.send(:"#{widget_name}")
     list.model = Gtk::ListStore.new(*columns.values)
     columns.each_with_index do |keyval, index|
       header, data_type = keyval
-      renderer, attrs = case data_type
-      when String, Integer
-        [Gtk::CellRendererText.new, :text => index]
-      when TrueClass
+      renderer, attrs = case "#{data_type}".to_sym
+      when :String, :Integer
+        [Gtk::CellRendererText.new, text: index]
+      when :TrueClass
         toggle = Gtk::CellRendererToggle.new
         toggle.signal_connect('toggled') do |widget, path|
           iter = list.model.get_iter(path)
           iter[index] = !iter[index]
         end
-        [toggle, :active => index]
-      when Gtk::ListStore
+        [toggle, active: index]
+      when :'Gtk::ListStore'
         _renderer = Gtk::CellRendererCombo.new
         model = Gtk::ListStore.new(String)
         _renderer.signal_connect("edited") do |cell, path, text|
           model.get_iter(path)[index] = text
         end
-        [_renderer, :text_column => 0, :model => model, :text => index, 
-          :editable => index]
+        [_renderer, text_column: 0, model: model, text: index, editable: index]
       else
         raise("GtkApp::View##{__method__} does not know how to handle " + 
           "'#{data_type}' data types.")
@@ -40,20 +54,21 @@ module ViewHelpers
       list.append_column(column)
     end
   end
-  
-  # Set *widgets sensitive property to true
-  #== Example
-  # @view.sensitize(:txtFoo, :cmbBar)
+
+  # Set widget(s) sensitivity property to true
+  # @overload sensitize(:lblFoo, :txtFoo)
+  # @overload sensitize(:cmbBar)
   def sensitize(*widgets)
     widgets.each { |w| self["#{w}"].sensitive = true }
   end
-  
-  # Set *widgets sensitive property to false
-  #== Example
-  # @view.desensitize(:txtFoo, :cmbBar)
+
+  # Set widget(s) sensitivity property to false
+  # @overload desensitize(:lblFoo, :lblBar)
+  # @overload desensitize(:cmbBar)
   def desensitize(*widgets)
     widgets.each { |w| self["#{w}"].sensitive = false }
   end
+
   
 end
 end

data/lib/gtk_app/widget_observer.rb

@@ -0,0 +1,6 @@
+module GtkApp
+class WidgetObserver
+
+  
+end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gtk_app
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-16 00:00:00.000000000Z
+date: 2013-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config
-  requirement: &70335886800000 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,31 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70335886800000
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gtk2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70335886798960 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +53,15 @@ dependencies:
         version: 3.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *70335886798960
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.7
 - !ruby/object:Gem::Dependency
-  name: raspell
-  requirement: &70335886798200 !ruby/object:Gem::Requirement
+  name: ffi-aspell
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,13 +69,36 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70335886798200
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: dan@dj-agiledev.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ./lib/gtk_app/application.rb
+- ./lib/gtk_app/callback_support.rb
 - ./lib/gtk_app/config.rb
 - ./lib/gtk_app/controller.rb
 - ./lib/gtk_app/dialog/ask.rb
@@ -62,7 +111,12 @@ files:
 - ./lib/gtk_app/dialog/warn.rb
 - ./lib/gtk_app/dialog.rb
 - ./lib/gtk_app/drawer.rb
+- ./lib/gtk_app/ext/combo_box.rb
+- ./lib/gtk_app/ext/text_buffer.rb
+- ./lib/gtk_app/ext/text_view.rb
+- ./lib/gtk_app/ext/tree_view.rb
 - ./lib/gtk_app/helpers.rb
+- ./lib/gtk_app/list_control.rb
 - ./lib/gtk_app/model.rb
 - ./lib/gtk_app/observer.rb
 - ./lib/gtk_app/partial.rb
@@ -72,6 +126,7 @@ files:
 - ./lib/gtk_app/version.rb
 - ./lib/gtk_app/view.rb
 - ./lib/gtk_app/view_helpers.rb
+- ./lib/gtk_app/widget_observer.rb
 - ./lib/gtk_app.rb
 homepage: https://github.com/drfeelngood/rb-gtk_app
 licenses:
@@ -94,8 +149,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A ruby-gtk framework
 test_files: []
+has_rdoc: true