reactive-wx 0.2.0

data/lib/reactive-wx/request.rb

@@ -0,0 +1,13 @@
+module Reactive # :nodoc:
+  module WxOutput # :nodoc:
+  
+    class Request < Reactive::Request # :nodoc:
+      attr_accessor :local_assigns
+      
+      def default_format
+        :wx
+      end
+    end
+  
+  end
+end

data/lib/reactive-wx/wx_ext.rb

@@ -0,0 +1,42 @@
+#
+# wxRuby extensions
+# Currently at experimental stage, sparingly tested on Win32 only.
+#
+# Author: Pascal Hurni
+# License: MIT
+#
+
+module WxExtensions # :nodoc: all
+end
+
+require 'wx'
+require 'reactive-wx/wx_ext/window'
+require 'reactive-wx/wx_ext/event_binder'
+require 'reactive-wx/wx_ext/message_dialog'
+require 'reactive-wx/wx_ext/panel_dialog'
+require 'reactive-wx/wx_ext/semi_modal'
+require 'reactive-wx/wx_ext/toolbar'
+require 'reactive-wx/wx_ext/aui_toolbar'
+require 'reactive-wx/wx_ext/form_grid_sizer'
+require 'reactive-wx/wx_ext/arranger'
+
+# 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, WxExtensions::Window)
+Wx::Window.send(:include, WxExtensions::Window)
+
+Wx::EvtHandler.send(:include, WxExtensions::EventBinder)
+Wx::Dialog.send(:include, WxExtensions::SemiModalDialog)
+silence_warnings { Wx::const_set(:MessageDialog, WxExtensions::MessageDialog) }
+Wx::ToolBar.send(:include, WxExtensions::ToolBar)
+Wx::AuiToolBar.send(:include, WxExtensions::AuiToolBar) if defined? Wx::AuiToolBar
+
+# WARNING: module WxSugar::Arranger was monkey patched in wx_ext/arranger.rb
+
+unless Wx::Window.instance_methods.include? 'bring_to_front'
+  # simple solution for feature request #1227
+  class Wx::Window
+    alias_method :bring_to_front, :raise
+    remove_method :raise
+  end
+end

data/lib/reactive-wx/wx_ext/arranger.rb

@@ -0,0 +1,33 @@
+# TODO: Currently uses monkey patching, because WxSugar::Arranger is already a mix-in module.
+module WxSugar # :nodoc: all
+  module Arranger
+    # takes hash arguments +layout+
+    # 
+    #  :rows - integer, number of rows (mandatory, see below)
+    #  :cols - integer, number of columns (mandatory, see below)
+    #  :vgap - integer, extra vertical space between each child (optional)
+    #  :hgap - integer, extra horizontal space between each child (optional)
+    #
+    # At least one of +:rows+ and +:cols+ must be specified. If one is not
+    # specified, the other will be calculated dynamically based on the
+    # total number of child widgets added.
+    # 
+    def arrange_formgrid(layout, &block)
+      Kernel.raise ArgumentError, "Pass eihter :cols or :rows, not both!" if layout[:cols] && layout[:rows]
+#      if layout[:padding]
+#        layout[:vgap] = layout[:hgap] = layout[:padding]
+#      end
+    
+      # wxruby wants them in this order, and with nought if null
+      args = [ :vgap, :hgap ].map { | arg | layout[arg] or 0 }
+      sizer = WxExtensions::FormGridSizer.new(layout[:rows], layout[:cols], *args)
+      arrange( sizer, layout, &block )
+    end
+  
+    def hints_to_constants_with_formgrid(layout_hints)
+      hints_to_constants_without_formgrid(layout_hints) + (layout_hints[:span] ? 0x10000000 : 0)
+    end
+  
+    alias_method_chain :hints_to_constants, :formgrid
+  end
+end

data/lib/reactive-wx/wx_ext/aui_toolbar.rb

