gtk_app 0.1.0a

data/lib/gtk_app.rb

@@ -0,0 +1,35 @@
+require 'gtk2'
+
+module GtkApp
+  lib = File.expand_path(File.dirname(__FILE__))
+
+  autoload :Model,         "#{lib}/gtk_app/model"
+  autoload :View,          "#{lib}/gtk_app/view"
+  autoload :Controller,    "#{lib}/gtk_app/controller"
+
+  autoload :Helpers,       "#{lib}/gtk_app/helpers"
+  autoload :ViewHelpers,   "#{lib}/gtk_app/view_helpers"
+  autoload :SignalSupport, "#{lib}/gtk_app/signal_support"
+  autoload :TextBuffer,    "#{lib}/gtk_app/text_buffer"
+  autoload :Observer,      "#{lib}/gtk_app/observer"
+  autoload :Version,       "#{lib}/gtk_app/version"
+
+  def self.run
+    Gtk::main
+  end
+  
+  def self.quit
+    Gtk::main_quit
+  end
+  
+  def self.refresh
+    Gtk::main_iteration_do(false) while Gtk::events_pending?
+  end
+
+  def self.add_timeout(time_in_milliseconds, controller, callback)
+    GLib::Timeout.add(time_in_milliseconds){ controller.method(:"#{callback}") }
+  end
+
+end
+
+require 'gtk_app/dialog'

data/lib/gtk_app/controller.rb

@@ -0,0 +1,21 @@
+module GtkApp
+class Controller
+  include GtkApp::Helpers
+  include GtkApp::SignalSupport
+
+  attr_accessor :model, :view
+
+  def initialize(&block)
+    instance_eval(&block) if block_given?
+    
+    establish_signal_connections
+  end
+
+  def quit(with_validations=true)
+    # TODO: if with_validations
+    # end
+    GtkApp.quit
+  end
+
+end
+end

data/lib/gtk_app/dialog.rb

@@ -0,0 +1,39 @@
+module GtkApp
+module Dialog
+
+  autoload(:Error,    'gtk_app/dialog/error')
+  autoload(:Info,     'gtk_app/dialog/info')
+  # autoload(:Wait,     'gtk_app/dialog/wait')
+  autoload(:Warn,     'gtk_app/dialog/warn')
+  autoload(:Ask,      'gtk_app/dialog/ask')
+  autoload(:Notify,   'gtk_app/dialog/notify')
+  # autoload(:Progress, 'gtk_app/dialog/progress')
+   
+  module Support
+
+    module ClassMethods
+
+      def show(parent, text, secondary_text=nil)
+        dialog = new(parent)
+        dialog.text  = text
+        dialog.secondary_text = secondary_text if secondary_text
+
+        result = Gtk::Dialog::RESPONSE_NONE
+        dialog.run do |response|
+          result = response
+        end
+        dialog.destroy
+        
+        result
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+
+end
+end

data/lib/gtk_app/dialog/ask.rb

@@ -0,0 +1,11 @@
+module GtkApp::Dialog
+class Ask < Gtk::MessageDialog
+  include GtkApp::Dialog::Support
+
+  def initialize(parent)
+    super(parent, Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
+      Gtk::MessageDialog::QUESTION, Gtk::MessageDialog::BUTTONS_YES_NO)
+  end
+
+end
+end

data/lib/gtk_app/dialog/error.rb

@@ -0,0 +1,11 @@
+module GtkApp::Dialog
+class Error < Gtk::MessageDialog
+  include GtkApp::Dialog::Support
+
+  def initialize(parent)
+    super(parent, Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
+      Gtk::MessageDialog::ERROR, Gtk::MessageDialog::BUTTONS_CLOSE)
+  end
+  
+end
+end

data/lib/gtk_app/dialog/info.rb

@@ -0,0 +1,11 @@
+module GtkApp::Dialog
+class Info < Gtk::MessageDialog
+  include GtkApp::Dialog::Support
+
+  def initialize(parent)
+    super(parent, Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
+      Gtk::MessageDialog::INFO, Gtk::MessageDialog::BUTTONS_OK)
+  end
+  
+end
+end

data/lib/gtk_app/dialog/notify.rb

