wxruby3 0.9.0.pre.beta.8

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

data/lib/wx/doc/aui/auimanager.rb

@@ -0,0 +1,12 @@
+
+class Wx::AUI::AuiManager
+
+  # Yield each pane to the given block.
+  # @yieldparam [Wx::AUI::AuiPaneInfo] pane the Aui pane info yielded
+  def each_pane; end
+
+  # Returns an array of all panes managed by the frame manager.
+  # @return [Array<Wx::AUI::AuiPaneInfo>] all managed panes
+  def get_all_panes; end
+  alias_method :all_panes, :get_all_panes
+end

data/lib/wx/doc/aui/auinotebook.rb

@@ -0,0 +1,9 @@
+
+class Wx::AUI::AuiNotebook
+
+  # Finds tab control and its tab index associated with a given window.
+  # @param [Wx::Window] page the notebook page window
+  # @return [Array<Wx::AUI::AuiTabCtrl, Integer>, nil] tab control and index if found else nil
+  def find_tab(page) end
+
+end

data/lib/wx/doc/colour_dialog.rb

@@ -0,0 +1,15 @@
+
+class Wx::ColourDialog
+
+  # Returns (a copy of) the colour data of the dialog.
+  # @return [Wx::ColourData] colour data copy
+  def get_colour_data; end
+  alias :colour_data :get_colour_data
+
+  # Updates the colour data for the dialog.
+  # @param [Wx::ColourData] clr_data the colour data to update the dialog with
+  # @return [void]
+  def set_colour_data(clr_data); end
+  alias :colour_data= :set_colour_data
+
+end

data/lib/wx/doc/core.rb

@@ -0,0 +1,11 @@
+
+module Wx
+
+  class << self
+    # Returns trace level (always 0 if #wxrb_debug returns false)
+    # In case #wxrb_debug returns true #wxrb_trace_level= is also defined)
+    # @return [Integer]
+    attr_reader :wrb_trace_level
+  end
+
+end

data/lib/wx/doc/dc.rb

@@ -0,0 +1,49 @@
+
+class Wx::DC
+
+  # Provides similar functionality like wxDCBrushChanger setting the given brush as the active
+  # brush for the DC for the duration of the block execution restoring the previous brush afterwards.
+  # @param [Wx::Brush] brush new brush to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_brush(brush) end
+
+  # Provides similar functionality like wxDCPenChanger setting the given pen as the active
+  # pen for the DC for the duration of the block execution restoring the previous pen afterwards.
+  # @param [Wx::Pen] pen new pen to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_pen(pen) end
+
+  # Provides similar functionality like wxDCFontChanger setting the given font as the active
+  # font for the DC for the duration of the block execution restoring the previous font afterwards.
+  # @param [Wx::Font] font new font to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_font(font) end
+
+  # Provides similar functionality like wxDCTextColourChanger setting the given colour as the active
+  # text foreground colour for the DC for the duration of the block execution restoring the previous colour afterwards.
+  # @param [Wx::Colour] clr new colour to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_text_foreground(clr) end
+  alias :with_text_fg :with_text_foreground
+
+  # Provides similar functionality like wxDCTextBgColourChanger setting the given colour as the active
+  # text background colour for the DC for the duration of the block execution restoring the previous colour afterwards.
+  # @param [Wx::Colour] clr new colour to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_text_background(clr) end
+  alias :with_text_bg :with_text_background
+
+  # Provides similar functionality like wxDCTextBgModeChanger setting the given mode as the active
+  # background mode for the DC for the duration of the block execution restoring the previous mode afterwards.
+  # @param [Integer] mode new mode to use during block execution
+  # @return [void]
+  # @yieldparam [Wx::DC] dc the DC (self)
+  def with_background_mode(mode) end
+  alias :with_bg_mode :with_background_mode
+
+end

data/lib/wx/doc/enum.rb

