wx_sugar 0.1.19 → 0.1.20

data/lib/wx_sugar/layout.rb

@@ -66,10 +66,13 @@ module Arranger
       return @current_sizer 
     else
       begin 
-        return self.get_sizer
-      rescue RuntimeError
+        if @current_sizer = self.get_sizer
+          return @current_sizer
+        end
+      rescue RuntimeError # Some wxRuby versions would error on get_sizer
       end
     end
+    
     @current_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
     self.set_sizer(@current_sizer)
     @current_sizer

data/lib/wx_sugar/version.rb

@@ -1,3 +1,3 @@
 module WxSugar
-  VERSION = '0.1.19'
+  VERSION = '0.1.20'
 end

data/lib/wx_sugar/xrc/outputter.rb

@@ -4,56 +4,56 @@ require 'ostruct'
 # Provides templated output of a Ruby subclass from an XRC specification
 # of a ruby Frame, Dialog or Panel class.
 class Outputter
-  # Valid options are :app_name and :module_name
-  attr_accessor :options, :klass
+	# Valid options are :app_name and :module_name
+	attr_accessor :options, :klass
 
-  # Creates a new outputter from the XRCClass +xrc_class+
-  def initialize(xrc_class, options = {})
-    @klass = xrc_class
-    @options = options
-  end
+	# Creates a new outputter from the XRCClass +xrc_class+
+	def initialize(xrc_class, options = {})
+		@klass = xrc_class
+		@options = options
+	end
 
-  # Writes the ruby code to the file or stream +io+
-  def output(io = $stdout)
-    tpl = ERB.new(TEMPLATE)
-    io.puts( tpl.result(binding) )
-  end
+	# Writes the ruby code to the file or stream +io+
+	def output(io = $stdout)
+		tpl = ERB.new(TEMPLATE)
+		io.puts( tpl.result(binding) )
+	end
 
-  # Returns the fully-qualified (including module namespace prefix) for
-  # +name+.
-  def fq_name(name)
-    options[:namespace] ? "#{options[:namespace]}::#{name}" : name
-  end
+	# Returns the fully-qualified (including module namespace prefix) for
+	# +name+.
+	def fq_name(name)
+		options[:namespace] ? "#{options[:namespace]}::#{name}" : name
+	end
 
-  # Returns the options object 
-  def opts
-    OpenStruct.new(options)
-  end
+	# Returns the options object 
+	def opts
+		OpenStruct.new(options)
+	end
 
-  # Utility function to format the attr_readers line so it doesn't wrap
-  # in editors
-  def clean_id_attr_readers(str, start_len = 15, one_per_line = false)
-    new_string = ''
-    
-    if one_per_line
-      str.each(',') do | x |
-        new_string << x
-        new_string << "\n" + " " * (start_len-2)        
-      end
-    else      
-      wanted_length = 72
-      current_line_length = start_len
-      str.each(',') do |x|
-        if (current_line_length + x.length) > wanted_length
-          new_string << "\n" + " " * (start_len-2)
-          current_line_length = start_len
-        end
-        new_string << x
-        current_line_length += x.length      
-      end 
-    end
-    return new_string 
-  end
+	# Utility function to format the attr_readers line so it doesn't wrap
+	# in editors
+	def clean_id_attr_readers(str, start_len = 15, one_per_line = false)
+		new_string = ''
+		
+		if one_per_line
+			str.each(',') do | x |
+				new_string << x
+				new_string << "\n" + " " * (start_len-2)        
+			end
+		else			
+			wanted_length = 72
+			current_line_length = start_len
+			str.each(',') do |x|
+				if (current_line_length + x.length) > wanted_length
+					new_string << "\n" + " " * (start_len-2)
+					current_line_length = start_len
+				end
+				new_string << x
+				current_line_length += x.length      
+			end 
+		end
+		return new_string 
+	end
 end
 
 
@@ -72,39 +72,42 @@ end
 # Generated at: <%= Time.now %>
 
 class <%= fq_name(klass.sub_class) %> < <%= klass.superclass %>
-  <% if not klass.controls.empty? %><% ids = klass.controls.map { | ctrl | ":#{ctrl.name.downcase}" }.join(', ') %>
-  attr_reader <%= clean_id_attr_readers(ids) %>
-  <% end %>
-  def initialize(parent = nil)
-    super()
-    xml = Wx::XmlResource.get
-    xml.flags = 2 # Wx::XRC_NO_SUBCLASSING
-    xml.init_all_handlers
-    xml.load("<%= klass.file_name %>")
-    xml.<%= klass.load_func %>(self, parent, "<%= klass.base_id %>")
+	<% if not klass.controls.empty? %><% ids = klass.controls.map { | ctrl | ":#{ctrl.name.downcase}" }.join(', ') %>
+	attr_reader <%= clean_id_attr_readers(ids) %>
+	<% end %>
+	def initialize(parent = nil)
+		super()
+		xml = Wx::XmlResource.get
+		xml.flags = 2 # Wx::XRC_NO_SUBCLASSING
+		xml.init_all_handlers
+		xml.load("<%= klass.file_name %>")
+		xml.<%= klass.load_func %>(self, parent, "<%= klass.base_id %>")
 