@@ -0,0 +1,87 @@
+module GtkApp
+module Dialog
+class Notify < Gtk::Window
+  DEFAULT_OPTIONS = { 
+    :decorated  => false, 
+    :resizable  => false, 
+    :keep_above => true,
+    :opacity    => 0.8,
+    :bg_color   => 'lightgray',
+    :padding    => 6,
+    :pixbuf     => File.dirname(__FILE__) + '/notify.xpm',
+    :pixmap     => File.dirname(__FILE__) + '/notify.xpm',
+    :label_fg   => "#ffffff"
+  }.freeze
+  
+  attr_reader :display
+
+  def initialize(title, text, options={})
+    @screen_info = {}
+    conf = DEFAULT_OPTIONS.merge(options)
+
+    screen = Gdk::Screen.default
+    # @screen_info[:monitor]  = screen.monitor
+    @screen_info[:geometry] = screen.monitor_geometry(screen.number)
+    # @screen_info[:x] =
+    # @screen_info[:y] = 
+
+    super(Gtk::Window::POPUP)
+
+    self.title = title
+    self.decorated  = conf[:decorated]
+    self.resizable  = conf[:resizable]
+    self.keep_above = conf[:keep_above]
+    self.stick
+    
+    ebox = Gtk::EventBox.new
+    ebox.visible_window = false
+    self.add(ebox)
+    vbox = Gtk::VBox.new(false, conf[:padding])
+    vbox.border_width = 12
+    ebox.add(vbox)
+    hbox = Gtk::HBox.new(false, conf[:padding])
+    vbox.pack_start(hbox, false, true, 0)
+
+    image = Gtk::Image.new(Gdk::Pixbuf.new(conf[:pixbuf]))
+    hbox.pack_start(image, false, false, 0)
+    
+    label = Gtk::Label.new(title)
+    label.modify_fg(Gtk::STATE_NORMAL, Gdk::Color.parse(conf[:label_fg]))
+    hbox.pack_start(label, false, false, 0)
+
+    label = Gtk::Label.new(text)
+    label.justify = Gtk::JUSTIFY_LEFT
+    label.modify_fg(Gtk::STATE_NORMAL, Gdk::Color.parse(conf[:label_fg]))
+    label.wrap = true
+    # label.wrap_mode = true
+    vbox.pack_start(label, true, false, 0)
+    
+    ebox.signal_connect('button-press-event') do |widget|
+      puts "button-press-event"
+    end
+    
+    ebox.signal_connect('enter-notify-event') do |widget|
+      puts "enter-notify-enter"
+    end
+    
+    ebox.signal_connect('leave-notify-event') do |widget|
+      puts "leave-notify-event"
+    end
+
+    self.app_paintable = true
+    self.opacity = 0
+    self.show_all
+    # 
+    # pixmap = Gdk::Pixmap.create_from_xpm(self, nil, conf[:pixmap])
+    # puts pixmap.size
+    # # Gdk::Drawable.new()
+    # self.shape_combine_mask(pixmap, 0, 0)
+  end
+  
+  def display
+    
+  end
+
+end
+end
+end

data/lib/gtk_app/dialog/progress.rb

@@ -0,0 +1,20 @@
+module GtkApp::Dialog
+class Progress < Gtk::Dialog
+  
+  def initialize(parent)
+    
+    super("test", parent, 
+      Gtk::Dialog::DESTROY_WITH_PARENT,
+      [Gtk::Stock::OK, Gtk::Dialog::RESPONSE_NONE])
+    pbar = Gtk::ProgressBar.new
+    hbox = Gtk::HBox.new(false, 6)
+    hbox.pack_start(pbar, true, false, 6)
+    self.vbox.add(hbox)
+    self.show_all
+  end
+  
+  # def +(amt)
+  # end
+  
+end
+end

data/lib/gtk_app/dialog/wait.rb

@@ -0,0 +1,10 @@
+module GtkApp::Dialog
+class Wait < Gtk::MessageDialog
+  include GtkApp::Dialog::Support
+
+  def initialize(parent)
+    super(parent, Gtk::Dialog::DESTROY_WITH_PARENT, Gtk::MessageDialog::OTHER,
+      Gtk::Dialog::BUTTONS_NONE)
+  end
+end
+end

data/lib/gtk_app/dialog/warn.rb

@@ -0,0 +1,11 @@
+module GtkApp::Dialog
+class Warn < Gtk::MessageDialog
+  include GtkApp::Dialog::Support
+
+  def initialize(parent)
+    super(parent, Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
+      Gtk::MessageDialog::WARNING, Gtk::MessageDialog::BUTTONS_OK_CANCEL)
+  end
+
+end
+end

data/lib/gtk_app/helpers.rb

@@ -0,0 +1,12 @@
+module GtkApp
+module Helpers
+  
+  def log
+    GtkApp.logger
+  end
+  
+  # def config
+  # end
+  
+end
+end

data/lib/gtk_app/model.rb