@@ -0,0 +1,88 @@
+###
+# wxRuby3 Enum class
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+
+module Wx
+
+  # Base class for typed enums.
+  # Derives from Numeric and behaves as such in math operations but provides
+  # type safety for arguments requiring the specific enum class.
+  class Enum < Numeric
+
+    # Initialize a new enum value.
+    # @param [Integer] val enum integer value
+    def initialize(val)end
+
+    # Coerces enum value to be compatible with other if possible. Raises TypeError if not compatible.
+    # @param [Numeric] other numeric value
+    # @return [Array<Integer, Integer>] the integer equivalences of other and enum value
+    def coerce(other) end
+
+    # Returns true.
+    def integer?; end
+
+    # Returns false.
+    def real?; end
+
+    # Redirects to the @value member attribute for any missing methods.
+    def method_missing(sym, *args) end
+
+    # Checks type and value equality.
+    # @param [Object] o the object to compare
+    # @return [true,false] true if o is instance of same enum class as self **and** integer values are equal; false otherwise
+    def eql?(o) end
+
+    # Compares integer values if possible. Raises ArgumentError if not compatible
+    # @param [Enum,Numeric] o enum or numeric object to compare.
+    # @return [-1,0,1]
+    def <=>(o) end
+
+    # Returns bitwise or-ed value.
+    # In case other is same class as self an enum instance of that class is returned
+    # otherwise an Integer value.
+    # @param [Wx::Enum,Integer] other
+    # @return [Wx::Enum,Integer]
+    def |(other) end
+
+    # Returns bitwise and-ed value.
+    # In case other is same class as self an enum instance of that class is returned
+    # otherwise an Integer value.
+    # @param [Wx::Enum,Integer] other
+    # @return [Wx::Enum,Integer]
+    def &(other) end
+
+    # Returns an enum instance of the complement value (same class as self).
+    # @return [Wx::Enum]
+    def ~; end
+
+    # Returns true if value is 0 otherwise false.
+    # @return [Boolean]
+    def !; end
+
+    # Return next integer value from enum's value.
+    # @return [Integer] next integer value
+    def succ; end
+
+    # Return string representation.
+    def inspect; end
+
+    # Return integer value of enum
+    def to_int; end
+    alias :to_i :to_int
+
+    # Create a new class and associated enum values.
+    # @param [String,Symbol] name name of new enum class
+    # @param [Hash] enum_values hash with enum value name and enum integer value pairs
+    # @return [Class] new enum class
+    def self.create(name, enum_values) end
+
+    # Returns enum class matching name or nil.
+    # @param [String,Symbol] name name of enum class
+    # @return [Class,nil] enum class
+    def self.[](name) end
+
+  end
+
+end

data/lib/wx/doc/evthandler.rb