-    finder = lambda do | x | 
-      int_id = Wx::xrcid(x)
-      begin
-        Wx::Window.find_window_by_id(int_id, self) || int_id
-      # Temporary hack to work around regression in 1.9.2; remove
-      # begin/rescue clause in later versions
-      rescue RuntimeError
-        int_id
-      end
-    end
-    <% klass.controls.each do | ctrl | %>
-    @<%= ctrl.name.downcase %> = finder.call("<%= ctrl.name %>")<% if ctrl.sub_class %>
-    @<%= ctrl.name.downcase %>.extend(<%= fq_name(ctrl.sub_class) %>)<% end %><% end %>
-  end
+		finder = lambda do | x | 
+			int_id = Wx::xrcid(x)
+			begin
+				Wx::Window.find_window_by_id(int_id, self) || int_id
+			# Temporary hack to work around regression in 1.9.2; remove
+			# begin/rescue clause in later versions
+			rescue RuntimeError
+				int_id
+			end
+		end
+		<% klass.controls.each do | ctrl | %>
+		@<%= ctrl.name.downcase %> = finder.call("<%= ctrl.name %>")<% if ctrl.sub_class %>
+		@<%= ctrl.name.downcase %>.extend(<%= fq_name(ctrl.sub_class) %>)<% end %><% end %>
+		if self.class.method_defined? "on_init"
+			self.on_init()
+		end
+	end
 end
 
 <% if opts.app_name %>
 class <%= opts.app_name %> < Wx::App
-  def on_init
-    f =  <%= opts.module_name %>::<%= fq_name(klass.sub_class) %>.new
-    f.show
-  end
+	def on_init
+		f =  <%= opts.module_name %>::<%= fq_name(klass.sub_class) %>.new
+		f.show
+	end
 end
 <%= opts.app_name %>.new.main_loop
 <% end %>

data/lib/wx_sugar/xrc/xrc2ruby.rb

@@ -0,0 +1,121 @@
+# container module
+module XRC2Ruby
+  # Whether the ruby code output should include hooks for ruby-gettext,
+  # used for internationalisation of applications. 
+  def self.use_gettext
+    @gettext
+  end
+
+  # Sets whether gettext hooks should be included.
+  def self.use_gettext=(gettext)
+    @gettext = gettext
+  end
+
+  # Load definitions that know how to output Ruby code
+  requires = %w|object window parent sizers containers toplevelwindows 
+                static buttons text lists range books menu toolbar|
+  requires.each do | req_file |
+    require "wx_sugar/xrc/xrc2ruby_types/#{req_file}"
+  end
+
+  # Use REXML stream parsing
+  require 'rexml/streamlistener'
+  require 'rexml/parsers/baseparser'
+  require 'rexml/parsers/streamparser'
+
+  # The parser goes through the XRC file and identifies top-level
+  # frames/dialogs and their child windows. Each window is turned into
+  # an instance of an ObjectType class; sizers and sizer settings are
+  # also stored. Each ObjectType stores the parameters associated with
+  # that specific type of window, and then can later output the wxRuby
+  # code to create that window.
+  class Parser
+    include REXML::StreamListener
+    include ObjectTypes
+
+    # The stack of all objects found - pushed onto when the tag opens,
+    # popped off when the tag closes
+    attr_reader :stack
+
+    def initialize
+      @stack = []
+    end
+
+    # The most recent  parent
+    def last_parent
+      @stack.reverse.find { | obj | obj.kind_of? Parent }
+    end
+
+    # The most recent sizer
+    def last_sizer
+      @stack.reverse.find { | obj | obj.kind_of? Sizer }
+    end
+
+    # Process a tag opening
+    def tag_start(tag, attrs)
+      case tag
+      when 'resource' 
+        # Top-level tag, ignore
+      when 'object' # Some kind of object
+        case attrs['class']
+        # A set of sizer settings
+        when 'sizeritem'
+          stack.push( SizerItem.new(last_sizer) )
+
+        # Some "special" object not corresponding to 
+        when 'panewindow', 'tool', 'separator'
+          special = ObjectTypes.const_get(attrs['class'].upcase)
+          stack.push( special.new(last_parent, attrs['name']) )
+        # An ordinary window
+        when /^wx/
+          # Look up the correct representation for this object type
+          kls = ObjectTypes.const_get(attrs['class'][2..-1])
+          # Create and link to parent
+          win = kls.new( last_parent,
+                         attrs["class"], 
+                         attrs["subclass"],
+                         attrs["name"])
+
+          if last_parent
+            last_parent.add_child(win)
+          end
+
+          # Associate this with the containing sizer item, if there is one
+          if stack.last.kind_of?(SizerItem)
+            stack.last.window = win
+          end
+          stack.push(win)
+        else
+          Kernel.raise "Unexpected object of type '#{attrs['class']}' found"
+        end
+      else # All other tags are type-specific settings for the current tag
+        @next_setting = "#{tag}="
+      end
+    end
+
+    # When text is encountered, if non-empty it should be the value for
+    # a setting (eg <label> within a wxButton tag)
+    def text(text)
+      # Ignore empty
+      return if text =~ /\A\s*\z/
+      if @next_setting
+        @stack.last.send(@next_setting, text)
+      end
+      @next_setting = nil
+    end
+
+    # Process a tag ending
+    def tag_end(tag)
+      case tag
+      when 'object'
+        if stack.last.kind_of?(SizerItem)
+          last_parent.size_child(@stack.last)
+        end
+        if stack.length == 1
+          puts stack.first.output
+        end
+        @stack.pop
+      end
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/books.rb

