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

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'

data/lib/wx/core/ext.rb

@@ -0,0 +1,58 @@
+
+module Wx
+
+  class << self
+
+    private
+
+    class Key
+      def initialize(mod, sym)
+        @mod = mod
+        @sym = sym
+      end
+      attr_reader :mod, :sym
+
+      def eql?(other)
+        self.class === other && mod == other.mod && sym == other.sym
+      end
+
+      def hash
+        "#{mod}#{sym}".hash
+      end
+    end
+
+    def delayed_constants
+      @delayed_constants ||= ::Hash.new
+    end
+
+    public
+
+    def add_delayed_constant(mod, sym, &block)
+      delayed_constants[Key.new(mod,sym)] = block
+    end
+
+    def load_delayed_constants
+      delayed_constants.each_pair { |key, blk| key.mod.const_set(key.sym, blk.call) }
+      delayed_constants.clear # cleanup
+    end
+
+    def check_delayed_constant(mod, sym)
+      if delayed_constants.has_key?(Key.new(mod, sym))
+        raise "Delayed constant #{mod.name}::#{sym} cannot be referenced before the Wx::App has started."
+      end
+    end
+  end
+
+  if !defined?(::WxGlobalConstants)
+    def self.const_missing(sym)
+      Wx.check_delayed_constant(self, sym)
+      super
+    end
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), 'ext', '*.rb')) do | fpath |
+  require_relative './ext/' + File.basename(fpath)
+end
+# Constant extension loader for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands

data/lib/wx/core/font/encoding.rb

@@ -0,0 +1,113 @@
+# --
+# This file is automatically generated by the WXRuby3 interface generator.
+# Do not alter this file.
+# --
+
+class Wx::Font
+  # String names of the constants provided by C++
+  # (extracted from enum defined in include/wx/fontenc.h)
+  ENCODING_NAMES = %w[
+    DEFAULT
+    ISO-8859-1
+    ISO-8859-2
+    ISO-8859-3
+    ISO-8859-4
+    ISO-8859-5
+    ISO-8859-6
+    ISO-8859-7
+    ISO-8859-8
+    ISO-8859-9
+    ISO-8859-10
+    ISO-8859-11
+    ISO-8859-12
+    ISO-8859-13
+    ISO-8859-14
+    ISO-8859-15
+    ISO-8859-MAX
+    KOI8
+    KOI8-U
+    ALTERNATIVE
+    BULGARIAN
+    CP437
+    CP850
+    CP852
+    CP855
+    CP866
+    CP874
+    CP932
+    CP936
+    CP949
+    CP950
+    CP1250
+    CP1251
+    CP1252
+    CP1253
+    CP1254
+    CP1255
+    CP1256
+    CP1257
+    CP1258
+    CP1361
+    CP12-MAX
+    UTF7
+    UTF8
+    EUC-JP
+    UTF16BE
+    UTF16LE
+    UTF32BE
+    UTF32LE
+    MACROMAN
+    MACJAPANESE
+    MACCHINESETRAD
+    MACKOREAN
+    MACARABIC
+    MACHEBREW
+    MACGREEK
+    MACCYRILLIC
+    MACDEVANAGARI
+    MACGURMUKHI
+    MACGUJARATI
+    MACORIYA
+    MACBENGALI
+    MACTAMIL
+    MACTELUGU
+    MACKANNADA
+    MACMALAJALAM
+    MACSINHALESE
+    MACBURMESE
+    MACKHMER
+    MACTHAI
+    MACLAOTIAN
+    MACGEORGIAN
+    MACARMENIAN
+    MACCHINESESIMP
+    MACTIBETAN
+    MACMONGOLIAN
+    MACETHIOPIC
+    MACCENTRALEUR
+    MACVIATNAMESE
+    MACARABICEXT
+    MACSYMBOL
+    MACDINGBATS
+    MACTURKISH
+    MACCROATIAN
+    MACICELANDIC
+    MACROMANIAN
+    MACCELTIC
+    MACGAELIC
+    MACKEYBOARD
+    ISO-2022-JP
+    MAX
+    MACMIN
+    MACMAX
+    UTF16
+    UTF32
+    UNICODE
+    GB2312
+    BIG5
+    SHIFT-JIS
+    EUC-KR
+    JOHAB
+    VIETNAMESE
+  ]
+end

