wxruby3 0.9.0.pre.beta.8

data/lib/wx/core/point.rb

@@ -0,0 +1,92 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make Point usable for parallel assignments like `x, y = pt`
+  def to_ary
+    [x, y]
+  end
+
+  alias :get_x :x
+  alias :get_y :y
+
+  # Compare point values
+  def ==(other)
+    if Wx::Point === other
+      x == other.x and y == other.y
+    elsif Array === other && other.size == 2
+      to_ary == other
+    else
+      Kernel.raise TypeError, "Cannot compare Point to #{other}"
+    end
+  end
+
+  # Correct comparison for Points - same if same x and y
+  def eql?(other)
+    if Wx::Point === other
+      x == other.x and y == other.y
+    else
+      false
+    end
+  end
+
+  # Return a new Wx::Point with the x and y parameters both divided by
+  # parameter +num+, which should be a Numeric
+  def /(num)
+    self.class.new((get_x / num).to_i, (get_y / num).to_i)
+  end
+
+  # Return a new Wx::Point with the x and y values both multiplied by
+  # parameter +num+, which should be a Numeric
+  def *(num)
+    self.class.new((get_x * num).to_i, (get_y * num).to_i)
+  end
+
+  # Return a new Wx::Point with the x and y values both reduced by
+  # parameter +arg+. If +arg+ is another Wx::Point (or Wx::Size or 2-element array), reduce x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # reduce x and y both by that value.
+  def -(arg)
+    case arg
+    when self.class
+      self.class.new(get_x - arg.x, get_y - arg.y)
+    when Wx::Size
+      self.class.new(get_x - arg.width,get_y - arg.height)
+    when Numeric
+      self.class.new((get_x - arg).to_i, (get_y - arg).to_i)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x - arg[0].to_i, get_y - arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot subtract #{arg} from #{self.inspect}"
+      end
+    end
+  end
+
+  # Return a new Wx::Point with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::Point (or Wx::Size or 2-element array), increase x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # increase both x and y by that value.
+  def +(arg)
+    case arg
+    when self.class
+      self.class.new(get_x + arg.x, get_y + arg.y)
+    when Wx::Size
+      self.class.new(get_x + arg.width,get_y + arg.height)
+    when Numeric
+      self.class.new((get_x + arg).to_i, (get_y + arg).to_i)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x + arg[0].to_i, get_y + arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/wx/core/real_point.rb

@@ -0,0 +1,92 @@
+class Wx::RealPoint
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::RealPoint: (#{x}, #{y})>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make RealPoint usable for parallel assignments like `x, y = pt`
+  def to_ary
+    [x, y]
+  end
+
+  alias :get_x :x
+  alias :get_y :y
+
+  # Compare point values
+  def ==(other)
+    if Wx::RealPoint === other
+      x == other.x and y == other.y
+    elsif Array === other && other.size == 2
+      to_ary == other
+    else
+      Kernel.raise TypeError, "Cannot compare RealPoint to #{other}"
+    end
+  end
+
+  # Correct comparison for RealPoints - same if same x and y
+  def eql?(other)
+    if Wx::RealPoint === other
+      x == other.x and y == other.y
+    else
+      false
+    end
+  end
+
+  # Return a new Wx::RealPoint with the x and y parameters both divided by
+  # parameter +num+, which should be a Numeric
+  def /(num)
+    self.class.new( get_x / num, get_y / num )
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both multiplied by
+  # parameter +num+, which should be a Numeric
+  def *(num)
+    self.class.new( get_x * num, get_y * num )
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both reduced by
+  # parameter +arg+. If +arg+ is another Wx::(Real)Point (or Wx::Size or 2-element array), reduce x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # reduce x and y both by that value.
+  def -(arg)
+    case arg
+    when Wx::Size
+      self.class.new(get_x - arg.width, get_y - arg.height)
+    when self.class, Wx::Point
+      self.class.new(get_x - arg.x, get_y - arg.y)
+    when Numeric
+      self.class.new(get_x - arg, get_y - arg)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x - arg[0].to_f, get_y - arg[1].to_f)
+      else
+        Kernel.raise TypeError, "Cannot subtract #{arg} from #{self.inspect}"
+      end
+    end
+  end
+
+  # Return a new Wx::RealPoint with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::(Real)Point (or Wx::Size or 2-element array), increase x by the
+  # other's x (or width) and y by the other's y (or height); if +arg+ is a numeric value,
+  # increase both x and y by that value.
+  def +(arg)
+    case arg
+    when Wx::Size
+      self.class.new(get_x + arg.width, get_y + arg.height)
+    when self.class, Wx::Point
+      self.class.new(get_x + arg.x, get_y + arg.y)
+    when Numeric
+      self.class.new(get_x + arg, get_y + arg)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(get_x + arg[0].to_f, get_y + arg[1].to_f)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/wx/core/rect.rb