@@ -0,0 +1,3 @@
+module XRC2Ruby::ObjectTypes
+
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/buttons.rb

@@ -0,0 +1,40 @@
+module XRC2Ruby::ObjectTypes
+  # Several similar control classes have a standard Window constructor
+  # with a text label; they can all share the same class
+  class Labelled < Window
+    translatable_string_init_arg(:label)
+  end
+
+  # These are the Wx classes that share the constructor
+  class Button < Labelled; end
+  class ToggleButton < Labelled; end
+  class CheckBox < Labelled; end
+  class RadioButton < Labelled; end
+
+  class BitmapButton < Window
+    attr_accessor :focus, :selected, :disabled, :hover
+    init_arg(:bitmap) do | val | 
+      "Wx::Bitmap.new('#{val}')"
+    end
+    
+    # Call extra methods to set up images for alternate states, if these
+    # have been defined in the XRC file.
+    def setup
+      [ :focus, :selected, :disabled, :hover ].inject('') do | out, extra_img |
+        if send(extra_img)
+          out << "#{var_name}.bitmap_#{extra_img} = "
+          out << " Wx::Bitmap.new('#{send(extra_img)}')\n"
+        end
+        out
+      end
+    end
+  end
+
+  class SpinButton < Window
+    attr_accessor :min, :max, :value
+    def setup
+      "#{var_name}.set_range(#{min}, #{max})\n" +
+        "#{var_name}.value = #{value}\n"
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/containers.rb

@@ -0,0 +1,105 @@
+module XRC2Ruby::ObjectTypes
+  class Container < Window
+    include Parent
+  end
+  # These don't need any special setup
+  class Panel < Container; end
+  class SashWindow < Container; end
+  class SashLayoutWindow < Container; end
+
+  class ScrolledWindow < Container
+    attr_accessor :ppux, :ppuy, :unitsx, :unitsy
+    def setup
+      "#{var_name}.set_scrollbars(#{ppux}, #{ppuy}, #{unitsx}, #{unitsy})"
+    end
+  end
+
+  # This has several options
+  class SplitterWindow < Container
+    attr_accessor :orientation, :sashpos, :minsize, :gravity
+
+    def output 
+      # Fiddly - we have to have created the child windows before we can
+      # split them in the 
+      base = super 
+
+      unless children
+        Kernel.raise "SplitterWindow must have children to split"
+      end
+      child_wins = children.grep(Window)
+      if child_wins.length != 2
+        Kernel.raise "SplitterWindow must have exactly two children"
+      end
+
+      child_args = "#{child_wins[0].var_name}, #{child_wins[1].var_name}"
+      if orientation == 'vertical'
+        base << "#{var_name}.split_vertically(#{child_args})\n"
+      else
+        base << "#{var_name}.split_horizontally(#{child_args})\n"
+      end
+      base
+    end
+
+    def setup 
+      setup = ""
+      if minsize
+        setup << "#{var_name}.minimum_pane_size = #{minsize}\n"
+      end
+      if sashpos
+        setup << "#{var_name}.sash_position = #{sashpos}\n"
+      end
+      if gravity
+        setup << "#{var_name}.sash_gravity = #{gravity}\n"
+      end
+
+      setup
+    end
+  end
+  
+  class CollapsiblePane < Container
+    translatable_string_init_arg(:label)
+    attr_accessor :collapsed
+    def setup
+      if collapsed.to_i.zero?
+        "#{var_name}.expand"
+      else
+        "#{var_name}.collapse"
+      end
+    end
+    
+    def pane=(pane)
+      @children = [pane]
+    end
+  end
+
+  # Special class for the interior pane of a CollapsiblePane; not
+  # represented by a "real" Window in wxRuby, instead accessed via
+  # CollapsiblePane#get_pane
+  class PANEWINDOW < Container
+    attr_reader :coll_pane
+    def initialize(coll_pane, an_id = nil)
+      @coll_pane = coll_pane
+      @coll_pane.pane = self
+    end
+
+    def var_name 
+      "#{coll_pane.var_name}.pane"
+    end
+
+    def output
+      "\n" + child_output
+    end
+  end
+
+  class StatusBar < Container
+    attr_accessor :fields, :widths
+    def setup
+      setup = "#{var_name}.fields_count = #{fields}"
+      if widths
+        setup << "\n#{var_name}.status_widths = [ #{widths} ]"
+      end
+      setup << "\n#{parent.var_name}.status_bar = #{var_name}"
+      setup
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/lists.rb

