wxruby-ruby19 1.9.10-x86-mingw32

data/lib/wx/classes/toolbar.rb

@@ -0,0 +1,27 @@
+# A set of buttons and controls attached to one edge of a Wx::Frame
+class Wx::ToolBar
+  # Generic method to add items, supporting positional and named
+  # arguments
+  ADD_ITEM_PARAMS = [ Wx::Parameter[ :position, -1 ], 
+                      Wx::Parameter[ :id, -1 ],
+                      Wx::Parameter[ :label, "" ], 
+                      Wx::Parameter[ :bitmap2, Wx::NULL_BITMAP ],
+                      Wx::Parameter[ :kind, Wx::ITEM_NORMAL ], 
+                      Wx::Parameter[ :short_help, "" ], 
+                      Wx::Parameter[ :long_help, "" ], 
+                      Wx::Parameter[ :client_data, nil ] ]
+  
+  def add_item(bitmap, *mixed_args)
+    args = Wx::args_as_list(ADD_ITEM_PARAMS, *mixed_args)
+
+    pos = args.shift
+    args.insert(2, bitmap)
+
+    # Call add_tool to append if default position
+    if pos == -1
+      add_tool(*args)
+    else
+      insert_tool(pos, *args)
+    end
+  end
+end

data/lib/wx/classes/toolbartool.rb

@@ -0,0 +1,4 @@
+class Wx::ToolBarTool
+  alias :id :get_id
+  alias :wx_id :get_id
+end

data/lib/wx/classes/treectrl.rb

@@ -0,0 +1,44 @@
+# Hierarchical control with items
+class Wx::TreeCtrl
+  # Make these ruby enumerables so find, find_all, map etc are available
+  include Enumerable
+  # Iterate over all items
+  alias :each :traverse
+
+  # Return the children of +parent+ as an array of TreeItemIDs.
+  def get_children(parent)
+    kids = [ get_first_child(parent) ]
+    return [] if kids[0].zero?
+
+    while kid = get_next_sibling(kids.last) and not kid.zero?
+      kids << kid
+    end
+    kids
+  end
+
+  # Returns a Wx::Rect corresponding to the edges of an individual tree
+  # item, including the button, identified by id. The standard wxWidgets
+  # API for getting the pixel location of an item is unrubyish, using an
+  # input/output parameter. But since the underlying get_bounding_rect
+  # method works, it's easier to fix the API in Ruby than adding more to
+  # the already-toxic swig interface TreeCtrl.i file.
+  def get_item_rect(tree_item_id)
+    rect = Wx::Rect.new
+    if get_bounding_rect(tree_item_id, rect, false)
+      return rect
+    else
+      return nil
+    end
+  end
+
+  # Returns a Wx::Rect corresponding to the edges of an individual tree
+  # item's text label. See above.
+  def get_label_rect(tree_item_id)
+    rect = Wx::Rect.new
+    if get_bounding_rect(tree_item_id, rect, true)
+      return rect
+    else
+      nil
+    end
+  end
+end

data/lib/wx/classes/vboxsizer.rb

@@ -0,0 +1,6 @@
+# Just a shortcut version for creating a vertical box sizer
+class Wx::VBoxSizer < Wx::BoxSizer
+  def initialize
+    super(Wx::VERTICAL)
+  end
+end

data/lib/wx/classes/window.rb