@@ -0,0 +1,12 @@
+require 'active_model'
+
+module GtkApp
+class Model
+  include ActiveModel::Validations
+
+  def initialize
+    @errors = ActiveModel::Errors.new(self)
+  end
+
+end
+end

data/lib/gtk_app/observer.rb

@@ -0,0 +1,13 @@
+# require 'active_model'
+require 'observer'
+
+module GtkApp
+# class Observer < ActiveModel::Observer
+class Observer
+  
+  # def after_update(model)
+  #   puts "#{model}"
+  # end
+  
+end
+end

data/lib/gtk_app/partial.rb

@@ -0,0 +1,5 @@
+module GtkApp
+class Partial < View
+  
+end
+end

data/lib/gtk_app/register_support.rb

@@ -0,0 +1,17 @@
+module GtkApp
+module RegisterSupport
+  
+  module ClassMethods
+    
+    def register(widget_name, method_name, options={}, &block)
+      # TODO:
+    end
+    
+  end
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+end
+end

data/lib/gtk_app/signal_support.rb

@@ -0,0 +1,65 @@
+module GtkApp
+module SignalSupport
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    attr_reader :signal_connections
+
+    def on(widget_name, signal_name, receiver_method=nil, &block)
+
+      sc = SignalConnection.new do
+        @widget_name = widget_name
+        @signal_name = signal_name
+        @receiver_method = receiver_method
+        @receiver_block = block if block_given?
+      end
+
+      @signal_connections ||= []
+      @signal_connections << sc
+    end
+
+  end
+  
+  module InstanceMethods
+
+    def establish_signal_connections
+      return unless self.class.signal_connections
+
+      self.class.signal_connections.each do |signal_connection|
+        signal_connection.with do |conn|
+          widget = @view.send conn.widget_name
+          if conn.receiver_block
+            widget.signal_connect conn.signal_name do |*args|
+              self.instance_exec(*args, &conn.receiver_block)
+            end
+          else
+            widget.signal_connect conn.signal_name do |*args|
+              self.send conn.receiver_method_name, *args
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+  class SignalConnection
+    attr_accessor :widget_name, :signal_name
+    attr_accessor :receiver_method, :receiver_block
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    def with
+      yield(self)
+    end
+
+  end
+
+end
+end

data/lib/gtk_app/text_buffer.rb

@@ -0,0 +1,193 @@
+require 'raspell'
+
+module GtkApp
+class TextBuffer < Gtk::TextBuffer
+  attr_reader :spell_check
+  attr_reader :undo_stack, :redo_stack
+
+  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_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
+  
+  def word_at_cursor
+    get_text(*word_bounds).strip
+  end
+
+  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(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)
+    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.
+  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
+  
+  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.
+  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.
+  def format(tag_name, s_iter, e_iter)
+    apply_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 clear_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| clear(tag_name, s_iter, e_iter) }
+      end
+    end
+  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.
+  def clear(tag_name, s_iter, e_iter)
+    remove_tag(tag_name.to_s, s_iter, e_iter)
+  end
+
+  # Remove all Gtk::TextTag's from one 
+  # Gtk::TextIter[http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATextIter] 
+  # to another.
+  def clear_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
+
+    # 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?
+          @undo_stack << [:insert, iter.offset, 
+            (iter.offset + text.scan(/./).size), text]
+          @redo_stack.clear
+        end
+      end
+      
+      signal_connect('delete-range') do |me, s_iter, e_iter|
+        if user_action?
+          text = get_text(s_iter, e_iter)
+          @undo_stack << [:delete, s_iter.offset, e_iter.offset, text]
+        end
+      end
+
+      # TODO: Add suggestion popups for spelling erros.
+      # tag_table.lookup('spell_error').signal_connect('event') do |tag|
+      # end
+    end
+    
+    def user_action?
+      @user_action
+    end
+
+end
+end

data/lib/gtk_app/version.rb

@@ -0,0 +1,3 @@
+module GtkApp
+  Version = VERSION = '0.1.0a'
+end

data/lib/gtk_app/view.rb

