wxruby3 0.9.0.pre.beta.8

data/lib/wx/core/choicedlg.rb

@@ -0,0 +1,54 @@
+
+module Wx
+
+  # get the user selection as a string
+  def self.get_single_choice(message,
+                             caption,
+                             choices,
+                             parent = nil,
+                             initial_selection: 0,
+                             x:  Wx::DEFAULT_COORD,
+                             y:  Wx::DEFAULT_COORD)
+    dialog = Wx::SingleChoiceDialog.new(parent, message, caption, choices, nil, Wx::CHOICEDLG_STYLE, [x, y])
+
+    dialog.selection = initial_selection
+    return dialog.show_modal == Wx::ID_OK ? dialog.get_string_selection : ''
+  end
+
+  # get the user selection as an index
+  def self.get_single_choice_index(message,
+                                   caption,
+                                   choices,
+                                   parent = nil,
+                                   initial_selection: 0,
+                                   x:  Wx::DEFAULT_COORD,
+                                   y:  Wx::DEFAULT_COORD)
+    dialog = Wx::SingleChoiceDialog.new(parent, message, caption, choices, nil, Wx::CHOICEDLG_STYLE, [x, y])
+
+    dialog.selection = initial_selection
+    return dialog.show_modal == Wx::ID_OK ? dialog.get_selection : -1
+  end
+
+  # return an array with the indices of the chosen items, it will be empty
+  # if no items were selected or Cancel was pressed
+  def self.get_selected_choices(message,
+                                caption,
+                                choices,
+                                parent = nil,
+                                initial_selections: [],
+                                x:  Wx::DEFAULT_COORD,
+                                y:  Wx::DEFAULT_COORD)
+    dialog = Wx::MultiChoiceDialog.new(parent, message, caption, choices, Wx::CHOICEDLG_STYLE, [x, y])
+
+    # call this even if selections array is empty and this then (correctly)
+    # deselects the first item which is selected by default
+    dialog.selections = initial_selections
+
+    if dialog.show_modal != Wx::ID_OK
+      return []
+    end
+
+    dialog.get_selections
+  end
+
+end

data/lib/wx/core/clientdc.rb

@@ -0,0 +1,13 @@
+# Device Context to paint on a window outside an on_paint handler. It is
+# recommended that PaintDC is used in preference to this class.
+class Wx::ClientDC
+  # 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,
+  # avoiding errors and segfaults on exit.
+  define_method(:initialize) do | *args |
+    Kernel.raise RuntimeError,
+                 "Do not instantiate ClientDC directly; use Window#paint",
+                 caller[1..-1]
+  end
+end

data/lib/wx/core/clipboard.rb

@@ -0,0 +1,56 @@
+class Wx::Clipboard
+  class << self
+    # This is provided internally by the SWIG interface file, but all
+    # public access should be via Clipboard.open; see below
+    private :get_global_clipboard
+
+    # Class method to provide access to the clipboard within a ruby
+    # block. Tests that the clipboard could be accessed, and ensures
+    # that it is closed when the block is finished.
+    def open
+      clip = nil
+      # Trying to access the segfault outside main_loop will segfault on
+      # some platforms (eg, GTK)
+      unless Wx::const_defined?(:THE_APP)
+        raise RuntimeError, 
+              "The clipboard can only be accessed when the App is running"
+      end
+
+      clip = get_global_clipboard
+      unless clip.open
+        Kernel.raise "Could not open clipboard"
+      end
+      yield clip
+     ensure
+       clip.close if clip
+    end
+  end
+
+  # Need to do some internal record-keeping to protect data objects on
+  # the clipboard from garbage collection
+  @@__clip_data = []
+
+  # These methods affect the clipboard contents; each time, update the
+  # record with the changed data contents
+  wx_add_data = instance_method(:add_data)
+  define_method(:add_data) do | the_data |
+    @@__clip_data << the_data
+    wx_add_data.bind(self).call(the_data)
+  end
+
+  wx_clear = instance_method(:clear)
+  define_method(:clear) do 
+    wx_clear.bind(self).call
+    @@__clip_data.clear
+  end
+
+  wx_set_data = instance_method(:set_data)
+  define_method(:set_data) do | the_data |
+    @@__clip_data = [ the_data ]
+    wx_set_data.bind(self).call(the_data)
+  end
+
+  # Aliases, more clearly expressive?
+  alias :place :set_data
+  alias :fetch :get_data
+end

data/lib/wx/core/collapsible_pane.rb