@@ -0,0 +1,89 @@
+# Copyright 2004-2007 by Kevin Smith
+# released under the MIT-style wxruby2 license
+
+# The base class for all things displayed on screen
+class Wx::Window
+
+  # Ruby's Object#id is deprecated and will be removed in 1.9; therefore
+  # for classes inheriting from Wx::Window, the id method returns the
+  # wxRuby Window id
+  alias :id :get_id
+  # In case a more explicit option is preferred.
+  alias :wx_id :get_id
+
+  # The name of Wx::Window#raise conflicts with Ruby's core Kernel#raise
+  # method. This can cause unexpected errors when undecorated #raise is
+  # used inside a Window method. For wxRuby 2.0 it's too late to remove
+  # Window#raise completely, but for now, offer alternatives to
+  # raise/lower that could replace them in future versions.
+  alias :bring_to_front :raise
+  alias :send_to_back :lower
+
+  # Recursively searches all windows below +self+ and returns the first
+  # window which has the id +an_id+. This corresponds to the find_window
+  # method method in WxWidgets when called with an integer.
+  def find_window_by_id(an_id)
+    Wx::Window.find_window_by_id(an_id, self)
+  end
+
+  # Searches all windows below +self+ and returns the first window which
+  # has the name +a_name+ This corresponds to the find_window method method
+  # in WxWidgets when called with an string.
+  def find_window_by_name(a_name)
+    Wx::Window.find_window_by_name(a_name, self)
+  end
+
+  # Searches all windows below +self+ and returns the first window which
+  # has the label +a_label+.
+  def find_window_by_label(a_label)
+    Wx:Window.find_window_by_label(a_label, self)
+  end
+
+  alias :__old_evt_paint :evt_paint
+  # This modified version of evt_paint sets a variable indicating that a
+  # paint event is being handled just before running the event
+  # handler. This ensures that any call to Window#paint within the
+  # handler will supply a Wx::PaintDC (see swig/Window.i).
+  def evt_paint(meth = nil, &block)
+    paint_proc = acquire_handler(meth, block)
+    wrapped_block = proc do | event |
+      instance_variable_set("@__painting__", true)
+      paint_proc.call(event)
+      remove_instance_variable("@__painting__")
+    end
+    __old_evt_paint(&wrapped_block)
+  end
+
+  # Provides bufferd drawing facility to reduce flicker for complex
+  # drawing commands. Works similar to BufferedDC and BufferedPaintDC in
+  # the wxWidgets API, by doing drawing on an in-memory Bitmap, then
+  # copying the result in bulk to the screen. 
+  #
+  # The method may be passed an existing Wx::Bitmap as the +buffer+,
+  # otherwise one will be created. 
+  #
+  # Works like wxAutoBufferedDC in that additional buffering will only
+  # be done on platforms that do not already natively support buffering
+  # for the standard PaintDC / ClientDC - Windows, in particular.
+  def paint_buffered(buffer = nil)
+    # OS X and GTK do double-buffering natively
+    if self.double_buffered?
+      paint { | dc | yield dc }
+    else
+      # client_size is the window area available for drawing upon
+      c_size = client_size
+      # Create an in-memory buffer if none supplied
+      buffer ||= Wx::Bitmap.new(c_size.width, c_size.height)
+      buffer.draw do | mem_dc |
+        mem_dc.background = Wx::TRANSPARENT_BRUSH
+        mem_dc.clear
+        # Yield the bitmap for the user code to draw upon
+        yield mem_dc
+        paint do | dc | 
+          # Copy the buffer to the window
+          dc.blit(0, 0, c_size.width, c_size.height, mem_dc, 0, 0)
+        end
+      end
+    end
+  end
+end

data/lib/wx/classes/xmlresource.rb

@@ -0,0 +1,54 @@
+class Wx::XmlResource
+  # XRC_NO_SUBCLASSING should always be in place in wxRuby - we can't
+  # currently link directly to wxRuby subclasses.
+  class << self
+    wx_get = self.instance_method(:get)
+    define_method(:get) do 
+      res = wx_get.bind(self).call
+      res.flags |= Wx::XRC_NO_SUBCLASSING
+      res
+    end
+  end
+
+  # WxRuby already has all XRC handlers built in so there's no way to
+  # control init_all_handlers to reduce binary size. So save users
+  # having to call it.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    result = wx_init.bind(self).call(*args)
+    result.flags |= Wx::XRC_NO_SUBCLASSING
+    result.init_all_handlers
+  end
+
+  # The standard .load method returns a boolean indicating success or
+  # failure. Failure might result from bad XML, or a non-existent
+  # file. In ruby, in these circumstances, it's more natural to raise an
+  # Exception than expect the user to test the return value.
+  wx_load = self.instance_method(:load)
+  define_method(:load) do | fname |
+    result = wx_load.bind(self).call(fname)
+    if not result
+      Kernel.raise( RuntimeError,
+                    "Failed to load XRC from '#{fname}'; " +
+                    "check the file exists and is valid XML")
+    end
+    fname
+  end
+
+  # Returns a Wx::Wizard object from the element named +name+ in the
+  # loaded XRC file. The Wizard will have the parent +parent+.
+  # 
+  # This method is not available in wxWidgets, but is here for
+  # completeness and also to document how to use load_object (see
+  # below).
+  def load_wizard(parent, name)
+    wiz = Wx::Wizard.new()
+    load_wizard_subclass(wiz, parent, name)
+    wiz
+  end
+
+  # Completes the loading of a incomplete instance of Wx::Wizard.
+  def load_wizard_subclass(wizard, parent, name)
+    load_object(wizard, parent, name, "wxWizard")
+  end
+end

data/lib/wx/helpers.rb

