wxruby 1.9.5-universal-darwin-9

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,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

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,82 @@
+# 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
+
+  # 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,16 @@
+class Wx::XmlResource
+  # 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
+end

data/lib/wx/keyword_ctors.rb

@@ -0,0 +1,219 @@
+# = 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
+      }
+
+      
+      # A named parameter in a Wx constructor parameter list
+      Parameter = Struct.new( :name, :default )
+
+      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.to_a.flatten] : 
+            Parameter[param, STANDARD_DEFAULTS[param] ]
+        end
+      end
+
+      def args_as_list(*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
+
+      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
+            msg = "Error initializing #{self.inspect} \n" +
+                  "Sent parameters: #{real_args.inspect}\n" +
+                   "Correct parameters are:\n" + 
+                   self.class.describe_constructor()
+            Kernel.raise ArgumentError, msg
+          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
+