@@ -0,0 +1,22 @@
+module WxExtensions
+  module AuiToolBar
+    def self.included(base) #:nodoc:
+#      base.send :alias_method_chain, :initialize, :extension
+      base.send :alias_method_chain, :add_tool, :extension
+    end
+
+    def initialize_with_extension(*args)
+      initialize_without_extension(*args)
+      if block_given?
+        yield self
+        realize
+      end
+    end
+  
+    def add_tool_with_extension(*args, &block)
+      item = add_tool_without_extension(*args)
+      evt_tool(item.get_id, &block) if block
+      item
+    end
+  end
+end

data/lib/reactive-wx/wx_ext/event_binder.rb

@@ -0,0 +1,11 @@
+module WxExtensions
+  # Adds a cooked way of connecting events to handler.
+  # Will be injected into Wx::EvtHandler
+  module EventBinder
+    def cooked_connect(event_name, window_or_id, meth = nil, &block)
+      handler = acquire_handler(meth, block)
+      id  = acquire_id(window_or_id)
+      connect(id, Wx::ID_ANY, self.class.event_type_for_name("evt_#{event_name}".to_sym), &handler)
+    end
+  end
+end

data/lib/reactive-wx/wx_ext/form_grid_sizer.rb

@@ -0,0 +1,54 @@
+module WxExtensions
+  class FormGridSizer < Wx::GridBagSizer
+    def initialize(rows, cols, hgap, vgap)
+      super(hgap, vgap)
+
+      @cols, @rows = cols, rows
+      @cols = 1 if @cols.nil? && @rows.nil?
+#puts "#{self} arrange: c:#{@cols} r:#{@rows}"
+      
+      @span = @cols ? Wx::GBSpan.new(1,2) : Wx::GBSpan.new(2,1)
+      @defaultspan = Wx::GBSpan.new(1,1)
+      
+      @row = @col = 0
+      
+      if @cols
+        1.step(@cols*2, 2) {|i| add_growable_col(i, 1); "puts grow: #{i}"}
+      else
+        add_growable_col(1, 1)
+      end
+    end
+  
+    def add(child, prop = 0, flag = 0, border = 0, userdata = nil)
+      span = (flag & 0x10000000 == 0x10000000) || child.is_a?(FormGridSizer)
+#puts "#{self} putting at r:#{@row}, c:#{@col} #{child.class} #{flag} #{span}"
+      item = super(child, Wx::GBPosition.new(@row, @col), span ? @span : @defaultspan, flag, border, userdata)
+      add_growable_row(@row, prop) if span
+      move_next
+      move_next if span
+      item
+    end
+  
+    protected
+    
+    def move_next()
+      if @cols
+        if (@col += 1) >= @cols * 2
+          @row += 1 
+          @col = 0
+        end
+      else
+        if (@col += 1) % 2 == 0
+          if (@row += 1) % @rows == 0
+            @row = 0
+#puts "grow: #{@col+1}"
+            add_growable_col(@col+1, 1)
+          else
+            @col -=2
+          end
+        end
+      end
+    end
+  
+  end
+end

data/lib/reactive-wx/wx_ext/message_dialog.rb