@@ -0,0 +1,12 @@
+# WxRuby Extensions - CollapsiblePane platform dependent alias
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+module Wx
+
+  if Wx.has_feature?(:USE_COLLPANE) && (!Wx.has_feature?(:WXGTK20) || Wx.has_feature?(:WXUNIVERSAL))
+    
+    GenericCollapsiblePane = CollapsiblePane
+    
+  end
+  
+end

data/lib/wx/core/colour.rb

@@ -0,0 +1,34 @@
+class Wx::Colour
+  # Redefine the initialize method so it raises an exception if an
+  # invalid colour value is given. This might be an unknown colour
+  # string (eg 'dark blue') or out-of-bounds integer values (<0 or >255)
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    begin
+      wx_init.bind(self).call(*args)
+    # Invalid integer values raise SWIG 'no matching func'
+    rescue ArgumentError, TypeError
+      Kernel.raise ArgumentError, "Invalid colour values #{args.inspect}"
+    end
+  end
+
+  # Missing Standard colour
+  Wx::MAGENTA = new(255, 0, 255)
+
+  # Colours are equal to one another if they have the same red, green
+  # and blue intensity, and the same alpha
+  def ==(other)
+    case other
+    when Wx::Colour
+      [  self.red,  self.green,  self.blue,  self.alpha ] == 
+      [ other.red, other.green, other.blue, other.alpha ]
+    else
+      false
+    end
+  end
+
+  # More informative output for inspect etc
+  def to_s
+    "#<Wx::Colour: (#{red}, #{green}, #{blue} *#{alpha})>"
+  end
+end

data/lib/wx/core/combobox.rb

@@ -0,0 +1,4 @@
+class Wx::ComboBox
+  alias :get_item_data :get_client_data
+  alias :set_item_data :set_client_data
+end

data/lib/wx/core/controlwithitems.rb

@@ -0,0 +1,10 @@
+# Superclass of a variety of controls that display lists of items (eg
+# Choice, ListBox, CheckListBox)
+class Wx::ControlWithItems
+  # Make these ruby enumerables so find, find_all, map etc are available 
+  include Enumerable
+  # Passes each valid item index into the passed block
+  def each
+    0.upto(get_count - 1) { | i | yield i }
+  end
+end

data/lib/wx/core/data_object.rb

@@ -0,0 +1,10 @@
+# Provide some default implementations of these to make life easier
+class Wx::DataObject
+  def get_preferred_format(direction)
+    get_all_formats(direction).first
+  end
+
+  def get_format_count(direction)
+    get_all_formats(direction).size
+  end
+end

data/lib/wx/core/dataformat.rb

@@ -0,0 +1,26 @@
+# Make this easier to use for multi-typed data objects. Comparison
+# doesn't work correctly in the SWIG binding
+class Wx::DataFormat
+  def ==(other)
+    if self.get_type > Wx::DataFormatId::DF_INVALID
+      self.get_type == other.get_type
+    else
+      self.id == other.id
+    end
+  end
+end
+
+# Provide pre-cooked data formats for the standard types
+module Wx
+  DF_TEXT        = DataFormat.new( Wx::DataFormatId::DF_TEXT )
+  DF_BITMAP      = DataFormat.new( Wx::DataFormatId::DF_BITMAP )
+  if Wx::PLATFORM != 'WXGTK'
+    DF_METAFILE    = DataFormat.new( Wx::DataFormatId::DF_METAFILE )
+  end
+  if Wx::PLATFORM == 'WXMSW'
+    DF_DIB         = DataFormat.new( Wx::DataFormatId::DF_DIB )
+  end
+  DF_FILENAME    = DataFormat.new( Wx::DataFormatId::DF_FILENAME )
+  DF_UNICODETEXT = DataFormat.new( Wx::DataFormatId::DF_UNICODETEXT )
+  # DF_HTML is only supported on Windows + MSVC, so don't offer it
+end

data/lib/wx/core/dc.rb