@@ -0,0 +1,45 @@
+module XRC2Ruby::ObjectTypes
+  # Several similar classes with list of strings
+  class ControlWithItems < Window
+    attr_accessor :selection
+
+    init_arg(:choices) do | val |
+      if XRC2Ruby.use_gettext
+        items = val.map { | c | "_(" + c.inspect + ")" }
+      else
+        items = val.map { | c | c.inspect }
+      end
+      "[ " + items.join(", ") + " ]"
+    end
+
+    def initialize(*args)
+      super
+      @choices = []
+    end
+
+    def item=(item)
+      @choices << item
+    end
+
+    def setup
+      self.selection ? "#{var_name}.selection = #{selection}" : ""
+    end
+  end
+  # The actual Wx classes of this type
+  class ListBox < ControlWithItems; end
+  class CheckListBox < ControlWithItems; end
+  class Choice < ControlWithItems; end
+  class ComboBox < ControlWithItems; end
+  class BitmapComboBox < ControlWithItems; end
+  class ListCtrl < Window; end
+
+
+  class RadioBox < ControlWithItems
+    translatable_string_init_arg(:label)
+    # The XRC element is called "dimension" but the wxRuby arg is called
+    # "major_dimension" - so make interchangeable
+    init_arg(:major_dimension) { | val | val }
+    alias :dimension :major_dimension
+    alias :dimension= :major_dimension=
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/menu.rb

@@ -0,0 +1,86 @@
+module XRC2Ruby::ObjectTypes
+  class MenuBar < Window
+    include Parent
+    def output
+      "#{var_name} = Wx::MenuBar.new\n" +
+      child_output +
+      "#{parent.var_name}.menu_bar = #{var_name}\n"
+    end
+  end
+
+  class Menu < Window
+    include Parent
+    attr_accessor :label
+
+    def output
+      if XRC2Ruby.use_gettext
+        the_label = "_(" + label.inspect + ")"
+      else
+        the_label = label.inspect
+      end
+      # A standard menu attached to menubar; NB - call to append must
+      # come after all menu items have been created
+      if parent.kind_of?(MenuBar)
+        "#{var_name} = Wx::Menu.new\n" +
+        child_output +
+        "#{parent.var_name}.append(#{var_name}, #{the_label})\n"
+      # If a submenu
+      elsif parent.kind_of?(Menu)
+        output_as_submenu(the_label)
+      else
+        Kernel.raise("Menu shouldn't be attached to a #{parent.class}")
+      end
+    end
+
+    def output_as_submenu(label)
+      
+      menu_item = MenuItem.new(parent, 'wxMenuItem', 'wxMenuItem', '')
+      menu_item.label = self.label
+      menu_item.submenu = self.var_name
+      submenu = "#{var_name} = Wx::Menu.new\n" + child_output + menu_item.output
+    end
+  end
+
+  class MenuItem < Object
+    attr_accessor :label, :checkable, :radio, :checked, :help, :submenu
+
+    def initialize(parent, klass, subclass, name)
+      super
+      # stock id
+      if name.sub!(/^wx/, "Wx::")
+        @menu_id = name
+      end
+    end
+
+    def output
+      @help ||= ''
+
+      # What type of menu item?
+      if radio
+        item_type = "Wx::ITEM_RADIO"
+      elsif checkable
+        item_type = "Wx::ITEM_CHECK"
+      else
+        item_type = "Wx::ITEM_NORMAL"
+      end
+
+      # Using a stock id
+      if @menu_id
+        m_i = "#{var_name} = Wx::MenuItem.new(#{parent.var_name}, #{@menu_id})"
+      else
+        if XRC2Ruby.use_gettext
+          the_label = "_(" + label.inspect + ")"
+          the_help  = "_(" + help.inspect + ")"
+        else
+          the_label = label.inspect
+          the_help  = help.inspect
+        end
+        the_submenu = submenu || "nil"
+        m_i = "#{var_name} = Wx::MenuItem.new(#{parent.var_name}, Wx::ID_ANY,
+                   #{the_label}, #{the_help}, 
+                   #{item_type}, #{the_submenu})"
+      end
+      m_i + "\n" + "#{parent.var_name}.append_item(#{var_name})"
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/object.rb