@@ -0,0 +1,57 @@
+# Class representing a rectangular shape
+class Wx::Rect
+  # Nicely readable inspect output for Rect
+  def to_s
+    "#<Wx::Rect: (#{left}, #{top}) #{width}x#{height}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make Rect usable for parallel assignments like `left, top, width, height = rect`
+  def to_ary
+    [left, top, width, height]
+  end
+
+  # Correct comparison for Wx::Rect, are the same if have the same
+  # position and the same size
+  def ==(other)
+    if Wx::Rect === other
+      left == other.left and top == other.top and
+        width == other.width and height == other.height
+    elsif Array === other && other.size == 4
+      to_ary == other
+    else
+      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+    end
+  end
+
+  def eql?(other)
+    if Wx::Rect === other
+      left == other.left and top == other.top and
+        width == other.width and height == other.height
+    else
+      false
+    end
+  end
+
+  # make sure union and intersect are constant operations, i.e. not changing self
+  wx_union = instance_method :union
+  define_method :union do |rect|
+    wx_union.bind(Wx::Rect.new(*self.to_ary)).call(rect)
+  end
+
+  wx_intersect = instance_method :intersect
+  define_method :intersect do |rect|
+    wx_intersect.bind(Wx::Rect.new(*self.to_ary)).call(rect)
+  end
+
+  alias :+ :add
+  alias :* :mul
+  alias :& :intersect
+  alias :| :union
+
+  # More ruby-ish names
+  alias :contains? :contains
+end

data/lib/wx/core/simplehelpprovider.rb

@@ -0,0 +1,38 @@
+# Pure-ruby implementation of the corresponding Wx class. Simply shows
+# the Window's help text in a tooltip.
+class Wx::SimpleHelpProvider < Wx::HelpProvider
+  def initialize
+    super
+    # Store for mapping windows -> help strings
+    @help_wins = {} 
+    # Store for mapping ids -> help strings
+    @help_ids  = {}
+  end
+
+  # This is what is called by Wx::Window#set_help_text
+  def add_help(identifier, text)
+    if identifier.kind_of? Wx::Window
+      @help_wins[identifier.object_id] = text
+    else
+      @help_ids[identifier] = text
+    end
+  end
+
+  # Retrieve help text for the given window +win+
+  def get_help(win)
+    @help_wins[win.object_id] || @help_ids[win.wx_id] || ""
+  end
+
+  # Remove the help text for +win+
+  def remove_help(win)
+    @help_wins.delete(win.object_id)
+  end
+
+  # Show help for +win+
+  def show_help(win)
+    help_text = get_help(win)
+    return false if help_text.empty?
+    tip = Wx::TipWindow.new(win, help_text, 100)
+    true
+  end
+end

data/lib/wx/core/size.rb

