reactive_view_wx 0.1.0

data/lib/helpers/model_show_ctrl_class.rb

@@ -0,0 +1,35 @@
+require 'wx_sugar'
+
+module Reactive::View::Wx
+  module Helpers
+  
+    class ModelShowCtrl < Wx::Panel
+      attr_reader :model
+      
+      def selected_records
+        [@record]
+      end
+      
+      def initialize(parent, record, options = {})
+        super(parent, options)
+        @model, @record = record.class, record
+        
+        fill_controls(record)
+      end
+    
+      protected
+    
+        def fill_controls(record)
+          arrange_grid(:cols => 2, :padding => 5, :proportion => 1) {|sizer| sizer.add_growable_col(1, 1)}
+          read_only = Wx::SystemSettings.get_colour(Wx::SYS_COLOUR_BTNFACE)
+          @model.content_columns.each do |column|
+            nest(Wx::StaticText.new(self, :label => "#{column.human_name} :"), :pad => 'ALIGN_CENTER_VERTICAL,ALIGN_RIGHT')
+            nest(ctrl = Wx::TextCtrl.new(self, :value => record.send(column.name).to_s, :style => Wx::TE_READONLY), :proportion => 1, :align => 'CENTER_VERTICAL')
+            ctrl.set_background_colour(read_only)
+          end
+        end
+
+    end
+
+  end
+end

data/lib/reactive_view_wx.rb

@@ -0,0 +1,22 @@
+require 'activesupport'
+require 'reactive'
+require 'wx'
+
+#require 'wx_pepper'
+require 'xrc_pepper'
+
+require 'request'
+require 'binder'
+require 'template'
+require 'base'
+
+Wx::EvtHandler.send(:include, Reactive::View::Wx::Binder)
+
+# Let the controller know our temlate class 
+#Reactive::Controller::Base.template_class = Reactive::View::Wx::Template
+
+# We want the ::Wx namespace to be directly available for our templates. Since ActionView compiles the template
+# and hosts the compiled code into the ActionView::Base::CompiledTemplates, we have to inject ::Wx there.
+ActionView::Base::CompiledTemplates.send(:include, ::Wx)
+
+Reactive::View::Wx::Template.load_helpers

data/lib/request.rb

@@ -0,0 +1,14 @@
+require 'reactive'
+
+module Reactive
+  module View
+    module Wx
+    
+      class Request < Reactive::Request
+        attr_accessor :local_assigns
+      end
+    
+    end
+  end
+end
+

data/lib/template.rb

@@ -0,0 +1,114 @@
+require 'action_view_init'
+
+module Reactive
+  module View
+    module Wx
+    
+      class RubyCodeTemplateHandler < ActionView::TemplateHandler
+        def compile(template)
+          template
+        end
+      end
+    
+      class Template < ActionView::Base
+        register_default_template_handler(:rb, RubyCodeTemplateHandler)
+        
+        def self.load_helpers #:nodoc:
+          # First load classes (all hosted under the Helper module)
+          Dir.entries("#{File.dirname(__FILE__)}/helpers").sort.each do |file|
+            next unless file =~ /^([a-z][a-z_]*_class|_classes).rb$/
+            require "helpers/#{$1}"
+          end
+          include Helpers
+          ActionView::Base::CompiledTemplates.send(:include, Helpers)
+          # Then helper modules
+          Dir.entries("#{File.dirname(__FILE__)}/helpers").sort.each do |file|
+            next unless file =~ /^([a-z][a-z_]*_helper).rb$/
+            require "helpers/#{$1}"
+            helper_module_name = $1.camelize
+            if Helpers.const_defined?(helper_module_name)
+              include Helpers.const_get(helper_module_name)
+              ActionView::Base::CompiledTemplates.send(:include, Helpers.const_get(helper_module_name))
+            end
+          end
+        end
+        
+        # ActionView returns :html by default, we don't have any 
+        def template_format
+          @template_format ||= :rb
+        end
+      
+        def do_request(hash)
+          Base.do_request(hash)
+        end
+      
+        # We accept the rendering of a plain file (not a partial) that lies in the current view directory
+        # For this, simply pass the name of the view like:  render "create.xrc"
+        def render(options = {}, old_local_assigns = {}, &block)
+          if options.is_a?(String) && !options.include?('/')
+            super(File.join(controller.class.controller_path, options), old_local_assigns, &block)
+          else
+            super
+          end
+        end
+
+        # handles format specification in the template_path.
+        # So it is possible to say: render "show.xrc", meaning XRC is the format and any available handler will
+        # be used. So the file may either be "show.xrc.erb" or "show.src.builder" or any custum registered handler.
+        def render_file(template_path, use_full_path = true, local_assigns = {}) #:nodoc:
+          if controller && controller.request.respond_to?(:local_assigns) && controller.request.local_assigns
+            local_assigns.merge!(controller.request.local_assigns) 
+          end
+          
+          template_path_without_format, template_format = path_and_extension(template_path)
+          if template_format && !File.basename(template_path_without_format).include?('.')
+            @template_format = template_format.to_sym 
+            super(template_path_without_format, use_full_path, local_assigns)
+          else
+            super
+          end
+        end
+
+        # The result of the rendering is used to create a Wx object (except when the format is :rb which means it is code)
+        def render_template(template_extension, template, file_path = nil, local_assigns = {}) #:nodoc:
+          output = super
+          if template_format == :xrc
+            template_key = file_path || template
+            parent = local_assigns[:parent_window]
+            load_xrc(template_key, output, parent)
+          else
+            output
+          end
+        end
+      
+        # The controller may extend this object, especially with helpers
+        # Because we have compiled templates, when rendering such templates they
+        # are hosted in the ActionView::Base::CompiledTemplates module.
+        # This becomes a problem when a compiled template wants to access helper constants,
+        # they are hosted under XXXHelper and also in the controller master_helper_module.
+        # This method will also include the passed module into CompiledTemplates, so that everything
+        # is accessable. Note that this may break the class unloading feature for development mode.
+        def extend(*modules)
+          ActionView::Base::CompiledTemplates.send(:include, *modules)
+          super
+        end
+      
+        private
+        
+          def load_xrc(template_key, data, parent)
+            return nil # Not implemented.... not on my priority list
+            Xrc.instance.unload_object(template_key)
+            Xrc.instance.load_data(template_key, data)
+            each_toplevel_object(data) do |klass, name|
+              Xrc.instance.load_object(parent, name, klass)
+            end
+          end
+        
+          def each_toplevel_object(xml)
+          end
+      
+      end
+    
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,13 @@
+module Reactive
+  module View
+    module Wx
+      module VERSION #:nodoc:
+        MAJOR = 0
+        MINOR = 1
+        TINY  = 0
+
+        STRING = [MAJOR, MINOR, TINY].join('.')
+      end
+    end
+  end
+end