@@ -0,0 +1,39 @@
+module XRC2Ruby::ObjectTypes
+  # Anything deriving from Wx::Object
+  class Object
+    attr_accessor :centered
+
+    def inspect 
+      "<#{self.class}>"
+    end
+    def self.next_id
+      @id_counter ||= 0
+      @id_counter += 1
+    end
+
+    attr_reader :parent, :win_class, :sub_class, :name
+    def initialize(parent, win_class, sub_class = nil, var_name = nil)
+      @parent    = parent
+      @win_class = win_class.gsub(/^wx/, "Wx::")
+      @sub_class = sub_class
+      
+      # A named and externally accessible item
+      if var_name and not var_name.empty? and 
+         var_name !~ /^ID_/ and var_name !~ /^wx/
+        @name = "@#{var_name.downcase}"
+      # Or just a local name
+      else
+        @local_id = Object.next_id
+      end
+    end
+
+    def var_name
+      @name || "#{self.class.name[/\w+$/].downcase}_#{@local_id}"
+    end
+
+    def output
+      # Should be defined in subclasses
+      Kernel.raise "Shouldn't be called"
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/parent.rb

@@ -0,0 +1,59 @@
+module XRC2Ruby::ObjectTypes
+  # Module used by all Windows which can contain other windows,
+  # optionally arranging those windows with a Sizer
+  module Parent 
+    attr_reader :children, :sizer_items, :main_sizer
+
+    def add_child(child)
+      @children ||= []
+      @children << child
+      if child.kind_of?(Sizer) and not main_sizer
+        @main_sizer = child
+      end
+    end
+
+    # Associates a sizer_item with this parent; keep a map of which
+    # settings apply to which child
+    def size_child(sizer_item)
+      @sizers ||= {}
+      @sizers[sizer_item.window] = sizer_item
+    end
+    
+    def output
+      super + child_output
+    end
+
+    # Returns a string containing the ruby code needed to instantiate
+    # all the child windows of this container, as well as arranging them
+    # in any sizer.
+    def child_output
+      output = ''
+      if children
+        children.each_with_index do | child, i |
+          output += child.output + "\n"
+          if @sizers and ( sizer_item = @sizers[child] )
+            output += sizer_item.output
+          end
+        end
+      end
+
+      if self.main_sizer
+        output << "#{var_name}.sizer = #{main_sizer.var_name}"
+      end
+      output
+    end
+
+    # Collects all the contained windows (recursively) that have
+    # user-defined names that should be exposed externally. Used by
+    # top-level windows to create a list of attribute readers to access
+    # named controls within the window.
+    def named_windows
+      return [] unless children
+      children.inject([]) do | names, child |
+        names << child.name if child.name
+        names += child.named_windows if child.kind_of?(Parent)
+        names
+      end
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/range.rb

@@ -0,0 +1,32 @@
+module XRC2Ruby::ObjectTypes
+
+  class ScrollBar < Window
+    attr_accessor :value, :range, :thumbsize, :pagesize
+    def setup
+      "#{var_name}.set_scrollbar(#{value}, #{thumbsize}, #{range}, #{pagesize})"
+    end
+  end
+  class SpinCtrl < Window
+    init_arg(:min) { | val | val }
+    init_arg(:max) { | val | val }
+    # This is called "value" in XRC but "initial" as a constructor
+    # keyword arg
+    init_arg(:initial) { | val | val }
+    alias :value :initial
+    alias :value= :initial=
+  end
+
+  class Slider < Window
+    # These are called "xxx_value" as keyword constructor arguments, but
+    # simply min/max in XRC
+    init_arg(:min_value) { | val | val }
+    alias :min :min_value
+    alias :min= :min_value=
+    init_arg(:max_value) { | val | val }
+    alias :max :max_value
+    alias :max= :max_value=
+
+    init_arg(:value) { | val | val }
+  end
+end
+

data/lib/wx_sugar/xrc/xrc2ruby_types/sizers.rb

