wxruby64 2.0.1-x64-mingw32

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,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/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/splitterwindow.rb

@@ -0,0 +1,10 @@
+# Class with movable sash to separate two windows
+class Wx::SplitterWindow
+  # These were released in wxRuby 2.0 with names slightly out of kilter
+  # with the documentation. The correct ones have an underscore before
+  # the digit.
+  #
+  # FIXME - the old names :get_window1 should be deleted in future versions.
+  alias :get_window_1 :get_window1
+  alias :get_window_2 :get_window2
+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,96 @@
+# 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
+            evt.skip
+          end
+        end
+      end
+      @__owned_timers__ << this_timer
+    end
+  end
+end

data/lib/wx/classes/toolbar.rb

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