@@ -0,0 +1,75 @@
+module GtkApp
+class View < Gtk::Builder
+  include GtkApp::Helpers
+  include GtkApp::ViewHelpers
+
+  def initialize(controller, builder_file, *args)
+    super()
+    self.add_from_file(builder_file)
+    self.connect_signals { |handler| controller.method(handler) }
+  end
+  
+  def method_missing(id, *args, &block)
+    method_name = id.to_s
+
+    widget_name = (method_name =~ /([!=]|<{2})$/ ? method_name.chop : method_name)
+    widget = self["#{widget_name}"]
+    super unless widget
+
+    bang_proc, equal_proc, append_proc = case widget
+    when Gtk::TextView then
+      [ lambda { widget.buffer.text },
+        lambda { |*argv| widget.buffer.text = argv[0].to_s },
+        lambda { |text| widget.buffer.text << text.to_s } ]
+    when Gtk::ComboBox then
+      [ lambda { widget.active_text },
+        lambda do |*argv|
+          if argv[0].is_a?(Fixnum)
+            widget.active = argv[0]
+          elsif widget.model
+            result = nil
+            widget.model.each do |m, p, i|
+              result = iter if iter[0] =~ /\A#{argv[0]}/i
+            end
+            widget.active_iter = result if result
+          end
+        end,
+        lambda { |text| widget.append_text(text.to_s) } ]
+    when Gtk::ToggleButton, Gtk::CheckButton then
+      [ lambda { widget.active? },
+        lambda { |*argv| widget.active = argv[0] },
+        nil ]
+    when Gtk::TreeView then
+      [ lambda { widget.selection.selected },
+        nil,
+        lambda do |row|
+          iter = widget.model.append
+          row.each_with_index { |v,i| iter[i] = v }
+          iter
+        end ]
+    else
+      if widget.respond_to?(:text)
+        [ lambda { widget.text },
+          lambda { |*argv| widget.text = argv[0].to_s },
+          lambda { |text| widget.text = ("#{widget.text}" << text) } ]
+      else [nil, nil, nil]; end
+    end
+    
+    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
+
+    send(:"#{method_name}", *args, &block)
+  end
+  
+  # TODO: def restore_geometry
+  # end
+  
+end
+end

data/lib/gtk_app/view_helpers.rb

@@ -0,0 +1,59 @@
+module GtkApp
+module ViewHelpers
+  
+  def build_listview(widget_name, columns, options={}, &block) # :yields: index, header, column, renderer
+    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
+        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
+        _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]
+      else
+        raise("GtkApp::View##{__method__} does not know how to handle " + 
+          "'#{data_type}' data types.")
+      end
+
+      column = Gtk::TreeViewColumn.new("#{header}".titleize, renderer, attrs)
+      column.visible = false if index == 0
+      yield(index, header, column, renderer) if block_given?
+
+      if options.key?(:formatter) && options[:formatter].is_a?(Proc)
+        column.set_cell_data_func(renderer, &options[:formatter])
+      end
+
+      list.append_column(column)
+    end
+  end
+  
+  # Set *widgets sensitive property to true
+  #== Example
+  # @view.sensitize(:txtFoo, :cmbBar)
+  def sensitize(*widgets)
+    widgets.each { |w| self["#{w}"].sensitive = true }
+  end
+  
+  # Set *widgets sensitive property to false
+  #== Example
+  # @view.desensitize(:txtFoo, :cmbBar)
+  def desensitize(*widgets)
+    widgets.each { |w| self["#{w}"].sensitive = false }
+  end
+  
+end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: gtk_app
+version: !ruby/object:Gem::Version 
+  prerelease: 5
+  version: 0.1.0a
+platform: ruby
+authors: 
+- Daniel Johnston
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pkg-config
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.7
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dmarkow-raspell
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: 
+email: dan@dj-agiledev.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ./lib/gtk_app/controller.rb
+- ./lib/gtk_app/dialog/ask.rb
+- ./lib/gtk_app/dialog/error.rb
+- ./lib/gtk_app/dialog/info.rb
+- ./lib/gtk_app/dialog/notify.rb
+- ./lib/gtk_app/dialog/progress.rb
+- ./lib/gtk_app/dialog/wait.png
+- ./lib/gtk_app/dialog/wait.rb
+- ./lib/gtk_app/dialog/warn.rb
+- ./lib/gtk_app/dialog.rb
+- ./lib/gtk_app/helpers.rb
+- ./lib/gtk_app/model.rb
+- ./lib/gtk_app/observer.rb
+- ./lib/gtk_app/partial.rb
+- ./lib/gtk_app/register_support.rb
+- ./lib/gtk_app/signal_support.rb
+- ./lib/gtk_app/text_buffer.rb
+- ./lib/gtk_app/version.rb
+- ./lib/gtk_app/view.rb
+- ./lib/gtk_app/view_helpers.rb
+- ./lib/gtk_app.rb
+homepage: https://github.com/drfeelngood/rb-gtk_app
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: A ruby-gtk framework
+test_files: []
+