@@ -0,0 +1,68 @@
+# Class for drawing primitives and bitmaps on various outputs (screen, paper)
+class Wx::DC
+  # provide Ruby-style convenience methods supporting wxDCxxxChanger-like functionality
+
+  def with_brush(brush)
+    begin
+      old_brush = self.brush
+      self.brush = brush
+      yield(self) if block_given?
+    ensure
+      self.brush = old_brush
+    end
+  end
+
+  def with_pen(pen)
+    begin
+      old_pen = self.pen
+      self.pen = pen
+      yield(self) if block_given?
+    ensure
+      self.pen = old_pen
+    end
+  end
+
+  def with_font(font)
+    begin
+      old_font = self.font
+      self.font = font
+      yield(self) if block_given?
+    ensure
+      self.font = old_font
+    end
+  end
+
+  def with_text_foreground(clr)
+    begin
+      old = self.get_text_foreground
+      self.text_foreground = clr
+      yield(self) if block_given?
+    ensure
+      self.text_foreground = old
+    end
+  end
+  alias :with_text_fg :with_text_foreground
+
+  def with_text_background(clr)
+    begin
+      old = self.get_text_background
+      self.text_background = clr
+      yield(self) if block_given?
+    ensure
+      self.text_background = old
+    end
+  end
+  alias :with_text_bg :with_text_background
+
+  def with_background_mode(mode)
+    begin
+      old = self.get_background_mode
+      self.background_mode = mode
+      yield(self) if block_given?
+    ensure
+      self.background_mode = old
+    end
+  end
+  alias :with_bg_mode :with_background_mode
+
+end

data/lib/wx/core/dialog.rb

@@ -0,0 +1,50 @@
+# WxRuby Extensions - Dialog functors for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+class Wx::Dialog
+
+  module Functor
+    def self.included(klass)
+      scope = klass.name.split('::')
+      functor_nm = scope.pop
+      code = <<~__CODE
+        def #{functor_nm}(*args, &block)
+          dlg = #{klass.name}.new(*args)
+          begin
+            if block_given?
+              return block.call(dlg)
+            else
+              return dlg.show_modal
+            end
+          rescue Exception
+            Wx.log_debug "\#{$!}\\n\#{$!.backtrace.join("\\n")}"
+            raise
+          ensure
+            dlg.destroy
+          end
+        end
+        __CODE
+      if scope.empty?
+        ::Kernel.module_eval code
+      else
+        scope.inject(::Object) { |mod, nm| mod.const_get(nm) }.singleton_class.module_eval code
+      end
+      klass.class_eval do
+        def self.inherited(sub)
+          sub.include Wx::Dialog::Functor
+        end
+      end
+    end
+  end
+
+  include Functor
+
+  def self.setup_dialog_functors(mod)
+    # find all Dialog descendants in mod and setup the dialog Functor for them
+    mod.constants.select do |c|
+      ::Class === (const = mod.const_get(c)) && const < Wx::Dialog
+    end.each { |c| mod.const_get(c).include Wx::Dialog::Functor }
+  end
+
+  setup_dialog_functors(Wx)
+end

data/lib/wx/core/enum.rb

@@ -0,0 +1,28 @@
+
+class Wx::Enum
+
+  def |(other)
+    if other.instance_of?(self.class)
+      self.class.new(to_i | other.to_i)
+    else
+      to_i | other.to_i
+    end
+  end
+
+  def &(other)
+    if other.instance_of?(self.class)
+      self.class.new(to_i & other.to_i)
+    else
+      to_i & other.to_i
+    end
+  end
+
+  def ~
+    self.class.new(~self.to_i)
+  end
+
+  def !
+    self.to_i == 0
+  end
+
+end

data/lib/wx/core/event.rb

@@ -0,0 +1,16 @@
+# Base class for all events
+class Wx::Event
+  # Get the Wx id, not Ruby's deprecated Object#id
+  alias :id :get_id
+end
+
+module Wx
+  # reduce mapping warnings for this unpublished event class
+  NcPaintEvent = Wx::Event
+
+  EvtHandler.register_event_type EvtHandler::EventType[
+    'evt_nc_paint', 0,
+    Wx::EVT_NC_PAINT,
+    Wx::NcPaintEvent
+  ]
+end

data/lib/wx/core/evthandler.rb

