wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

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

data/lib/wx/core/variant.rb

@@ -0,0 +1,62 @@
+
+require 'date'
+
+class Wx::Variant
+  include ::Enumerable
+
+  # add a proper enumerator method
+  def each
+    if block_given?
+      get_count.times { |i| yield self[i] }
+    else
+      ::Enumerator.new { |y| get_count.times { |i| y << self[i] } }
+    end
+  end
+
+  # make assign return self and add it's handy alias
+  wx_assign = instance_method :assign
+  define_method :assign do |v|
+    wx_assign.bind(self).call(v)
+    self
+  end
+  alias :<< :assign
+
+  # extend to_s to arraylist and list (easier in pure Ruby)
+
+  wx_to_s = instance_method :to_s
+  define_method :to_s do
+    unless null?
+      case type
+      when 'list'
+        return "[#{each.collect { |v| v.string? ? %Q{"#{v.to_s}"} : v.to_s }.join(', ')}]"
+      when 'arrstring'
+        return array_string.to_s
+      when 'wxFont'
+        return font.to_s
+      when 'wxColour'
+        return colour.to_s
+      when 'wxColourPropertyValue'
+        return colour_property_value.to_s
+      end
+    end
+    wx_to_s.bind(self).call
+  end
+
+  # extend with more Ruby-like type checking
+
+  def string?; !null? && is_type('string'); end
+  def bool?; !null? && is_type('bool'); end
+  def long?; !null? && is_type('long'); end
+  def long_long?; !null? && is_type('longlong'); end
+  def u_long_long?; !null? && is_type('ulonglong'); end
+  def integer?; !null? && (long? || long_long? || u_long_long?); end
+  def date_time?; !null? && is_type('datetime'); end
+  def double?; !null? && is_type('double'); end
+  def numeric?; !null? && (integer? || double?); end
+  def list?; !null? && is_type('list'); end
+  def array_string?; !null? && is_type('arrstring'); end
+  def font?; !null? && is_type('wxFont'); end
+  def colour?; !null? && is_type('wxColour'); end
+  def colour_property_value?; !null? && is_type('wxColourPropertyValue'); end
+  def object?(klass=Object) !null? && is_type('WXRB_VALUE') && klass === object; end
+end

data/lib/wx/core/vboxsizer.rb

@@ -0,0 +1,6 @@
+# Just a shortcut version for creating a vertical box sizer
+class Wx::VBoxSizer < Wx::BoxSizer
+  def initialize
+    super(Wx::VERTICAL)
+  end
+end

data/lib/wx/core/window.rb

@@ -0,0 +1,95 @@
+# 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
+
+  # Add the deprecated/removed GetSize method
+  def get_size
+    rect.size
+  end
+  alias :size :get_size
+
+  # 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
+
+  # The name of Wx::Window#raise conflicts with Ruby's core Kernel#raise
+  # method. This can cause unexpected errors when undecorated #raise is
+  # used inside a Window method. For wxRuby 2.0 it's too late to remove
+  # Window#raise completely, but for now, offer alternatives to
+  # raise/lower that could replace them in future versions.
+  alias :bring_to_front :raise
+  alias :send_to_back :lower
+
+  # 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/core/window_update_locker.rb

@@ -0,0 +1,12 @@
+# Emulates the wxWidgets WindowUpdateLocker class, by providing a scope within
+# which window can be updated without refreshing
+class Wx::WindowUpdateLocker
+  # Only one class method accepting a window that will be
+  # frozen while the block is executed
+  def self.update(win)
+    win.freeze
+    yield
+  ensure
+    win.thaw
+  end
+end

data/lib/wx/core/xmlresource.rb

@@ -0,0 +1,56 @@
+class Wx::XmlResource
+  class << self
+    wx_get = self.instance_method(:get)
+    define_method(:get) do 
+      result = wx_get.bind(self).call
+      result.init_all_handlers
+      result
+    end
+
+    wx_add_subclass_factory = self.instance_method(:add_subclass_factory)
+    define_method(:add_subclass_factory) do |factory|
+      @factories ||= []
+      @factories << factory # keep Ruby factories alive through GC
+      wx_add_subclass_factory.bind(self).call(factory)
+    end
+  end
+
+  # Again, if created via new, switch subclassing off and init_all_handlers
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    result = wx_init.bind(self).call(*args)
+    result.init_all_handlers
+  end
+
+  # 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
+
+  # Returns a Wx::Wizard object from the element named +name+ in the
+  # loaded XRC file. The Wizard will have the parent +parent+.
+  # 
+  # This method is not available in wxWidgets, but is here for
+  # completeness and also to document how to use load_object (see
+  # below).
+  def load_wizard(parent, name)
+    wiz = Wx::Wizard.new()
+    load_wizard_subclass(wiz, parent, name)
+    wiz
+  end
+
+  # Completes the loading of an incomplete instance of Wx::Wizard.
+  def load_wizard_subclass(wizard, parent, name)
+    load_object(wizard, parent, name, "wxWizard")
+  end
+end

data/lib/wx/core.rb

@@ -0,0 +1,61 @@
+# Wx core package loader for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+require_relative './startup' if File.exist?(File.join(__dir__, 'startup.rb'))
+
+require 'wxruby_core'
+
+# Load the version information (should be bundled with all released versions)
+begin
+  require 'wx/version'
+rescue LoadError
+  Wx::WXRUBY_VERSION = '0.0.0'
+end
+
+# decompose wxRuby version
+Wx::WXRUBY_RELEASE_TYPE = (/\d+\.\d+\.\d+-?(.+)/ =~ Wx::WXRUBY_VERSION ? $1 : '')
+Wx::WXRUBY_MAJOR,
+  Wx::WXRUBY_MINOR,
+  Wx::WXRUBY_RELEASE = Wx::WXRUBY_VERSION.split('.').collect { |v| v.to_i }
+
+# Convenience string for WxWidgets version info
+Wx::WXWIDGETS_VERSION = '%i.%i.%i' % [ Wx::WXWIDGETS_MAJOR_VERSION,
+                                       Wx::WXWIDGETS_MINOR_VERSION,
+                                       Wx::WXWIDGETS_RELEASE_NUMBER ]
+
+# Helper functions
+require 'wx/helpers'
+
+# Accessor automagic
+require 'wx/accessors'
+
+# Global constant compatibility helper
+require 'wx/global_const'
+
+# ctor syntax sweeteners support
+require 'wx/keyword_ctors'
+
+# Load in all the class extension methods written in ruby
+# evthandler must be required first b/c it sets up methods modified elsewhere
+require 'wx/core/evthandler.rb'
+class_files = File.join( File.dirname(__FILE__), 'core', '*.rb')
+Dir.glob(class_files) do | class_file |
+  require 'wx/core/' + File.basename(class_file)
+end
+
+::Wx.include(WxRubyStyleAccessors)
+
+::Wx.include((defined?(::WX_GLOBAL_CONSTANTS) && ::WX_GLOBAL_CONSTANTS) ? WxGlobalConstants : WxEnumConstants)
+
+# Load in syntax sweeteners
+require 'wx/keyword_defs'
+
+# If a program is ended by ruby's exit, it can bypass doing the proper
+# Wx clean-up routines called by Wx::App#on_exit. This can under some
+# circumstances cause crashes as the application ends.
+Kernel::at_exit do
+  # These are set at App startup and wxRuby shut down respectively - see App.i
+  if Wx::const_defined?(:THE_APP) and Wx::THE_APP.is_running
+    Wx::THE_APP.wx_ruby_cleanup
+  end
+end