data/lib/xrc_pepper.rb

@@ -0,0 +1,253 @@
+#
+# wxRuby extensions for XRC
+#
+# Author: Pascal Hurni
+# License: MIT
+#
+
+require 'wx'
+require 'wx_sugar/event_connector'     # for listen()
+require 'singleton'
+
+#
+# Access to Window children
+# Injected into Wx::Window
+#
+
+module WindowEnumerable
+  include Enumerable
+
+  # ruby way to iterate over children
+  def each
+    get_children.each {|item| yield item}
+  end
+
+  # iterate over children and all descendant
+  def each_descendant(&block)
+    each {|item| block.call(item); item.each_descendant(block) }
+  end
+
+  # access children window by name directly as attribute reader
+  def method_missing(name, *args)
+    if [:ok, :cancel, :yes, :no].include?(name)
+      win = Wx::Window.find_window_by_name("wxID_#{name.to_s.upcase}", self)
+      return win if win
+    end
+    Wx::Window.find_window_by_name(name.to_s, self) || super
+  end
+end
+
+module MenuBarEnumerable
+  include Enumerable
+
+  def each
+    index = 0
+    while index < get_menu_count
+      yield get_menu(index)
+      index += 1
+    end
+  end
+
+  # find a menu_item in any of the bar's menu
+  def method_missing(name, *args)
+    each do |menu|
+      item = menu.find_item_by_name(name)
+      return item if item
+    end
+    super
+  end
+end
+
+module MenuEnumerable
+  include Enumerable
+
+  def each
+    index = 0
+    while index < get_menu_item_count
+      yield find_item_by_position(index)
+      index += 1
+    end
+  end
+
+  def find_item_by_name(name)
+    item = find_item(Wx::xrcid(name.to_s))
+    item == Wx::NOT_FOUND ? nil : item
+  end
+
+  def method_missing(name, *args)
+    find_item_by_name(name.to_s) || super
+  end
+end
+
+module AuiManagerEnumerable
+  include Enumerable
+  
+#  alias_method :each, :each_pane
+
+  def method_missing(name, *args)
+    pi = get_pane(name.to_s)
+    pi.ok? ? pi : super
+  end
+end
+
+
+#
+# Easily bind method named after this pattern: on_#{control_name}_#{event_name}
+# to the corresponding event.
+# Injected into Wx::EvtHandler
+#
+module EventBinder
+
+  def load_and_bind(options = {})
+    options[:name] ||= self.class.to_s
+    options[:class] ||= "wx" + self.class.ancestors.find {|ancestor| ancestor.to_s =~ /Wxruby2::/}.to_s.split("Wxruby2::")[1]
+    Xrc.instance.bind_object_subclass(self, options[:parent], options[:name], options[:class])
+    
+    # needed anymore? Xrc.instance.bind_menu_bar(self, options[:menu]) if options[:menu]
+  end
+
+  #
+  # A little more rubyesque version of wxSugar#listen method
+  # Pass the window (control) to be bound and then a hash with event name as keys and method name as value
+  # (You may also pass a Proc as value)
+  #
+  def _bind(window, events)
+    events.each do |event, method|
+      case method
+        when Symbol
+          listen(event, window, method)
+        when Proc
+          listen(event, window, nil, &method)
+      end
+    end
+  end
+
+  def bind_standard_buttons
+    # bind the close button (something like a cross on top-right corner)
+    if respond_to? :on_close
+      arity = method(:on_close).arity
+      evt_close {|event| arity == 0 ? on_close : on_close(event)}
+    end
+
+    # bind the buttons with standard wxID_*
+    select{|item| item.kind_of?(Wx::Button) && item.name[0..4] == "wxID_"}.each do |button|
+      method_name = "on_#{button.name[5..-1].downcase}"
+      arity = method(method_name).arity
+      evt_button(button.get_id) {|event| arity == 0 ? send(method_name) : send(method_name, event)} if respond_to? method_name
+    end
+  end
+
+  def bind_events
+    # get all methods that are named 'on_*'
+    methods = self.methods.select{|method| method[0..2] == "on_" }
+    
+    # for each control in this window
+    each do |control|
+      # iterate over the methods that target the current control (named 'on_#{control.name}_*')
+      methods.grep(Regexp.new("^on_#{control.name}_(.*)")) {|method| [$1,method]}.each do |event,method|
+        # bind the found method with the event
+        listen(event, control, method)
+      end
+    end
+  end
+  
+  def bind_menus
+    # get all methods that are named 'on_*_menu'
+    self.methods.grep(/^on_(.*)_menu$/) {|method| [$1,method]}.each do |name,method|
+      # bind the found method with the event
+      evt_menu(Wx::xrcid(name), method)
+    end
+  end
+
+end
+
+=begin obsolete
+#
+# XrcDialog
+# subclass your dialog from this class instead of Wx::Dialog
+# so that button events are automatically bound to methods +on_XXX+ where XXX is the button name
+#
+class XrcFrame < Wx::Frame
+  def initialize(*args)
+    super
+    Xrc.instance.bind_frame_subclass(self)
+  end
+end
+
+class XrcDialog < Wx::Dialog
+  def initialize(*args)
+    super
+    Xrc.instance.bind_dialog_subclass(self)
+  end
+end
+=end
+
+#
+# Class to handle XRC
+# This is a Singleton, so access it from everywhere with Xrc.instance
+#
+class Xrc < Wx::XmlResource
+  include ::Singleton
+  
+  def initialize
+    super
+    init_all_handlers
+  end
+
+  def bind_object_subclass(win, parent = nil, name = win.class.to_s, klass = "wx#{win.class.to_s}")
+    raise StandardError unless load_object(win, parent, name, klass)
+    bind(win)
+    true
+  end
+
+  def bind_dialog_subclass(win, parent = nil, name = win.class.to_s)
+    raise StandardError unless load_dialog_subclass(win, parent, name)
+    bind(win)
+    true
+  end
+
+  def bind_frame_subclass(win, parent = nil, name = win.class.to_s)
+    raise StandardError unless load_frame_subclass(win, parent, name)
+    bind(win)
+    true
+  end
+
+  def bind_menu_bar(win, name)
+    load_menu_bar(win, name)
+    win.send(:bind_menus)
+  end
+
+protected
+  def bind(win)
+    win.send(:bind_events)
+    win.send(:bind_standard_buttons)
+    win.send(:bind_menus)
+  end
+
+end
+
+module Accessors
+  module ControlWithItems
+    def value
+      val = get_item_data(get_selection)
+      val.kind_of?(ActiveRecord::Base) ? val.id : val
+    end
+  end
+end
+
+
+
+# WARNING: module WxRubyStyleAccessors is a mixin which also redefines method_missing. So it catches first.
+# Thus, we first extend Dialog so that our sugar is before in the chain!
+Wx::Dialog.send(:include, WindowEnumerable)
+Wx::Panel.send(:include, WindowEnumerable)
+Wx::Frame.send(:include, WindowEnumerable)
+Wx::Window.send(:include, WindowEnumerable)
+
+Wx::MenuBar.send(:include, MenuBarEnumerable)
+Wx::Menu.send(:include, MenuEnumerable)
+
+# Our EventBinder is useful for any class that has events
+Wx::EvtHandler.send(:include, EventBinder)
+
+Wx::ControlWithItems.send(:include, Accessors::ControlWithItems)