@@ -0,0 +1,253 @@
+# All classes which are capable of handling events inherit from
+# EvtHandler. This includes all Wx::Window subclasses and Wx::App.
+
+class Wx::EvtHandler
+  # EventType is an internal class that's used to set up event handlers
+  # and mappings.
+  # * 'name' is the name of the event handler method in ruby
+  # * 'arity' is the number of id arguments that method should accept
+  # * 'const' is the Wx EventType constant that identifies the event
+  # * 'evt_class' is the WxRuby event class which is passed to the event
+  #    handler block
+  #
+  # NB: Some event types currently pass a Wx::Event into the event
+  # handler block; when the appropriate classes are added to wxRuby, the
+  # binding can be updated here.
+  EventType = Struct.new(:name, :arity, :const, :evt_class)
+
+  # Fast look-up hash to map event type ids to ruby event classes
+  EVENT_TYPE_CLASS_MAP = {}
+  # Hash to look up EVT constants from symbol names of evt handler
+  # methods; used internally by disconnect (see EvtHandler.i)
+  EVENT_NAME_TYPE_MAP = {}
+
+  # Given a Wx EventType id (eg Wx::EVT_MENU), returns a WxRuby Event
+  # class which should be passed to event handler blocks. The actual
+  # EVT_XXX constants themselves are in the compiled libraries.
+  def self.event_class_for_type(id)
+    if evt_klass = EVENT_TYPE_CLASS_MAP[id]
+      return evt_klass
+    else
+      if Wx::DEBUG
+        warn "No event class defined for event type #{id}"
+      end
+      return Wx::Event
+    end
+  end
+
+  # Given the symbol name of an evt_xxx handler method, returns the
+  # Integer Wx::EVT_XXX constant associated with that handler.
+  def self.event_type_for_name(name)
+    EVENT_NAME_TYPE_MAP[name]
+  end
+
+  # Given the Integer constant Wx::EVT_XXX, returns the convenience
+  # handler method name associated with that type of event.
+  def self.event_name_for_type(name)
+    EVENT_NAME_TYPE_MAP.key(name)
+  end
+
+  # Given an integer value +int_val+, returns the name of the EVT_xxx
+  # constant which points to it. Mainly useful for debugging.
+  def self.const_to_name(int_val)
+    Wx::constants.grep(/^EVT/).find do | c_name |
+      Wx::const_get(c_name) == int_val
+    end
+  end
+
+  # 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.
+  def self.register_class( klass, konstant = nil,
+                           meth = nil, arity = nil)
+    konstant ||= Wx::Event.new_user_event_type
+    unless klass < Wx::Event
+      Kernel.raise TypeError, "Event class should be a subclass of Wx::Event"
+    end
+    ev_type = EventType.new(meth, arity, konstant, klass)
+    register_event_type(ev_type)
+    return konstant
+  end
+
+  # Registers the event type +ev_type+, which should be an instance of
+  # the Struct class +Wx::EvtHandler::EventType+. This sets up the
+  # mapping of events of that type (identified by integer id) to the
+  # appropriate ruby event class, and defines a convenience evt_xxx
+  # instance method in the class EvtHandler.
+  def self.register_event_type(ev_type)
+    # set up the event type mapping
+    EVENT_TYPE_CLASS_MAP[ev_type.const] = ev_type.evt_class
+    EVENT_NAME_TYPE_MAP[ev_type.name.intern] = ev_type.const
+
+    unless ev_type.arity and ev_type.name
+      return
+    end
+
+    # set up the evt_xxx method
+    case ev_type.arity
+    when 0 # events without an id
+      class_eval %Q|
+        def #{ev_type.name}(meth = nil, &block)
+          handler = acquire_handler(meth, block)
+          connect(Wx::ID_ANY, Wx::ID_ANY, #{ev_type.const}, handler)
+        end |
+    when 1 # events with an id
+      class_eval %Q|
+        def #{ev_type.name}(id, meth = nil, &block)
+          handler = acquire_handler(meth, block)
+          id  = acquire_id(id)
+          connect(id, Wx::ID_ANY, #{ev_type.const}, handler)
+        end |
+    when 2 # events with id range
+      class_eval %Q|
+        def #{ev_type.name}(first_id, last_id, meth = nil, &block)
+          handler  = acquire_handler(meth, block)
+          first_id = acquire_id(first_id)
+          last_id  = acquire_id(last_id)
+          connect(first_id, last_id, #{ev_type.const}, handler)
+        end |
+    end
+  end
+
+  # Not for external use; determines whether to use a block or call a
+  # method in self to handle an event, passed to connect. Makes evt_xxx
+  # liberal about what it accepts - aside from a block, it can be a
+  # method name (as Symbol or String), a (bound) method object, or a
+  # Proc object
+  def acquire_handler(meth, block)
+    if block and not meth
+      return block
+    elsif meth and not block
+      h_meth = case meth
+               when Symbol, String then self.method(meth)
+               when Proc then meth
+               when Method then meth
+               end
+      # check arity <= 1
+      if h_meth.arity>1
+        Kernel.raise ArgumentError,
+                     "Event handler should not accept more than at most a single argument"
+                     caller
+      end
+      # wrap method without any argument in anonymous proc to prevent strict argument checking
+      if Method === h_meth && h_meth.arity == 0
+        Proc.new { h_meth.call }
+      else
+        h_meth
+      end
+    else
+      Kernel.raise ArgumentError,
+                  "Specify event handler with a method, name, proc OR block"
+                  caller
+    end
+  end
+
+  # Not for external use; acquires an id either from an explicit Fixnum
+  # parameter or by calling the wx_id method of a passed Window.
+  def acquire_id(window_or_id)
+    case window_or_id
+    when ::Integer, Wx::Enum
+      window_or_id
+    when Wx::Window, Wx::MenuItem, Wx::ToolBarTool, Wx::Timer
+      window_or_id.wx_id
+    else
+      Kernel.raise ArgumentError,
+                   "Must specify Wx::Window event source or its Wx id, " +
+                   "not '#{window_or_id.inspect}'",
+                   caller
+    end
+  end
+  private :acquire_id, :acquire_handler
+
+  wx_call_after = instance_method(:call_after)
+  define_method(:call_after) do |*args, &block|
+    async_proc = if block
+                   block
+                 elsif !args.empty?
+                   case args.first
+                   when Symbol, String then self.method(args.shift)
+                   when Proc then args.shift
+                   when Method then args.shift
+                   else
+                     nil
+                   end
+                 else
+                   nil
+                 end
+    Kernel.raise ArgumentError, 'Missing async call handler' unless async_proc
+    wx_call_after.bind(self).call(args.unshift(async_proc))
+  end
+
+  # Process a command, supplying the window identifier, command event identifier, and member function or proc.
+  def evt_command(id, evt_id, meth = nil, &block)
+    handler = acquire_handler(meth, block)
+    id  = acquire_id(id)
+    connect(id, Wx::ID_ANY, evt_id, handler)
+  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.
+  def evt_command_range(id1, id2, evt_id, meth = nil, &block)
+    handler = acquire_handler(meth, block)
+    id  = acquire_id(id)
+    connect(id, Wx::ID_ANY, evt_id, handler)
+  end
+
+  # Convenience evt_handler to listen to all mouse events.
+  def evt_mouse_events(&block)
+    evt_left_down(&block)
+    evt_left_up(&block)
+    evt_middle_down(&block)
+    evt_middle_up(&block)
+    evt_right_down(&block)
+    evt_right_up(&block)
+    evt_motion(&block)
+    evt_left_dclick(&block)
+    evt_middle_dclick(&block)
+    evt_right_dclick(&block)
+    evt_leave_window(&block)
+    evt_enter_window(&block)
+    evt_mousewheel(&block)
+  end
+
+  # Convenience evt handler to listen to all scrollwin events.
+  def evt_scrollwin(&block)
+    evt_scrollwin_top(&block)
+    evt_scrollwin_bottom(&block)
+    evt_scrollwin_lineup(&block)
+    evt_scrollwin_linedown(&block)
+    evt_scrollwin_pageup(&block)
+    evt_scrollwin_pagedown(&block)
+    evt_scrollwin_thumbtrack(&block)
+    evt_scrollwin_thumbrelease(&block)
+  end
+
+  if Wx.const_defined?(:EVT_DESTROY)
+
+    # evt_window_destroy is a special case in that evt.skip
+    # should always be called when handling the event
+    # as otherwise the OnWindowDestroy handler of Wx::App will not
+    # be called to deregister the windows on destruction which
+    # may lead to segfaults during the GC marking phase.
+    # Thus we register the event here explicitly as well as the
+    # event hook method.
+
+    EVENT_TYPE_CLASS_MAP[Wx::EVT_DESTROY] = Wx::WindowDestroyEvent
+    EVENT_NAME_TYPE_MAP['evt_window_destroy'.intern] = Wx::EVT_DESTROY
+
+    def evt_window_destroy(meth = nil, &block)
+      handler = acquire_handler(meth, block)
+      connect(Wx::ID_ANY, Wx::ID_ANY, Wx::EVT_DESTROY, Proc.new { |evt| handler.call(evt); evt.skip })
+    end
+
+  end
+end
+
+if Wx.const_defined?(:EVT_SASH_DRAGGED) && !Wx.const_defined?(:EVT_SASH_DRAGGED_RANGE)
+  Wx.const_set(:EVT_SASH_DRAGGED_RANGE, Wx::EVT_SASH_DRAGGED)
+end
+
+# Definitions for all event types that are part by core wxRuby.
+
+require_relative './events/evt_list'