@@ -0,0 +1,62 @@
+module WxExtensions
+  # A class to allow modeless message dialogs
+  # The code is ugly as it is a quick translation of the generic MessageDialog C source code
+  class MessageDialog < Wx::Dialog
+
+    def initialize(parent, *args)
+      message = args[0] if args[0]
+      caption = args[1] ? args[1] : 'Message'
+      style = args[2] ? args[2] : Wx::OK | Wx::CENTRE
+      pos = args[3] ? args[3] : Wx::DEFAULT_POSITION
+      if (options = args.last).is_a? Hash
+        message = options[:message] if options[:message]
+        caption = options[:caption] if options[:caption]
+        style = options[:style] if options[:style]
+        pos = options[:pos] if options[:pos]
+      end
+
+      dialog_style = (style & (Wx::OK|Wx::CANCEL|Wx::YES|Wx::NO|Wx::HELP|Wx::NO_DEFAULT)) == 0 ? Wx::CAPTION : Wx::DEFAULT_DIALOG_STYLE
+      super(parent, Wx::ID_ANY, caption, pos, Wx::DEFAULT_SIZE, dialog_style)
+      @parent = parent          # for SemiModalDialog
+      
+      top_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+      icon_text = Wx::BoxSizer.new(Wx::HORIZONTAL)
+      
+      if (style & Wx::ICON_MASK) != 0
+        @@icon_map ||= {Wx::ICON_ERROR => Wx::ART_ERROR, Wx::ICON_INFORMATION => Wx::ART_INFORMATION, Wx::ICON_WARNING => Wx::ART_WARNING, Wx::ICON_QUESTION => Wx::ART_QUESTION}
+        @@icon_map.default ||= Wx::ART_ERROR
+        icon_text.add(Wx::StaticBitmap.new(self, Wx::ID_ANY, Wx::ArtProvider.get_icon(@@icon_map[style & Wx::ICON_MASK], Wx::ART_MESSAGE_BOX)), 0, Wx::CENTER)
+      end
+    
+      icon_text.add(Wx::StaticText.new(self, Wx::ID_ANY, message.gsub('&','&&')), 0, Wx::ALIGN_CENTER | Wx::LEFT, 10)
+      top_sizer.add(icon_text, 1, Wx::CENTER | Wx::LEFT|Wx::RIGHT|Wx::TOP, 10)
+      
+      center_flag = Wx::EXPAND
+      center_flag = Wx::ALIGN_CENTRE if (style & Wx::YES_NO) != 0
+      center_flag = Wx::ALIGN_CENTRE if RUBY_PLATFORM =~ /win/
+      sizer_btn = create_button_sizer(style & (Wx::OK|Wx::CANCEL|Wx::YES|Wx::NO|Wx::HELP|Wx::NO_DEFAULT))
+      top_sizer.add(sizer_btn, 0, center_flag | Wx::ALL, 10)
+      
+      set_auto_layout(true)
+      set_sizer(top_sizer)
+
+      top_sizer.set_size_hints(self)
+      top_sizer.fit(self)
+      size = get_size
+      if size.get_width < size.get_height*3/2
+        size.set_width(size.get_height*3/2)
+        set_size(size)
+      end
+
+      centre(Wx::BOTH | Wx::CENTER_FRAME)
+      
+      evt_button(Wx::ID_YES) { end_modal(Wx::ID_YES) }
+      evt_button(Wx::ID_NO) { end_modal(Wx::ID_NO) }
+      evt_button(Wx::ID_CANCEL) do
+        # Allow cancellation via ESC/Close button except if only YES and NO are specified.
+        end_modal(Wx::ID_CANCEL) if (style & Wx::YES_NO) != Wx::YES_NO || (style & Wx::CANCEL) != 0
+      end
+    end
+  
+  end
+end

data/lib/reactive-wx/wx_ext/panel_dialog.rb

@@ -0,0 +1,14 @@
+module WxExtensions
+  class PanelDialog < Wx::Dialog
+    attr_reader :panel
+    
+    def initialize(*args)
+      super(*args, &nil)      # We explicitely pass a nil block because WxSugar would call the block (We'll call it with a return value...)
+      arrange_vertically
+      @panel = yield self
+      nest(@panel, :proportion => 1)
+      # TODO: set size to the best size
+    end
+  
+  end
+end

data/lib/reactive-wx/wx_ext/semi_modal.rb

