wxruby-ruby19 1.9.10-x86-mingw32

data/lib/wx/classes/menu.rb

@@ -0,0 +1,62 @@
+# A single labelled list within a drop-down menu, or a popup menu
+class Wx::Menu
+
+  # In the standard WxWidgets API, the methods append, prepend, insert
+  # (and their variants) require a constant integer id as the identifier
+  # of the menu item. This is then used in event handling. 
+  #
+  # In WxRuby the use of explicit ids can be avoided in most cases,
+  # being a most unruby-ish practice. So, by analogy with the general
+  # use of Wx::Window classes and event handlers, where the id is
+  # implicit in the constructor, and the window can be passed direct to
+  # the event handler setup method, the below sets up a similar facility
+  # for adding items to Wx::Menu.
+  #
+  # For all these methods, the only required argument is the string name
+  # of the menu item; a system-default id will be supplied if no
+  # explicit one is given. The return value of these methods in all
+  # cases is a Wx::MenuItem object, which can be passed directly as the
+  # first argument to an evt_menu handler.
+  def self.methods_with_optional_ids(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | *args |
+          case args.first
+            when Fixnum then old_meth.bind(self).call(*args)
+            when String then old_meth.bind(self).call(Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids :append, :prepend,
+                            :append_check_item, :prepend_check_item, 
+                            :append_radio_item, :prepend_radio_item
+
+  # This is much the same as above, except for insert and variants,
+  # which take an additional first argument, the position at which to
+  # insert the new item.
+  def self.methods_with_optional_ids_and_pos(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | pos, *args |
+          case args.first
+            when Fixnum then old_meth.bind(self).call(pos, *args)
+            when String then old_meth.bind(self).call(pos, Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(pos, args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids_and_pos :insert,
+                                    :insert_check_item,
+                                    :insert_radio_item
+end

data/lib/wx/classes/menuitem.rb

@@ -0,0 +1,7 @@
+# An individual item within a frame or popup menu
+class Wx::MenuItem
+  # Get the Wx id, not Ruby's deprecated Object#id
+  alias :id :get_id
+  # In case a more explicit option is preferred.
+  alias :wx_id :get_id
+end

data/lib/wx/classes/notebook.rb

@@ -0,0 +1,9 @@
+# Displays a set of pages in parallel using tabs
+class Wx::Notebook
+  # Convenience method for iterating pages
+  def each_page
+    0.upto(get_page_count - 1) do | i |
+      yield get_page(i)
+    end
+  end
+end

data/lib/wx/classes/object.rb

@@ -0,0 +1,14 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # Massage the output of inspect to show the public module name (Wx),
+  # instead of the internal name (Wxruby2)
+  def to_s
+    super.sub('ruby2', '')
+  end
+
+  # Returns a string containing the C++ pointer address of this
+  # object. Only useful for debugging.
+  def ptr_addr
+    Wx::ptr_addr(self)
+  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,56 @@
+class Wx::Point
+  # More informative output when converted to string
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+
+  # Correct comparison for Points - same if same x and y
+  def ==(other)
+    unless other.kind_of?(Wx::Point)
+      Kernel.raise TypeError, "Cannot compare Point to #{other}"
+    end
+    x == other.x and y == other.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,19 @@
+# Class representing a rectangular shape
+class Wx::Rect
+  # Nicely readable inspect output for Rect
+  def to_s
+    "#<Wx::Rect: (#{get_left}, #{get_top}) (#{get_right}, #{get_bottom})>"    
+  end
+
+  # Correct comparison for Wx::Rect, are the same if have the same
+  # position and the same size
+  def ==(other)
+    unless other.kind_of?(Wx::Rect)
+      Kernel.raise TypeError, "Cannot compare Rect to #{other}"
+    end
+    get_left == other.get_left and get_top == other.get_top and
+      get_right = other.get_right and get_bottom == other.get_bottom
+  end
+  # More ruby-ish names
+  alias :contains? :contains
+end

data/lib/wx/classes/richtextctrl.rb

@@ -0,0 +1,63 @@
+# Text editor supporting various formatting, intended for editing
+# natural language texts
+class Wx::RichTextCtrl
+  # These three methods return the styles applicable at certain points
+  # in the document. However, the standard wx signature is to accept the
+  # value of some kind of TextAttr class that will hold the return as an
+  # argument. The return value is a boolean for success/failure. In
+  # Ruby, we only support returning the value as a RichTextAttr, and do
+  # so as a proper return value, having accepted a single argument
+  # specifying where to get the style from. If retrieval is not
+  # successful, raise an exception.
+  wx_get_style = self.instance_method(:get_style)
+  define_method(:get_style) do | pos |
+    style = Wx::RichTextAttr.new
+    if wx_get_style.bind(self).call(pos, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style at position #{pos}"
+    end
+  end
+
+  wx_get_style_for_range = self.instance_method(:get_style_for_range)
+  define_method(:get_style_for_range) do | rng |
+    style = Wx::RichTextAttr.new
+    if wx_get_style_for_range.bind(self).call(rng, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style for range #{rng}"
+    end
+  end
+
+  wx_get_uncombined_style = self.instance_method(:get_uncombined_style)
+  define_method(:get_uncombined_style) do | pos |
+    style = Wx::RichTextAttr.new
+    if wx_get_uncombined_style.bind(self).call(pos, style)
+      return style
+    else
+      Kernel.raise RuntimeError, "Could not retrieve style at position #{pos}"
+    end
+  end
+
+  # Fix to accept a single +pos+ argument and return a Wx::Rect
+  wx_car_pos_for_index = self.instance_method(:get_caret_position_for_index)
+  define_method(:get_caret_position_for_index) do | pos |
+    rect = Wx::Rect.new
+    if wx_car_pos_for_index.bind(self).call(pos, rect)
+      return rect
+    else
+      Kernel.raise RuntimeError, "Could not rect for position #{pos}"
+    end
+  end
+
+  # Fix to return a pair of col, row values
+  wx_pos_to_xy = self.instance_method(:position_to_xy)
+  define_method(:position_to_xy) do | pos |
+    success, x, y = wx_pos_to_xy.bind(self).call(pos)
+    if success
+      return x, y
+    else
+      Kernel.raise RuntimeError, "Could not convert position #{pos} to x, y"
+    end
+  end
+end

data/lib/wx/classes/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/classes/size.rb

@@ -0,0 +1,58 @@
+class Wx::Size
+  # More informative output for inspect etc
+  def to_s
+    "#<Wx::Size: (#{get_width}, #{get_height})>"
+  end
+
+  # Compare with another size
+  def ==(other)
+    unless other.kind_of?(Wx::Size)
+      Kernel.raise TypeError, "Cannot compare Size to #{other}"
+    end
+    get_x == other.get_x and get_y == other.get_y
+  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/sizer.rb

@@ -0,0 +1,37 @@
+# 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)
+    args = Wx::args_as_list(ADD_ITEM_PARAMS, *mixed_args)
+
+    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/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/standardpaths.rb

@@ -0,0 +1,9 @@
+# Access OS-standard locations for user files, config files etc
+class Wx::StandardPaths
+  class << self
+    # Expose instance methods as class methods in Ruby
+    Wx::StandardPaths.instance_methods(false).each do | meth |
+      define_method(meth) { get.send(meth) }
+    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,18 @@
+# Event fired when a user clicks or hovers over a hyperlink in a TextCtrl
+class Wx::TextUrlEvent
+  # Returns the string URL that is being interacted with in this event
+  def get_url
+    text_ctrl = event_object
+    # In the standard TextCtrl, the relevant URL is always the same as
+    # the text clicked on, because all it does is highlight text that
+    # look like a URL. In RichTextCtrl, however, the URL value can be
+    # applied to any text (more like HTML), and so the URL has be
+    # retrieved by getting the applied RichTextAttr style and inspecting
+    # its property.
+    if text_ctrl.kind_of?(Wx::RichTextCtrl)
+      return text_ctrl.get_style(url_start).url
+    else      
+      return text_ctrl.value[url_start .. url_end]
+    end
+  end
+end

data/lib/wx/classes/timer.rb

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