@@ -0,0 +1,39 @@
+module XRC2Ruby::ObjectTypes
+  # Represents the settings for a particular Window added to a
+  # container's sizer; corresponds to the <object class="sizeritem"> tag
+  # in XRC.
+  class SizerItem
+    attr_reader :flag
+    attr_accessor :border, :option, :window, :sizer
+
+    # Create a new sizer item contained within the sizer +sizer+, set up
+    # default sizer options
+    def initialize(sizer)
+      @sizer  = sizer
+      @option = 0
+      @flag   = 0
+      @border = 0
+    end
+
+    def flag=(flag)
+      @flag = flag.gsub(/wx/, "Wx::")
+    end
+
+    # Output a Sizer#add statement, adding +window+ to +sizer+
+    def output
+      "#{sizer.var_name}.add(#{window.var_name}, #{option}, #{flag}, #{border})\n"
+    end
+  end
+
+  # Actual sizers
+  class Sizer < Object
+    BASE_NAME = "sizer"
+  end
+
+  class BoxSizer < Sizer
+    attr_accessor :orient
+    def output
+      "#{var_name} = Wx::BoxSizer.new(#{orient.gsub(/^wx/, "Wx::")})\n"
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/static.rb

@@ -0,0 +1,24 @@
+module XRC2Ruby::ObjectTypes
+  class StaticText < Window
+    translatable_string_init_arg(:label)
+  end
+
+  class StaticBox < Window
+    translatable_string_init_arg(:label)
+  end
+
+  class StaticBitmap < Window
+    init_arg(:label) { | val | "Wx::Bitmap.new('#{val}')" }
+  end
+
+  # No extra args needed
+  class StaticLine < Window; end
+
+  class Gauge < Window
+    attr_accessor :value
+    init_arg(:range) { | val | val }
+    def setup
+      value ? "#{var_name}.value = #{value}\n" : ""
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/text.rb

@@ -0,0 +1,10 @@
+module XRC2Ruby::ObjectTypes
+  class TextCtrl < Window
+    translatable_string_init_arg(:value)
+  end
+  class SearchCtrl < Window
+    translatable_string_init_arg(:value)
+  end
+  class StyledTextCtrl < Window
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/toolbar.rb

@@ -0,0 +1,86 @@
+module XRC2Ruby::ObjectTypes
+  class ToolBar < Window
+    include Parent
+    attr_accessor :dontattachtoframe
+    def initialize(*args)
+      super
+      @tools = []
+    end
+
+    def add_tool(tool)
+      @tools << tool
+    end
+
+    def setup
+      @tools.inject('') { | str, tool | str + tool.output }
+    end
+  end
+
+  # Not a real wxRuby class; individual tools are created by calls to
+  # add_tool and friends.
+  class TOOL
+    attr_reader :toolbar, :var_name
+    attr_accessor :bitmap, :bitmap2, :label,
+                  :radio, :toggle,
+                  :help, :longhelp, :tooltip
+
+    def initialize(toolbar, an_id)
+      @toolbar  = toolbar
+        @var_name = an_id.downcase
+      if an_id.sub!(/^wx/, "Wx::")
+        @stock_id = an_id
+      end
+      @toolbar.add_tool(self)
+    end
+
+    def output
+      @label ||= ''
+      @help ||= ''
+      @longhelp  ||= ''
+
+      # Normal bitmap
+      if bitmap
+        bmp1 = "Wx::Bitmap.new(#{self.bitmap.inspect}, Wx::BITMAP_TYPE_PNG)"
+      else
+        bmp1 = "Wx::NULL_BITMAP"
+      end
+
+      # Disabled bitmap
+      if bitmap2
+        bmp2 = "Wx::Bitmap.new(#{self.bitmap2.inspect}, Wx::BITMAP_TYPE_PNG)"
+      else
+        bmp2 = "Wx::NULL_BITMAP"
+      end
+
+      # What type of tool?
+      if radio
+        tooltype = "Wx::ITEM_RADIO"
+      elsif toggle
+        tooltype = "Wx::ITEM_CHECK"
+      else
+        tooltype = "Wx::ITEM_NORMAL"
+      end
+      if @stock_id
+        the_id = @stock_id
+      else
+        the_id = "Wx::ID_ANY"
+      end
+      # This is the most general form of add_tool 
+      "#{var_name} = #{toolbar.var_name}.add_tool(#{the_id},
+                                                  #{label.inspect},
+                                                  #{bmp1},
+                                                  #{bmp2},
+                                                  #{tooltype},
+                                                  #{help.inspect},
+                                                  #{longhelp.inspect})\n"
+
+    end
+  end
+
+  class SEPARATOR
+    attr_reader :toolbar
+    def initialize(toolbar_or_menu, an_id = nil)
+      @toolbar = toolbar_or_menu
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/toplevelwindows.rb