@@ -0,0 +1,87 @@
+# Additional event handler methods documentation stubs.
+
+
+class Wx::EvtHandler
+
+  # Public method to register the mapping of a custom event type
+  # +konstant+ (which should be a unique integer; one will be created if
+  # not supplied) to a custom event class +klass+. If +meth+ and +arity+
+  # are given, a convenience evt_handler method called +meth+ will be
+  # created, which accepts +arity+ arguments (specify both or neither).
+  # @param klass [Class] event class
+  # @param konstant [Integer] unique event type id (if nil a unique value will be autogenerated)
+  # @param meth [String,Symbol] optional event handler method name
+  # @param arity [Integer] event handler method arity (should be 0, 1 or 2 if not nil)
+  # @return [Integer] unique event type id
+  def self.register_class(klass, konstant = nil, meth = nil, arity = nil) end
+
+  def connect(first_id, last_id, evt_type, handler) end
+
+  def disconnect(first_id, last_id, evt_spec) end
+
+  # Processes an event, searching event tables and calling zero or more suitable event handler function(s).
+  #
+  # Normally, your application would not call this function: it is called in the wxWidgets implementation to
+  # dispatch incoming user interface events to the framework (and application).
+  #
+  # However, you might need to call it if implementing new functionality (such as a new control) where you
+  # define new event types, as opposed to allowing the user to override virtual functions.
+  #
+  # In wxRuby this method can not be effectively overridden.
+  # In order to override default event processing define a try_before(event) or try_after(event) method
+  # as member of a derived EvtHandler class.
+  #
+  # The normal order of event table searching is as follows:
+  #
+  # 1. {Wx::App#filter_event} is called. If it returns anything but -1 (default) the processing stops here.
+  # 2. #try_before (if it exists, otherwise the C++ default implementation) is called (this is where {Wx::Validator} are taken into account for {Wx::Window} objects). If this returns true, the function exits.
+  # 3. If the object is disabled (via a call to {Wx::EvtHandler#set_evt_handler_enabled}) the function skips to step (7).
+  # 4. Dynamic event table of the handlers bound using Bind<>() is searched in the most-recently-bound to the most-early-bound order. If a handler is found, it is executed and the function returns true unless the handler used {Wx::Event#skip} to indicate that it didn't handle the event in which case the search continues.
+  # 5. Static events table of the handlers bound using event table macros is searched for this event handler in the order of appearance of event table macros in the source code. If this fails, the base class event table is tried, and so on until no more tables exist or an appropriate function was found. If a handler is found, the same logic as in the previous step applies.
+  # 6. The search is applied down the entire chain of event handlers (usually the chain has a length of one). This chain can be formed using {Wx::EvtHandler#set_next_handler}
+  #    Note that in the case of Wx::Window you can build a stack of event handlers (see {Wx::Window#push_event_handler} for more info). If any of the handlers of the chain return true, the function exits.
+  # 7. #try_after (if it exists, otherwise the C++ default implementation) is called: for the {Wx::Window} object this may propagate the event to the window parent (recursively). If the event is still not processed, {#process_event} on the {Wx::THE_APP} object is called as the last step.
+  #
+  # Notice that steps (2)-(6) are performed in {#process_event_locally} which is called by this function.
+  #
+  # @param event [Wx::Event]  Event to process.
+  # @return [true,false] true if event has been processed
+  def process_event(event) end
+
+  # Process a command, supplying the window identifier, command event identifier, and member function or proc.
+  # @param [Integer] id window identifier
+  # @param [Integer] evt_id event type identifier
+  # @param [String,Symbol,Method,Proc] meth (name of) method or event handling proc
+  # @yieldparam [Wx::CommandEvent] event event to handle
+  def evt_command(id, evt_id, meth = nil, &block) end
+
+  # Process a command for a range of window identifiers, supplying the minimum and maximum window identifiers, command event identifier, and member function or proc.
+  # @param [Integer] id1 minimum window identifier
+  # @param [Integer] id2 maximum window identifier
+  # @param [Integer] evt_id event type identifier
+  # @param [String,Symbol,Method,Proc] meth (name of) method or event handling proc
+  # @yieldparam [Wx::CommandEvent] event event to handle
+  def evt_command_range(id1, id2, evt_id, meth = nil, &block) end
+
+  # Convenience evt_handler to listen to all mouse events.
+  # @yieldparam [Wx::MouseEvent] event event to handle
+  def evt_mouse_events(&block) end
+
+  # Convenience evt handler to listen to all scrollwin events.
+  # @yieldparam [Wx::ScrollWinEvent] event event to handle
+  def evt_scrollwin(&block) end
+
+  # Processes Wx::WindowDestroyEvent events.
+  # In wxRuby Wx::Event#skipped will be forced to true after the provided
+  # handler has finished to make sure the event is propagated as it is
+  # required that Wx::App gets to handle the event in the end.
+  # @yieldparam [Wx::WindowDestroyEvent] event event to handle
+  def evt_window_destroy(&block) end
+
+  # Schedule a call for asynchronous execution (at idle time).
+  # @param meth [Symbol,String,Method,Proc] (name of) method or proc to call
+  # @param args [Array<Object>] optional arguments to pass to the call
+  # @return [void]
+  # @yield [*args] optional arguments
+  def call_after(meth = nil, *args, &block) end
+end