@@ -0,0 +1,45 @@
+# Various non-GUI helper functions
+module Wx
+  # A named parameter in a Wx named-arg parameter list
+  Parameter = Struct.new( :name, :default )
+
+  # Convert mixed positional / named args into a list to be passed to
+  # an underlying API method. +param_spec+ is an Array of Parameter
+  # structs containing the keyword name and default value for each
+  # possible argument. +mixed_args+ is an array which may optionally end
+  # with a set of named arguments
+  def self.args_as_list(param_spec, *mixed_args)
+    # get keyword arguments from mixed args if supplied, else empty
+    kwa = mixed_args.last.kind_of?(Hash) ? mixed_args.pop : {}
+    out_args = []
+    param_spec.each_with_index do | param, i |
+      if arg = mixed_args[i] # use the supplied list arg 
+        out_args << arg
+      elsif kwa.key?(param.name) # use the keyword arg
+        out_args << kwa[param.name]
+      else # use the default argument
+        out_args << param.default
+      end
+    end
+    out_args
+  rescue
+    Kernel.raise ArgumentError, 
+                 "Bad arg composition of #{mixed_args.inspect}"
+  end
+
+  # Given an integer constant +int_const+, returns an array Wx constant
+  # names which have this value. If a string +prefix+ is supplied, find
+  # only constants whose names begin with this prefix. For example,
+  # passing "EVT" would return only constants with a name like
+  # Wx::EVT_XXX
+  # 
+  # This is primarily useful for debugging, when an unknown constant is
+  # returned, eg as an event type id.
+  def self.find_const(sought, prefix = "")
+    consts = constants.grep(/\A#{prefix}/)
+    consts.find_all do | c | 
+      c_val = const_get(c)
+      c_val.instance_of?(Fixnum) and c_val == sought
+    end
+  end
+end

data/lib/wx/keyword_ctors.rb

@@ -0,0 +1,204 @@
+# = WxRuby Extensions - Keyword Constructors
+# 
+# The *Keyword Constructors* extension allows the use of Ruby hash-style
+# keyword arguments in constructors of common WxWidgets Windows, Frame,
+# Dialog and Control classes.
+# 
+# == Introduction
+#
+# Building a GUI in WxWidgets involves lots of calls to +new+, but
+# these methods often have long parameter lists. Often the default
+# values for many of these parameters are correct. For example, if
+# you're using a sizer-based layout, you usually don't want to specify a
+# size for widgets, but you still have to type
+#  
+#  Wx::TreeCtrl.new( parent, -1, Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 
+#                    Wx::NO_BUTTONS )
+#  
+# just to create a standard TreeCtrl with the 'no buttons' style. If you
+# want to specify the 'NO BUTTONS' style, you can't avoid all the typing
+# of DEFAULT_POSITION etc.
+#
+# == Basic Keyword Constructors
+# 
+# With keyword_constructors, you could write the above as
+# 
+#  TreeCtrl.new(parent, :style => Wx::NO_BUTTONS)
+# 
+# And it will assume you want the default id (-1), and the default size
+# and position. If you want to specify an explicit size, you can do so:
+#
+#  TreeCtrl.new(parent, :size => Wx::Size.new(100, 300))
+# 
+# For brevity, this module also allows you to specify positions and
+# sizes using a a two-element array:
+#  
+#  TreeCtrl.new(parent, :size => [100, 300])
+#
+# Similarly with position:
+#
+#  TreeCtrl.new(parent, :pos => Wx::Point.new(5, 25))
+#
+#  TreeCtrl.new(parent, :pos => [5, 25])
+#
+# You can have multiple keyword arguments:
+#
+#  TreeCtrl.new(parent, :pos => [5, 25], :size => [100, 300] )
+#
+# == No ID required
+# 
+# As with position and size, you usually don't want to deal with
+# assigning unique ids to every widget and frame you create - it's a C++
+# hangover that often seems clunky in Ruby. The *Event Connectors*
+# extension allows you to set up event handling without having to use
+# ids, and if no :id argument is supplied to a constructor, the default
+# (-1) will be passed.
+#
+# There are occasions when a specific ID does need to be used - for
+# example, to tell WxWidgets that a button is a 'stock' item, so that it
+# can be displayed using platform-standard text and icon. To do this,
+# simply pass an :id argument to the constructor - here, the system's
+# standard 'preview' button
+#
+#  Wx::Button.new(parent, :id => Wx::ID_PREVIEW) 
+#
+# == Class-specific arguments
+# 
+# The arguments :size, :pos and :style are common to many WxWidgets
+# window classes. The +new+ methods of these classes also have
+# parameters that are specific to those classes; for example, the text
+# label on a button, or the initial value of a text control.
+# 
+#  Wx::Button.new(parent, :label => 'press me')
+#  Wx::TextCtrl.new(parent, :value => 'type some text here')
+#
+# The keyword names of these arguments can be found by looking at the
+# WxRuby documentation, in the relevant class's +new+ method. You can
+# also get a string description of the class's +new+ method parameters
+# within Ruby by doing:
+# 
+#  puts Wx::TextCtrl.describe_constructor()
+# 
+# This will print a list of the argument names expected by the class's
+# +new+ method, and the correct type for them.
+#
+# == Mixing positional and keyword arguments
+#
+# To support existing code, and to avoid forcing the use of more verbose
+# keyword-style arguments where they're not desired, you can mix
+# positional and keyword arguments, omitting or including +id+s as
+# desired.
+#
+#  Wx::Button.new(parent, 'press me', :style => Wx::BU_RIGHT)
+
+module Wx
+  module KeywordConstructor
+    module ClassMethods
+
+      # Common Wx constructor argument keywords, with their default values.
+      STANDARD_DEFAULTS = {
+        :id        => -1,
+        :size      => Wx::DEFAULT_SIZE,
+        :pos       => Wx::DEFAULT_POSITION,
+        :style     => 0,
+        :title     => '',
+        :validator => Wx::DEFAULT_VALIDATOR,
+        :choices   => [] # for Choice, ComboBox etc
+      }
+
+      attr_writer :param_spec
+      def param_spec
+        @param_spec ||= []
+      end
+      
+      # Adds a list of named parameters *params* to the parameter
+      # specification for this Wx class's constructor. Each parameter
+      # should be specified as a either a common known symbol, such as
+      # +:size+ or +:pos:+ or +:style:+ (corresponding to the common
+      # constructor arguments in WxWidgets API), or a single-key with the
+      # key the name of the argument, and the value a default value.
+      # 
+      # Parameters should be specified in the order they occur in the Wx
+      # API constructor
+      def wx_ctor_params(*params)
+        self.param_spec += params.map do | param |
+          param.kind_of?(Hash) ? 
+            Parameter[ param.keys.first, param.values.first ] : 
+            Parameter[ param, STANDARD_DEFAULTS[param] ]
+        end
+      end
+
+      def args_as_list(*mixed_args)
+        Wx::args_as_list(param_spec, *mixed_args)
+      end
+
+      def args_as_hash(*mixed_args)
+        kwa = mixed_args.last.kind_of?(Hash) ? mixed_args.pop : {}
+        param_spec.zip(mixed_args) do | param, arg |
+          kwa[param.name] = arg if arg
+        end
+        kwa 
+      end
+      
+      def describe_constructor()
+        param_spec.inject("") do | desc, param |
+          desc << ":#{param.name} => (#{param.default.class.name})\n"
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.module_eval do
+
+        alias :pre_wx_kwctor_init :initialize
+
+        # The new definition of initialize; accepts a parent arg
+        # mixed_args, which may zero or more position args, optionally
+        # terminated with hash keyword args, and an optional block
+        def initialize(parent = :default_ctor, *mixed_args, &block)
+          # allow zero-args ctor for use with XRC
+          if parent == :default_ctor
+            pre_wx_kwctor_init()
+            return
+          end
+
+          real_args = [ parent ] + self.class.args_as_list(*mixed_args)
+          begin
+            pre_wx_kwctor_init(*real_args)
+          rescue => err
+            msg = "Error initializing #{self.inspect}\n"+
+                  " : #{err.message} \n" +
+                  "Correct parameters for #{self.class.name}.new are:\n" + 
+                   self.class.describe_constructor()
+
+            new_err = err.class.new(msg)
+            new_err.set_backtrace(caller)
+            Kernel.raise new_err
+          end
+
+          # If a block was given, pass the newly created Window instance
+          # into it; use block
+          if block
+            if block.arity == -1 or block.arity == 0
+              self.instance_eval(&block)
+            elsif block.arity == 1
+              block.call(self)
+            else 
+              Kernel.raise ArgumentError, 
+                           "Block to initialize accepts zero or one arg"
+            end
+          end
+        end
+      end
+      
+      # Any class inheriting from a class including this module must have
+      # its own copy of the param_spec
+      def klass.inherited(sub_klass)
+        sub_klass.instance_variable_set(:@param_spec, 
+                                        instance_variable_get(:@param_spec) )
+      end
+    end
+  end
+end
+