wxruby 1.9.3-universal-darwin

data/lib/wx/classes/object.rb

@@ -0,0 +1,7 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # massage the output of inspect to show the public module name (Wx)
+  def to_s
+    super.sub('ruby2', '')
+  end
+end

data/lib/wx/classes/paintdc.rb

@@ -0,0 +1,12 @@
+# Device Context to paint within an on_paint handler
+class Wx::PaintDC
+  # This class should not be instantiated directly in wxRuby; it should
+  # always be used via Window#paint, which takes a block receiving the
+  # DC. This ensures that the DC is cleaned up at the correct time,
+  # preventing serious errors on some platforms.
+  define_method(:initialize) do | *args |
+    Kernel.raise RuntimeError,
+                 "Do not instantiate PaintDC directly; use Window#paint",
+                 caller[1..-1]
+  end
+end

data/lib/wx/classes/point.rb

@@ -0,0 +1,48 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+
+  # Return a new Wx::Point with the x and y parameters both divided by
+  # parameter +div+, which should be a Numeric
+  def /(div)
+    self.class.new( (get_x / div).to_i, (get_y / div).to_i )
+  end
+
+  # Return a new Wx::Point with the x and y values both multiplied by
+  # parameter +mul+, which should be a Numeric
+  def *(mul)
+    self.class.new( (get_x * mul).to_i, (get_y * mul).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, reduce x by the
+  # other's x and y by the other's y; 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.get_x, get_y - arg.get_y )
+    when Numeric
+      self.class.new( (get_x - arg).to_i, (get_y - arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+
+  # Return a new Wx::Point with the x and y values both increased by
+  # parameter +arg+. If +arg+ is another Wx::Point, increase x by the
+  # other's x and y by the other's y; 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.get_x, get_y + arg.get_y )
+    when Numeric
+      self.class.new( (get_x + arg).to_i, (get_y + arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+end

data/lib/wx/classes/previewframe.rb

@@ -0,0 +1,13 @@
+# Frame that displays a print preview
+class Wx::PreviewFrame
+  # a PreviewFrame has a preview associated with it that must be
+  # protected from Ruby's GC. However, there is no C++ method to access
+  # the Wx::PrintPreview (only a protected member), so instead we have
+  # to assign it to an instance variable so it is marked correctly when
+  # the frame displaying it is marked.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    wx_init.bind(self).call(*args)
+    @__preview = args[0]
+  end
+end

data/lib/wx/classes/rect.rb

@@ -0,0 +1,5 @@
+class Wx::Rect
+  def to_s
+    "#<Wx::Rect: (#{get_left}, #{get_top}) (#{get_right}, #{get_bottom})>"    
+  end
+end

data/lib/wx/classes/size.rb

@@ -0,0 +1,49 @@
+class Wx::Size
+  def to_s
+    "#<Wx::Size: (#{get_width}, #{get_height})>"
+  end
+
+  # Return a new Wx::Size with the width and height values both divided
+  # by parameter +div+, which should be a Numeric
+  def /(div)
+    self.class.new( (get_x / div).to_i, (get_y / div).to_i )
+  end
+
+  # Return a new Wx::Size with the width and height values both
+  # multiplied by parameter +mul+, which should be a Numeric
+  def *(mul)
+    self.class.new( (get_x * mul).to_i, (get_y * mul).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, 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( get_x - arg.get_x, get_y - arg.get_y )
+    when Numeric
+      self.class.new( (get_x - arg).to_i, (get_y - arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+
+  # Return a new Wx::Size with the width and height parameters both
+  # increased by parameter +arg+. If +arg+ is another Wx::Size, 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( get_x + arg.get_x, get_y + arg.get_y )
+    when Numeric
+      self.class.new( (get_x + arg).to_i, (get_y + arg).to_i )
+    else
+      Kernel.raise TypeError, "Cannot add #{arg} to #{self.inspect}"
+    end
+  end
+end

data/lib/wx/classes/sound.rb

@@ -0,0 +1,23 @@
+# Plays simple sounds from .wav files
+class Wx::Sound
+  class << self
+    # Shortcut class method, as per the wxWidgets docs, but easier to do
+    # in Ruby
+    def play(file, flags = Wx::SOUND_ASYNC)
+      new(file).play(flags)
+    end
+  end
+
+  # Test if newly created Sound is valid; if not, raise an exception
+  # rather than failing silently.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    if not File.exist?( File.expand_path(args[0]) )
+      Kernel.raise(ArgumentError, "Sound file does not exist: #{args[0]}")
+    end
+    wx_init.bind(self).call(*args)
+    if not ok?
+      Kernel.raise(ArgumentError, "Error loading sound file #{args[0]}")
+    end
+  end
+end

data/lib/wx/classes/styledtextctrl.rb

@@ -0,0 +1,92 @@
+# Functionality here must be loaded first to add custom events
+require 'wx/classes/evthandler'
+
+# These event type constants will only be available and meaningful if
+# Wx::StyledTextCtrl has been compiled into the library. If so, they
+# need the below definitions for mapping, otherwise all the rest should
+# be skipped
+if defined?(Wx::StyledTextCtrl)
+  EventType = Wx::EvtHandler::EventType
+
+  stc_event_types = [ 
+    EventType['evt_stc_calltip_click', 1,
+              Wx::EVT_STC_CALLTIP_CLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_change', 1,
+              Wx::EVT_STC_CHANGE, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_charadded', 1,
+              Wx::EVT_STC_CHARADDED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_doubleclick', 1,
+              Wx::EVT_STC_DOUBLECLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_do_drop', 1,
+              Wx::EVT_STC_DO_DROP,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_drag_over', 1,
+              Wx::EVT_STC_DRAG_OVER,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_dwellend', 1,
+              Wx::EVT_STC_DWELLEND,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_dwellstart', 1,
+              Wx::EVT_STC_DWELLSTART,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_hotspot_click', 1,
+              Wx::EVT_STC_HOTSPOT_CLICK,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_hotspot_dclick', 1,
+              Wx::EVT_STC_HOTSPOT_DCLICK,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_key', 1,
+              Wx::EVT_STC_KEY,
+              Wx::StyledTextEvent],
+    EventType['evt_stc_macrorecord', 1,
+              Wx::EVT_STC_MACRORECORD, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_marginclick', 1,
+              Wx::EVT_STC_MARGINCLICK, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_modified', 1,
+              Wx::EVT_STC_MODIFIED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_needshown', 1,
+              Wx::EVT_STC_NEEDSHOWN, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_painted', 1,
+              Wx::EVT_STC_PAINTED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_romodifyattempt', 1,
+              Wx::EVT_STC_ROMODIFYATTEMPT, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_savepointleft', 1,
+              Wx::EVT_STC_SAVEPOINTLEFT, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_savepointreached', 1,
+              Wx::EVT_STC_SAVEPOINTREACHED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_start_drag', 1,
+              Wx::EVT_STC_START_DRAG, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_styleneeded', 1,
+              Wx::EVT_STC_STYLENEEDED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_updateui', 1,
+              Wx::EVT_STC_UPDATEUI, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_uridropped', 1,
+              Wx::EVT_STC_URIDROPPED, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_userlistselection', 1,
+              Wx::EVT_STC_USERLISTSELECTION, 
+              Wx::StyledTextEvent],
+    EventType['evt_stc_zoom', 1,
+              Wx::EVT_STC_ZOOM, 
+              Wx::StyledTextEvent]
+    ]
+
+  stc_event_types.each do | ev_type | 
+    Wx::EvtHandler.register_event_type(ev_type)
+  end
+end

data/lib/wx/classes/textctrl.rb

@@ -0,0 +1,14 @@
+class Wx::TextCtrl
+  # Fix position_to_xy so it returns a two-element array - the internal
+  # version returns a three-element array with a Boolean that doesn't
+  # really make sense in Ruby
+  wx_position_to_xy = instance_method(:position_to_xy)
+  define_method(:position_to_xy) do | pos |
+    retval, x, y = wx_position_to_xy.bind(self).call(pos)
+    if retval
+      return [x, y]
+    else
+      return nil
+    end
+  end
+end

data/lib/wx/classes/texturlevent.rb

@@ -0,0 +1,6 @@
+class Wx::TextUrlEvent
+  # Returns the string URL  that is being interacted with in this event
+  def get_url
+    get_event_object.get_value[get_url_start .. get_url_end]
+  end
+end

data/lib/wx/classes/timer.rb

@@ -0,0 +1,69 @@
+# Class allowing periodic or timed events to be fired
+class Wx::Timer
+  # 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
+            evt.skip
+          end
+        end
+      end
+      @__owned_timers__ << this_timer
+    end
+  end
+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/window.rb

@@ -0,0 +1,49 @@
+# 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
+
+
+  # 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
+end