wxruby3 0.9.0.pre.beta.8

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

data/lib/wx/core/image.rb

@@ -0,0 +1,68 @@
+# A platform-independent image; can be manipulated more extensively than
+# Bitmap, but must be converted to a Bitmap for drawing.
+class Wx::Image
+
+  # restore the overloaded method
+  def set_rgb_data(data, *size)
+    if size.empty?
+      height = self.get_size.height
+      width = self.get_size.width
+    else
+      width, height = size
+      if Wx::Size === width
+        height = width.height
+        width = width.width
+      end
+    end
+    set_rgb_data_with_size(data, width, height)
+  end
+
+  # alias for backward compatibility
+  alias :get_data :get_rgb_data
+  alias :set_data :set_rgb_data
+  
+  # Load the type-guessing hash from Wx::Bitmap
+  require_relative './bitmap'
+  BITMAP_TYPE_GUESS = Wx::Bitmap::BITMAP_TYPE_GUESS
+
+  # Load a new image from an IO-like object that supports "read"
+  def self.read(an_io, type_or_mime, index = -1)
+    img = new
+    img.load_stream(an_io, type_or_mime, index)
+    img
+  end
+
+  # Create a new image from Wx::Bitmap, preserving mask information
+  def self.from_bitmap(bmp)
+    bmp.convert_to_image
+  end
+
+  # Ruby methods that switch class are conventionally named to_foo
+  def to_bitmap
+    Wx::Bitmap.from_image(self)
+  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 invalid image, which may cause faults
+  # later. Also, if loading from a file, and the type is not specified,
+  # try to guess it from the filename extension
+  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, "Image 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
+  
+  # Convert to bitmap
+  def convert_to_bitmap
+    Wx::Bitmap.from_image(self)
+  end
+end

data/lib/wx/core/imagelist.rb

@@ -0,0 +1,3 @@
+class Wx::ImageList
+  alias :<< :add
+end

data/lib/wx/core/listbox.rb

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

data/lib/wx/core/listctrl.rb

@@ -0,0 +1,33 @@
+# Multi-item control with numerous possible view styles
+class Wx::ListCtrl
+  # Make these ruby enumerables so find, find_all, map are available 
+  include Enumerable
+  # Passes each valid item index into the passed block
+  def each
+    0.upto(item_count - 1) { | i | yield i }
+  end
+
+  # Returns an Array containing the indexes of the currently selected
+  # items 
+  def get_selections
+    selections = []
+    item = get_next_item(-1, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED)
+    while item >= 0
+      selections << item
+      item = get_next_item(item, Wx::LIST_NEXT_ALL, Wx::LIST_STATE_SELECTED) 
+    end
+    selections
+  end
+
+  # # Stub version for LC_VIRTUAL controls that does nothing; may be
+  # # overridden in subclasses.
+  # def on_get_item_attr(i)
+  #   nil
+  # end
+  #
+  # # Stub version for LC_VIRTUAL|LC_REPORT controls that does nothing;
+  # # may be overridden in subclasses.
+  # def on_get_item_column_image(i, col)
+  #   -1
+  # end
+end

data/lib/wx/core/locale.rb

@@ -0,0 +1,73 @@
+class Wx::Locale
+  class << self
+    def get_system_language_name
+      get_language_name( get_system_language )
+    end
+    
+    def get_system_encoding_name
+      Wx::Font::ENCODING_NAMES[ get_system_encoding ]
+    end
+
+    # Set the current locale by a name, canonical name, or Wx::LANGUAGE_
+    # constant; mainly here because it seems a bit strange in Ruby to
+    # have global side-effects in a constructor
+    def set_locale(locale)
+      if ::Integer === locale || Wx::Enum === locale
+        new(locale)
+      elsif ::String === locale and (lang_info = find_language_info(locale))
+        new(lang_info.language)
+      else
+        raise ArgumentError, "Unknown language #{locale}"
+      end
+    end
+
+    # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+    # to specify languages we need to fix some things here to make that easier
+    wx_is_available = Wx::Locale.method(:is_available)
+    define_method :is_available do |lang|
+      wx_is_available.call(lang.to_i)
+    end
+
+    wx_get_language_info = Wx::Locale.method(:get_language_info)
+    define_method :get_language_info do |lang|
+      wx_get_language_info.call(lang.to_i)
+    end
+
+    wx_get_language_name = Wx::Locale.method(:get_language_name)
+    define_method :get_language_name do |lang|
+      wx_get_language_name.call(lang.to_i)
+    end
+
+    wx_get_language_canonical_name = Wx::Locale.method(:get_language_canonical_name)
+    define_method :get_language_canonical_name do |lang|
+      wx_get_language_canonical_name.call(lang.to_i)
+    end
+  end
+
+  # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+  # to specify languages we need to fix some things here to make that easier
+  alias :wx_initialize :initialize
+  def initialize(*args)
+    if args.empty? || ::String === args.first
+      wx_initialize(*args)
+    else
+      wx_initialize(args.shift.to_i, *args)
+    end
+  end
+
+  # as wxWidgets defines an enum wxLanguage but still uses a mix of enum args and int args
+  # to specify languages we need to fix some things here to make that easier
+  wx_init = instance_method(:init)
+  define_method :init do |*args|
+    if args.empty? || ::String === args.first
+      wx_init.bind(self).call(*args)
+    else
+      wx_init.bind(self).call(args.shift.to_i, *args)
+    end
+  end
+
+  def get_language_name
+    self.class.get_language_name(get_language)
+  end
+
+end