@@ -0,0 +1,29 @@
+module XRC2Ruby::ObjectTypes
+  # All windows which may be top-level containers (eg Frames,
+  # Dialogs). In particular, they may become named ruby subclasses
+  class TopLevelWindow < Window
+    include Parent
+    attr_accessor :title
+    def output
+      if not named_windows.empty?
+        attr_reader = "attr_reader " + 
+          named_windows.map { | name | name.tr('@', ':') }.join(', ')
+      end
+
+      @name = "self"
+      # get child widgets code and indent to four spaces
+      "class #{sub_class} < #{win_class}
+  #{attr_reader}" +
+  ( XRC2Ruby.use_gettext ? "include GetText\n" : "" ) + "
+  def initialize(parent)
+    super(parent, #{args})
+" + child_output.gsub(/^/, '    ') + "
+  end
+end"
+    end
+  end
+
+  class Dialog < TopLevelWindow; end
+  class Frame < TopLevelWindow; end
+  class MiniFrame < TopLevelWindow; end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/window.rb

@@ -0,0 +1,128 @@
+module XRC2Ruby::ObjectTypes
+  # Module used to manage keyword arguments 
+  module InitArgs
+    def init_args
+      @init_args 
+    end
+
+    # Method for defining an element called +arg_name+ which is passed
+    # as part of the wxRuby constructor for a class
+    def init_arg(arg_name, &block)
+      attr_writer arg_name
+      define_method(arg_name) do
+        if val = instance_variable_get("@#{arg_name}")
+          block.call(val)
+        end
+      end
+      @init_args ||= {}
+      @init_args[arg_name] = block
+    end
+
+    # Method for defining a string ctor arg that can be translated using
+    # ruby-gettext, if that option is in use. For example - mneu items,
+    # button labels.
+    def translatable_string_init_arg(arg_name)
+      if XRC2Ruby.use_gettext
+        init_arg(arg_name) { | val | "_(" + val.inspect + ")" }
+      else
+        init_arg(arg_name) { | val | val.inspect }
+      end
+    end
+
+    def inherited(kls)
+      @init_args.each { | arg, proc | kls.init_arg(arg, &proc) }
+    end
+  end
+
+  class Window < Object
+    BASE_NAME = "window"
+    self.extend InitArgs
+
+    # Standard constructor arguments
+    init_arg(:size) { | val | "Wx::Size.new(#{val})" }
+    init_arg(:point) { | val | "Wx::Point.new(#{val})" }
+    init_arg(:style) { | val | val.gsub(/wx/, "Wx::") }
+
+    # Tooltip and help text, applicable to all windows
+    attr_accessor :tooltip, :help, :hidden, :enabled, :fg, :bg
+    
+    def output
+      # The base constructor
+      if parent
+        base = "#{var_name} = #{win_class}.new(#{parent.var_name}"
+        base << ( args.empty? ? ")" : ",\n#{args})" )
+      else
+        base = "#{var_name} = #{win_class}.new(nil" 
+        base << ( args.empty? ? ")" : ",\n#{args})" )
+      end
+      # Re-indent the keyword arguments
+      indent = base.index("(") + 1
+      base.gsub!(/\n:/, "\n" + (" " * indent ) + ":") || base
+      base << "\n"
+
+      # If help text is defined
+      if self.help
+        base << "#{var_name}.help_text = '#{self.help}'\n"
+      end
+
+      # If a tooltip is defined
+      if self.tooltip
+        base << "#{var_name}.tool_tip = '#{self.tooltip}'\n"
+      end
+
+      # If foreground colour is specified, convert hex->int and set
+      if self.fg
+        colour = self.bg.scan(/[0-9a-fA-F]{2}/).map { | e | e.to_i(16) }
+        base << "#{var_name}.background_colour = "
+        base << "Wx::Colour.new(#{colour.join(', ')})\n"
+      end
+
+      # If background colour is specified, convert hex->int and set
+      if self.bg
+        colour = self.bg.scan(/[0-9a-fA-F]{2}/).map { | e | e.to_i(16) }
+        base << "#{var_name}.foreground_colour = "
+        base << "Wx::Colour.new(#{colour.join(', ')})\n"
+      end
+
+      # If explicitly disabled or enabled
+      if self.enabled 
+        if self.enabled.to_i.zero?
+          base << "#{var_name}.disable\n"
+        else
+          base << "#{var_name}.enable\n"
+        end
+      end
+
+      # If explicitly shown or hidden
+      if self.hidden 
+        if self.hidden.to_i.zero?
+          base << "#{var_name}.hide\n"
+        else
+          base << "#{var_name}.show\n"
+        end
+      end
+
+      base << setup
+      base
+    end
+
+    # Returns the constructor arguments as a Ruby string
+    def args
+      defined_args = []
+      self.class.init_args.keys.each do | arg |
+        if arg_val = send(arg)
+          defined_args << ":#{arg} => #{arg_val}"
+        end
+      end
+      defined_args.join(",\n")
+    end
+
+    # Some classes define XRC property elements that are set in
+    # wxWidgets by method calls rather than passed as part of the
+    # constructor. This method can be overridden in subclasses to return
+    # a string with those arguments.
+    def setup
+      ''
+    end
+  end
+end

data/lib/wx_sugar/xrc/xrc2ruby_types/windows.rb

@@ -0,0 +1,51 @@
+module WindowTypes
+  class Window < Object
+    def self.init_args
+      @init_args 
+    end
+
+    def self.init_arg(arg_name, &block)
+      attr_writer arg_name
+      define_method(arg_name) do
+        if val = instance_variable_get("@#{arg_name}")
+          block.call(val)
+        end
+      end
+      @init_args ||= {}
+      @init_args[arg_name] = block
+    end
+
+    def self.inherited(kls)
+      @init_args.each { | arg, proc | kls.init_arg(arg, &proc) }
+    end
+
+    init_arg(:size) do | val |
+      "Wx::Size.new(#{val})"
+      # "[ #{val} ]"
+    end
+
+    init_arg(:point) do | val |
+      "[ #{val} ]"
+    end
+
+    init_arg(:style) do | val |
+      val.gsub(/wx/, "Wx::")
+    end
+
+    def args
+      defined_args = []
+      self.class.init_args.keys.each do | arg |
+        if arg_val = send(arg)
+          defined_args << ":#{arg} => #{arg_val}"
+        end
+      end
+      defined_args.join(",\n")
+    end
+  end
+
+  class Button < Window
+    init_arg(:label) do | val |
+      "'#{val}'"
+    end
+  end
+end

metadata

@@ -1,72 +1,96 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: wx_sugar
 version: !ruby/object:Gem::Version 
-  version: 0.1.19
-date: 2007-11-08 00:00:00 +00:00
-summary: Syntax extensions for WxRuby.
-require_paths: 
-- lib
-email: alex@pressure.to
-homepage: http://www.pressure.to/qda/
-rubyforge_project: weft-qda
-description: Ruby-ifies the ruby API for WxRuby.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.1
-  version: 
+  version: 0.1.20
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Alex Fenton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-15 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Ruby-ifies the ruby API for WxRuby.
+email: alex@pressure.to
+executables: 
+- xrcise
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
 - bin/xrcise
 - lib/wx_sugar
-- lib/wx_sugar.rb
-- lib/wx_sugar/wx_classes
-- lib/wx_sugar/xrc
-- lib/wx_sugar/layout.rb
-- lib/wx_sugar/delayed_constructors.rb
+- lib/wx_sugar/all.rb
 - lib/wx_sugar/class_definitions.rb
+- lib/wx_sugar/delayed_constructors.rb
 - lib/wx_sugar/enumerable_controls.rb
-- lib/wx_sugar/menu.rb
-- lib/wx_sugar/all.rb
-- lib/wx_sugar/itemdata.rb
 - lib/wx_sugar/event_connector.rb
-- lib/wx_sugar/wx_classes.rb
-- lib/wx_sugar/xrc.rb
+- lib/wx_sugar/itemdata.rb
+- lib/wx_sugar/layout.rb
+- lib/wx_sugar/menu.rb
 - lib/wx_sugar/version.rb
-- lib/wx_sugar/wx_classes/listctrl.rb
+- lib/wx_sugar/wx_classes
 - lib/wx_sugar/wx_classes/colour.rb
+- lib/wx_sugar/wx_classes/control_with_items.rb
+- lib/wx_sugar/wx_classes/listctrl.rb
 - lib/wx_sugar/wx_classes/position.rb
-- lib/wx_sugar/wx_classes/window.rb
 - lib/wx_sugar/wx_classes/size.rb
-- lib/wx_sugar/wx_classes/control_with_items.rb
+- lib/wx_sugar/wx_classes/window.rb
+- lib/wx_sugar/wx_classes.rb
+- lib/wx_sugar/xrc
+- lib/wx_sugar/xrc/outputter.rb
 - lib/wx_sugar/xrc/xml_class.rb
 - lib/wx_sugar/xrc/xml_resource.rb
-- lib/wx_sugar/xrc/outputter.rb
+- lib/wx_sugar/xrc/xrc2ruby.rb
+- lib/wx_sugar/xrc/xrc2ruby_types
+- lib/wx_sugar/xrc/xrc2ruby_types/books.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/buttons.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/containers.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/lists.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/menu.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/object.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/parent.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/range.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/sizers.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/static.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/text.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/toolbar.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/toplevelwindows.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/window.rb
+- lib/wx_sugar/xrc/xrc2ruby_types/windows.rb
+- lib/wx_sugar/xrc.rb
+- lib/wx_sugar.rb
 - samples/sugar-sample.rb
 - LICENCE
-test_files: []
-
+has_rdoc: true
+homepage: http://www.pressure.to/qda/
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: 
-- xrcise
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: weft-qda
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Syntax extensions for WxRuby.
+test_files: []