data/lib/wx/core/font.rb

@@ -0,0 +1,22 @@
+
+require_relative './font/encoding'
+
+class Wx::Font
+  class << self
+    # Returns the name of the platform's default font encoding 
+    def get_default_encoding_name
+      ENCODING_NAMES[ get_default_encoding ]
+    end
+
+    # Sets the default encoding to be +enc+, which may be the string
+    # name of an encoding (eg 'UTF8') or an internal WxWidgets flag 
+    # (eg Wx::FONTENCODING_UTF8).
+    def set_default_encoding_name(enc)
+      if flag_int = ENCODING_NAMES.index(enc.upcase)
+        set_default_encoding(Wx::FontEncoding.new(flag_int))
+      else
+        raise ArgumentError, "Unknown font encoding name '#{enc}'"
+      end
+    end
+  end
+end

data/lib/wx/core/functions.rb

@@ -0,0 +1,44 @@
+# Tweaks to the global module functions
+
+module Wx
+  class << self
+    # Allow this to be called with keyword parameters, and avoid
+    # segfaults on OS X with bad params
+    wx_about_box = self.instance_method(:about_box)
+    define_method(:about_box) do | info |
+      # If AboutDialogInfo has no version, it segfaults on OS X 10.5
+      no_version = ArgumentError.new("Must supply a version for AboutDialog")
+      case info
+      when Wx::AboutDialogInfo
+        unless info.has_version
+          Kernel.raise no_version 
+        end
+
+        ab_info = info
+      when Hash
+        ab_info = Wx::AboutDialogInfo.new
+        ab_info.name    = info[:name] || 'wxRuby application'
+        ab_info.version = info[:version] || Kernel.raise(no_version)
+        
+        ab_info.description = info[:description] || ''
+        ab_info.copyright   = info[:copyright] || ''
+        ab_info.licence     = info[:licence] || ''
+        ab_info.developers  = info[:developers] || []
+        ab_info.doc_writers = info[:doc_writers] || []
+        ab_info.artists     = info[:artists] || []
+        ab_info.translators = info[:translators] || []
+        if info.key?(:website)
+          ab_info.set_website(*info[:website])
+        end
+        if info.key?(:icon)
+          ab_info.icon = info[:icon]
+        end
+
+      else
+        Kernel.raise ArgumentError,
+                     "Can't use #{info.inspect} for AboutDialogInfo"
+      end
+      wx_about_box.bind(self).call(ab_info)
+    end
+  end
+end

data/lib/wx/core/gauge.rb

@@ -0,0 +1,12 @@
+# Gauge : presents a progress bar
+#
+# On the C++ side, the actual class name of wxGauge under Windows is
+# wxGauge95. So when a Gauge is loaded from XRC, and we try to wrap the
+# object in a ruby class by calling obj->ClassInfo()->ClassName(), it
+# seeks for a ruby class (Wx::Gauge95) that doesn't exist (see
+# swig/shared/get_ruby_object.i). 
+#
+# To fix this, make Wx::Gauge95 an alias.
+if Wx::PLATFORM == 'WXMSW'
+  Wx::Gauge95 = Wx::Gauge
+end

data/lib/wx/core/genericdirctrl.rb