@@ -0,0 +1,86 @@
+class Wx::Size
+  # More informative output for inspect etc
+  def to_s
+    "#<Wx::Size: #{width}x#{height}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  # make Size usable for parallel assignments like `w, h = sz`
+  def to_ary
+    [width, height]
+  end
+
+  # Compare with another size value
+  def ==(other)
+    if Wx::Size === other
+      width == other.width and height == other.height
+    elsif Array === other and other.size == 2
+      to_ary == other
+    else
+      Kernel.raise TypeError, "Cannot compare Size to #{other}"
+    end
+  end
+
+  def eql?(other)
+    if Wx::Size === other
+      width == other.width and height == other.height
+    else
+      false
+    end
+  end
+
+  # Return a new Wx::Size with the width and height values both divided
+  # by parameter +num+, which should be a Numeric
+  def /(num)
+    self.class.new((width / num).to_i, (height / num).to_i)
+  end
+
+  # Return a new Wx::Size with the width and height values both
+  # multiplied by parameter +num+, which should be a Numeric
+  def *(num)
+    self.class.new((width * num).to_i, (height * num).to_i)
+  end
+
+  # Return a new Wx::Size with the width and height parameters both
+  # reduced by parameter +arg+. If +arg+ is another Wx::Size (or 2-element array), reduce
+  # width by the other's width and height by the other's height; if
+  # +arg+ is a numeric value, reduce both width and height by that
+  # value.
+  def -(arg)
+    case arg
+    when self.class
+      self.class.new(width - arg.width, height - arg.height)
+    when Numeric
+      self.class.new((width - arg).to_i, (height - arg).to_i)
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(width - arg[0].to_i, height - arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+
+  # Return a new Wx::Size with the width and height parameters both
+  # increased by parameter +arg+. If +arg+ is another Wx::Size (or 2-element array), increase
+  # width by the other's width and height by the other's height; if
+  # +arg+ is a numeric value, increase both width and height by that
+  # value.
+  def +(arg)
+    case arg
+    when self.class
+      self.class.new( width + arg.width, height + arg.height )
+    when Numeric
+      self.class.new( (width + arg).to_i, (height + arg).to_i )
+    else
+      if Array === arg && arg.size == 2
+        self.class.new(width + arg[0].to_i, height + arg[1].to_i)
+      else
+        Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/wx/core/sizer.rb

@@ -0,0 +1,43 @@
+# Class for automatically managing layouts
+class Wx::Sizer
+  # Generic method to add items, supporting positional and named
+  # arguments
+  ADD_ITEM_PARAMS = [ Wx::Parameter[ :index, -1 ], 
+                      Wx::Parameter[ :proportion, 0 ],
+                      Wx::Parameter[ :flag, 0 ],
+                      Wx::Parameter[ :border, 0 ],
+                      Wx::Parameter[ :user_data, nil ] ]
+  
+  def add_item(item, *mixed_args)
+
+    begin
+      args = Wx::args_as_list(ADD_ITEM_PARAMS, *mixed_args)
+    rescue => err
+      err.set_backtrace(caller)
+      Kernel.raise err
+    end
+
+    full_args = []
+
+    # extract the width and the height in the case of a spacer
+    # defined as an array
+    if item.kind_of?(Array)
+      Kernel.raise ArgumentError,
+        "Invalid Sizer specification : [width, height] expected" if item.size != 2
+      full_args << item[0] << item[1]
+    else
+      full_args << item
+    end
+
+    # update the full arguments list with the optional arguments (except index)
+    idx = args.shift
+    full_args.concat(args)
+
+    # Call add to append if default position
+    if idx == -1
+      add(*full_args)
+    else
+      insert(idx, *full_args)
+    end
+  end
+end

data/lib/wx/core/splash_screen.rb

@@ -0,0 +1,44 @@
+
+class Wx::SplashScreen
+
+  # special handling for keyword ctor extension here
+  # as this class deviates from 'normal' window ctors
+  Wx::define_keyword_ctors(Wx::SplashScreen) do
+    wx_ctor_params :id, :pos, :size, :style => Wx::SIMPLE_BORDER|Wx::FRAME_NO_TASKBAR|Wx::STAY_ON_TOP
+  end
+
+  # now redefine the overridden ctor to account for deviating arglist
+  def initialize(bitmap, splashstyle, milliseconds, parent = nil, *mixed_args, &block)
+    # no zero-args ctor for use with XRC!
+
+    begin
+      real_args = [ bitmap, splashstyle, milliseconds, parent ] + self.class.args_as_list(*mixed_args)
+      pre_wx_kwctor_init(*real_args)
+    rescue => err
+      msg = "Error initializing #{self.inspect}\n"+
+        " : #{err.message} \n" +
+        "Provided are #{real_args} \n" +
+        "Correct parameters for #{self.class.name}.new are:\n" +
+        self.class.describe_constructor(
+          ":bitmap => Wx::Bitmap\n:splashstyle => Integer\n:milliseconds => Integer\n:parent => Wx::Window\n")
+
+      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

data/lib/wx/core/textctrl.rb

@@ -0,0 +1,8 @@
+
+class Wx::TextCtrl
+  wx_op_append = instance_method :<<
+  define_method :<< do |o|
+    wx_op_append.bind(self).call(o)
+    self
+  end
+end

data/lib/wx/core/timer.rb

@@ -0,0 +1,104 @@
+# Class allowing periodic or timed events to be fired
+class Wx::Timer
+  # Convenience method to trigger a one-off action after +interval+
+  # milliseconds have passed. The action is specified by the passed
+  # block. The Timer is owned by the global App object, and is returned
+  # by the method.
+  def self.after(interval, &block)
+    timer = new(Wx::THE_APP, Wx::ID_ANY)
+    Wx::THE_APP.evt_timer(timer.get_id, block)
+    timer.start(interval, true)
+    timer
+  end
+
+  # Convenience method to trigger a repeating action every +interval+
+  # milliseconds. The action is specified by the passed block. The Timer
+  # is owned by the global App object, and is returned by the method.
+  def self.every(interval, &block)
+    timer = new(Wx::THE_APP, Wx::ID_ANY)
+    Wx::THE_APP.evt_timer(timer.get_id, block)
+    timer.start(interval)
+    timer
+  end
+
+  # In common with other classes, make the id method refer to the
+  # wxWidgets id, not ruby's deprecated name for object_id
+  alias :id :get_id
+  # In case a more explicit option is preferred.
+  alias :wx_id :get_id
+
+  # This class can be linked to an owner - an instance of a class
+  # derived from EvtHandler which will receive Timer events. However,
+  # event if a Wx::Timer is attached to a Wx::Window, it is (unlike most
+  # classes) NOT automatically deleted when the window is destroyed. If
+  # the Timer continues ticking, it will send events to the
+  # now-destroyed window, causing segfaults. So the little acrobatics
+  # below set up a hook when a Timer's owner is set, and then ensure the
+  # timer is stopped when the window is destroyed.
+
+  # Redefine initialize
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    setup_owner_destruction_hook(args[0])
+    wx_init.bind(self).call(*args)
+  end
+
+  # Redefine set_owner
+  wx_set_owner = self.instance_method(:set_owner)
+  define_method(:set_owner) do | *args |
+    setup_owner_destruction_hook(args[0])
+    wx_set_owner.bind(self).call(*args)
+  end
+
+  private 
+  # This method notes in Ruby the ownership of the timer, from both
+  # sides, and sets up an event hook if needed for the window's
+  # destruction.
+  def setup_owner_destruction_hook(new_owner)
+    this_timer = self
+
+    # Class-wide list of global (unowned) timers
+    @@__unowned_timers__ ||= []
+
+    # remove from list of previous owner
+    if defined?(@__owner__) and @__owner__
+      @__owner__.instance_eval { @__owned_timers__.delete(this_timer) }
+    end
+
+    # If becoming global unowned timer, add to list of those timers
+    if not new_owner
+      @__owner__ = nil
+      @@__unowned_timers__ << self      
+      return
+    end
+    
+    # Otherwise, if previously unowned, remove from global owned
+    @@__unowned_timers__.delete(self)
+    @__owner__ = new_owner
+
+    # Then add to list of new owner, setting destructor hook if required    
+    new_owner.instance_eval do
+      if not defined?(@__owned_timers__)
+        @__owned_timers__ = []
+        unless self.kind_of?(Wx::App) # Don't set up hook on App
+          evt_window_destroy do | evt |
+            # If it's the owning window being destroyed...
+            if evt.get_event_object == self
+              @__owned_timers__.each { | timer | timer.stop }
+            end
+          end
+        end
+      end
+      @__owned_timers__ << this_timer
+    end
+  end
+end
+
+class Wx::EvtHandler
+  # missing from XML docs so we add this here manually
+  self.register_event_type EventType[
+    'evt_timer', 1,
+    Wx::EVT_TIMER,
+    Wx::TimerEvent
+  ] if Wx.const_defined?(:EVT_TIMER)
+end

data/lib/wx/core/toolbar.rb

@@ -0,0 +1,37 @@
+# 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[ :bitmap2, Wx::NULL_BITMAP ],
+                      Wx::Parameter[ :position, -1 ], 
+                      Wx::Parameter[ :id, -1 ],
+                      Wx::Parameter[ :label, "" ], 
+                      Wx::Parameter[ :kind, Wx::ItemKind::ITEM_NORMAL ],
+                      Wx::Parameter[ :short_help, "" ], 
+                      Wx::Parameter[ :long_help, "" ], 
+                      Wx::Parameter[ :client_data, nil ] ]
+  
+  def add_item(bitmap1, *mixed_args)
+
+    begin
+      args = Wx::args_as_list(ADD_ITEM_PARAMS, *mixed_args)
+    rescue => err
+      err.set_backtrace(caller)
+      Kernel.raise err
+    end
+
+    bitmap2 = args.shift
+
+    pos = args.shift
+    args.insert(2, bitmap1)
+    args.insert(3, bitmap2)
+
+    # 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/core/toolbartool.rb

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

data/lib/wx/core/treectrl.rb

@@ -0,0 +1,46 @@
+# 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 = []
+    kid, _ = get_first_child(parent)
+    return [] unless kid.ok?
+    kids << kid
+
+    while kid = get_next_sibling(kids.last) and kid.ok?
+      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/core/validator.rb

@@ -0,0 +1,8 @@
+
+class Wx::Validator
+  # Default implementation of clone, may need to be over-ridden if
+  # custom subclasses should state variables that need to be copied
+  def clone
+    self.class.new
+  end
+end