data/lib/wx/core/log.rb

@@ -0,0 +1,20 @@
+
+module Wx
+
+  class Log
+    class << self
+      alias :active_target= :set_active_target
+      alias :active_target :get_active_target
+      alias :log_level :get_log_level
+      alias :log_level= :set_log_level
+      alias :enabled? :is_enabled
+      alias :repetition_counting :get_repetition_counting
+      alias :repetition_counting= :set_repetition_counting
+      alias :timestamp :get_timestamp
+      alias :timestamp= :set_timestamp
+      alias :verbose :get_verbose
+      alias :verbose= :set_verbose
+    end
+  end
+
+end

data/lib/wx/core/menu.rb

@@ -0,0 +1,78 @@
+# A single labelled list within a drop-down menu, or a popup menu
+class Wx::Menu
+
+  alias :wx_initialize :initialize
+
+  def initialize(*args, &block)
+    wx_initialize(*args)
+    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 should accept a single argument or none"
+      end
+    end
+  end
+
+  # In the standard WxWidgets API, the methods append, prepend, insert
+  # (and their variants) require a constant integer id as the identifier
+  # of the menu item. This is then used in event handling. 
+  #
+  # In WxRuby the use of explicit ids can be avoided in most cases,
+  # being a most unruby-ish practice. So, by analogy with the general
+  # use of Wx::Window classes and event handlers, where the id is
+  # implicit in the constructor, and the window can be passed direct to
+  # the event handler setup method, the below sets up a similar facility
+  # for adding items to Wx::Menu.
+  #
+  # For all these methods, the only required argument is the string name
+  # of the menu item; a system-default id will be supplied if no
+  # explicit one is given. The return value of these methods in all
+  # cases is a Wx::MenuItem object, which can be passed directly as the
+  # first argument to an evt_menu handler.
+  def self.methods_with_optional_ids(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | *args |
+          case args.first
+            when Integer, Wx::Enum then old_meth.bind(self).call(*args)
+            when String then old_meth.bind(self).call(Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids :append, :prepend,
+                            :append_check_item, :prepend_check_item, 
+                            :append_radio_item, :prepend_radio_item
+
+  # This is much the same as above, except for insert and variants,
+  # which take an additional first argument, the position at which to
+  # insert the new item.
+  def self.methods_with_optional_ids_and_pos(*meth_names)
+    class_eval do 
+      meth_names.each do | meth |
+        old_meth = instance_method(meth)
+        define_method(meth) do | pos, *args |
+          case args.first
+            when Integer, Wx::Enum then old_meth.bind(self).call(pos, *args)
+            when String then old_meth.bind(self).call(pos, Wx::ID_ANY, *args)
+            when Wx::MenuItem then old_meth.bind(self).call(pos, args.first)
+          end
+        end
+      end
+    end
+  end
+
+  # Create the optional-id methods
+  methods_with_optional_ids_and_pos :insert,
+                                    :insert_check_item,
+                                    :insert_radio_item
+end

data/lib/wx/core/menu_bar.rb

@@ -0,0 +1,20 @@
+
+class Wx::MenuBar
+
+  alias :wx_initialize :initialize
+
+  def initialize(*args, &block)
+    wx_initialize(*args)
+    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 should accept a single argument or none"
+      end
+    end
+  end
+
+end

data/lib/wx/core/menuitem.rb

@@ -0,0 +1,7 @@
+# An individual item within a frame or popup menu
+class Wx::MenuItem
+  # Get the Wx id, not Ruby's deprecated Object#id
+  alias :id :get_id
+  # In case a more explicit option is preferred.
+  alias :wx_id :get_id
+end

data/lib/wx/core/notebook.rb

@@ -0,0 +1,9 @@
+# Displays a set of pages in parallel using tabs
+class Wx::Notebook
+  # Convenience method for iterating pages
+  def each_page
+    0.upto(get_page_count - 1) do | i |
+      yield get_page(i)
+    end
+  end
+end

data/lib/wx/core/object.rb

@@ -0,0 +1,14 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # Massage the output of inspect to show the public module name (Wx),
+  # instead of the internal name (Wxruby2)
+  # def to_s
+  #   super.sub('ruby2', '')
+  # end
+
+  # Returns a string containing the C++ pointer address of this
+  # object. Only useful for debugging.
+  def ptr_addr
+    Wx::ptr_addr(self)
+  end
+end

data/lib/wx/core/pen_info.rb

@@ -0,0 +1,11 @@
+
+class Wx::PenInfo
+
+  # make Wx::PenInfo#dashes return self
+  wx_dashes = instance_method :dashes
+  define_method :dashes do |*args|
+    wx_dashes.bind(self).call(*args)
+    self
+  end
+
+end

data/lib/wx/core/platform_info.rb

@@ -0,0 +1,13 @@
+
+module Wx
+
+  class PlatformInfo
+
+    # make all methods of the singleton accessible through the class
+    def self.method_missing(sym, *args)
+      Wx::PlatformInfo.instance.__send__(sym, *args)
+    end
+
+  end
+
+end