@@ -0,0 +1,36 @@
+# Bottom-up implementation of a Directory lister
+class Wx::GenericDirCtrl
+  module DirCtrlTree 
+    # The TreeCtrl contained in a GenericDirCtrl already has C++ data
+    # associated with the items. If these are returned to Ruby crashes
+    # will result. So this module sets the TreeCtrl to return the path
+    # string.
+    def get_item_data(tree_id)
+      root_id = get_root_item
+      return "" if tree_id == root_id
+
+      path = item_text(tree_id)
+      while tree_id = item_parent(tree_id) and tree_id != root_id
+        path = item_text(tree_id) + "/#{path}" 
+      end
+      unless Wx::PLATFORM == 'WXMSW'
+        path = "/" + path
+      end
+      path
+    end
+
+    alias :get_item_path :get_item_data
+
+    # Not allowed
+    def set_item_data(tree_id, data)
+      Kernel.raise "Item data cannot be set for a GenericDirCtrl's Tree"
+    end
+  end
+  
+  wx_get_tree_ctrl = instance_method(:get_tree_ctrl)
+  define_method(:get_tree_ctrl) do 
+    tree = wx_get_tree_ctrl.bind(self).call
+    tree.extend(DirCtrlTree)
+    tree
+  end
+end

data/lib/wx/core/hboxsizer.rb

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

data/lib/wx/core/helpcontroller.rb

@@ -0,0 +1,5 @@
+class Wx::HelpController
+  def self.instance(*args)
+    @instance ||= new(*args)
+  end
+end

data/lib/wx/core/helpcontrollerhelpprovider.rb

@@ -0,0 +1,24 @@
+# Pure-ruby implementation of the corresponding Wx class. Shows a
+# relevant section of help, if available, or a native popup
+require_relative './simplehelpprovider'
+
+class Wx::HelpControllerHelpProvider < Wx::SimpleHelpProvider
+  def initialize(help_controller)
+    super()
+    @hc = help_controller
+  end
+
+  # Show help for +win+; if the help text for +win+ is a string with a
+  # single integer only, treats that as a section id for help and shows
+  # that, otherwise shows a popup (native-style on Windows) of the text.
+  def show_help(win)
+    help_text = get_help(win)
+    return false if help_text.empty?
+    if help_text =~ /\A\d+\z/
+      @hc.display_context_popup(help_text.to_i)
+    else
+      @hc.display_text_popup(help_text, Wx::get_mouse_position)
+    end
+    true
+  end
+end

data/lib/wx/core/helpprovider.rb

@@ -0,0 +1,15 @@
+# Base class for providing context-sensitive help. The main definition
+# is in SWIG/C++ 
+class Wx::HelpProvider
+  class << self
+    # We need to protect the currently set HelpProvider from GC as it is a
+    # SWIG Director; it can't be reaped and re-wrapped later. The
+    # easiest way is to make the currently set one an instance variable
+    # of this class
+    alias :__wx_set :set
+    define_method(:set) do | help_provider |
+      __wx_set(help_provider)
+      @__hp__ = help_provider
+    end
+  end
+end

data/lib/wx/core/icon.rb

@@ -0,0 +1,40 @@
+# Specific type of platform-dependent image used for frames on Windows and
+# Linux. Normally Bitmap is used
+class Wx::Icon
+  # Load the type-guessing hash from Wx::Bitmap
+  require 'wx/core/bitmap'
+  BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
+
+  # Analogous to Image.from_bitmap
+  def self.from_bitmap(bmp)
+    ico = new
+    ico.copy_from_bitmap(bmp)
+    ico
+  end
+
+  def to_bitmap
+    # for WXMSW platform Icon is not derived from Bitmap
+    return self unless Wx::PLATFORM == 'WXMSW'
+    bm = Wx::Bitmap.new
+    bm.copy_from_icon(self)
+    bm
+  end
+
+  # Redefine the initialize method so it raises an exception if a
+  # non-existent file is given to the constructor; otherwise, wx Widgets
+  # just carries on with an empty icon, which may cause faults
+  # later. Also guess icon type from filename, if not specified.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    if args[0].kind_of? String
+      if not File.exist?( File.expand_path(args[0]) )
+        Kernel.raise(ArgumentError, "Icon file does not exist: #{args[0]}")
+      end
+      # If type not specified, try to guess it from the file extension
+      if not args[1] and ( file_ext = args[0][/\w+$/] )
+        args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+      end
+    end
+    wx_init.bind(self).call(*args)
+  end
+end