@@ -0,0 +1,233 @@
+module WxExtensions
+  # This class acts like a Wx::Panel but will be the root for semi-modal windows (or dialogs)
+  # When any children of this RootPanel invokes semi-modal, all the children of this panel will be disabled,
+  # and only the semi-modal window will be active.
+  class RootPanel < Wx::Panel
+    
+    # Look for the topmost RootPanel in the ancestors
+    def self.find_root_panel(current)
+      # If current is already a top level, look for a RootPanel in his parent
+      current = current.get_parent if current.is_a? Wx::TopLevelWindow
+      
+      root_panel = nil
+      begin
+        case current
+          when nil
+            break
+          when RootPanel
+            root_panel = current
+          when Wx::TopLevelWindow
+            break
+        end
+        current = current.get_parent
+      end while current
+      
+      raise StandardError.new("There are no RootPanel in the ancestors!") if root_panel.nil?
+      root_panel
+    end
+    
+    def disable_children
+      @screener = Wx::Frame.new(self, :style => #Wx::FRAME_TOOL_WINDOW |
+                                         Wx::FRAME_FLOAT_ON_PARENT |
+                                         Wx::FRAME_NO_TASKBAR |
+                                         #Wx::NO_BORDER |
+                                         0,
+                                         :size => self.size, :pos => self.get_screen_position)
+      @screener.set_background_colour(Wx::SystemSettings.get_colour(Wx::SYS_COLOUR_ACTIVECAPTION))
+      @screener.set_transparent(128)
+      @screener.show
+      
+      top_level = find_top_level
+
+      # Hooks to handle moving and resizing
+      resize_block = proc do |event|
+        update_screener
+        @user_resize_block.call if @user_resize_block
+        event.skip
+      end
+      top_level.evt_moving() {|event| update_screener; event.skip}
+      top_level.evt_move() {|event| update_screener; event.skip}
+      evt_sizing(&resize_block)
+      evt_size(&resize_block)
+      
+      # Hooks for handling showing/hiding
+      @screener.evt_activate() do |event|
+        @user_visible_block.call(true) if @user_visible_block && event.get_active
+        event.skip
+      end
+      evt_set_focus() do |event|
+        @user_visible_block.call(true) if @user_visible_block
+        event.skip      # TODO: Not sure if this is wanted... to be checked on the different platforms
+      end
+      @timer = Wx::Timer.every(100) do
+        # TODO: This timer may tick after window deletion (when the app exits) and thus crash on the *is_shown* method. DONE with evt_window_destroy
+        if (shown = is_shown) != @shown
+          @shown = shown
+          # handle screener
+          if @screener
+            update_screener if shown
+            @screener.show(shown)
+          end
+          # handler user window
+          @user_resize_block.call if @user_resize_block && shown
+          @user_visible_block.call(shown) if @user_visible_block
+        end
+      end
+      evt_window_destroy() do |event|
+        @timer.stop if @timer
+        event.skip
+      end
+    
+      # Hook to handle client closing
+      # TODO: BUG: event handler used to be on the top_level window, now on the root panel. Test it. This change moves wxruby to be unstable
+      evt_close() do |event|
+        veto = nil
+        veto = @user_close_block.call(event) if @user_close_block
+        veto ? event.veto : event.skip
+      end
+
+=begin only when the patched version of wxAui will be commited in wxWidgets trunk
+      # Is the TopLevelWindow of this root panel managed by Aui?
+      handler = top_level.get_event_handler
+      begin
+#        puts "PROCESSING handler #{handler}"
+        aui_manager = case handler
+          when Wx::AuiManager
+            handler
+          when Wx::AuiFloatingFrame
+            handler.get_owner_manager
+          else
+            nil
+        end
+        if aui_manager
+#          puts "MANAGED by #{aui_manager}"
+          pi = aui_manager.get_pane(self)
+#          puts "WITH PI #{pi}"
+          if pi
+            @aui_manager = aui_manager
+            @pi_floatable = pi.is_floatable
+            @pi_dockable = pi.is_dockable
+            pi.set_floatable(false).set_dockable(false)
+            #@aui_manager.update
+          end
+          break
+        end
+      end while handler = handler.get_next_handler
+=end
+    end
+  
+    def enable_children
+      if @aui_manager
+        if pi = @aui_manager.get_pane(self)
+          pi.set_floatable(@pi_floatable).set_dockable(@pi_dockable)
+        end
+      end
+      
+      top_level = find_top_level
+      top_level.disconnect(Wx::ID_ANY, Wx::ID_ANY, :evt_moving)
+      top_level.disconnect(Wx::ID_ANY, Wx::ID_ANY, :evt_move)
+      disconnect(Wx::ID_ANY, Wx::ID_ANY, :evt_close)
+      disconnect(Wx::ID_ANY, Wx::ID_ANY, :evt_sizing)
+      disconnect(Wx::ID_ANY, Wx::ID_ANY, :evt_size)
+      
+      @timer.stop if @timer
+      @user_resize_block = nil
+      @user_visible_block = nil
+      
+      @screener.destroy
+      @screener = nil
+    end
+
+    # The passed block will be called when the RootPanel is resized.
+    def on_resize(&block)
+      @user_resize_block = block
+    end
+
+    # The passed block will be called when the RootPanel is activated or gains focus.
+    # The block should receive one argument which will be a boolean indicating if it should be made visible.
+    # Note that setting your window visible may not be enough, #raise should put it in front.
+    def on_visible(&block)
+      @user_visible_block = block
+    end
+  
+    # The passed block will be called when the TopLevel window of this RootPanel is requested
+    # to close. The return code of the block is a boolean value indicating if the close should be vetoed.
+    # (Thus the normal block is: { not close }
+    def on_close(&block)
+      @user_close_block = block
+    end
+  
+    protected
+    
+      def update_screener
+        @screener.set_size(Wx::Rect.new(get_screen_position, size))
+      end
+
+      # don't memoize this method, because the top level may change when docking/floating this panel
+      def find_top_level
+        # Look for the first top_level window in the ancestors
+        top_level = self
+        top_level = top_level.get_parent until top_level.is_top_level
+        top_level
+      end
+  
+  end
+
+  # Extension for the Dialog class to allow semi-modal dialogs
+  module SemiModalDialog
+
+    def self.included(base) #:nodoc:
+      base.send :alias_method_chain, :end_modal, :semi_handling
+      base.send :alias_method_chain, :is_modal, :semi_handling
+    end
+
+    # shows the dialog semi-modally.
+    # This method will return immediately, you should pass a block to allow processing
+    # when the dialog is dismissed. The block will be passed the returned ID
+    # Example:
+    #   dlg.show_semi_modal do |id|
+    #     case id
+    #       when Wx::ID_OK
+    #         ...
+    #       when Wx::ID_CANCEL
+    #         ...
+    #     end
+    #   end
+    def show_semi_modal(destroy_on_close = true, &block)
+      @root_panel = RootPanel.find_root_panel(@parent || self)    # @parent may be set by MessageDialog
+      
+      @semi_modal_block = block
+      @showing_semi_modal = true
+      @destroy_on_close = destroy_on_close
+
+      # FIXME: Until wxRuby 2.0.0 fix the issue #, we have to handle the dismiss ourselves
+      evt_close { end_modal_with_semi_handling(Wx::ID_CANCEL) }
+      evt_button(Wx::ID_CANCEL) { end_modal_with_semi_handling(Wx::ID_CANCEL) }
+      # END OF FIXME
+
+      @root_panel.on_visible {|visible| show(visible); bring_to_front if visible }
+      @root_panel.on_resize { set_size(get_rect.centre_in(@root_panel.get_screen_rect)) }
+      @root_panel.on_close { !close }
+      @root_panel.disable_children
+
+      # Show dialog
+      centre_on_parent
+      show
+    end
+
+    def is_modal_with_semi_handling
+      @showing_semi_modal || is_modal_without_semi_handling
+    end
+  
+    def end_modal_with_semi_handling(code)
+      return end_modal_without_semi_handling(code) unless @showing_semi_modal
+
+      @root_panel.enable_children
+      
+      @semi_modal_block.call(code) if @semi_modal_block
+      @showing_semi_modal = false
+      @destroy_on_close ? destroy : hide
+    end
+    
+  end
+end