wxruby64 2.0.1-x64-mingw32

data/lib/wx/classes/font.rb

@@ -0,0 +1,118 @@
+class Wx::Font
+  # String names of the constants provided by C++ 
+  # (enum is originally defined inc 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
+    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
+    MAX
+  ]
+
+  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(flag_int)
+      else
+        raise ArgumentError, "Unknown font encoding name '#{enc}'"
+      end
+    end
+  end
+end

data/lib/wx/classes/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/classes/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/classes/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/classes/grid.rb

@@ -0,0 +1,146 @@
+# A data-oriented editable table control.
+class Wx::Grid
+  # The following extensions are all to prevent crashes associated with
+  # garbage collection of Grid-related classes; they do not extend the
+  # public functionality of the class in any way. 
+  # 
+  # GridTableBase, and the GridCellRenderers and GridCellEditors pose a
+  # problem for ruby's GC, in that Wx makes them owned by the grid once
+  # they have been set for a cell or group of cells. However, because
+  # they are SWIG directors we cannot allow the ruby object they are
+  # originally associated with to be swept by GC, as C++ method calls
+  # are routed to ruby method calls.
+  #
+  # The code below stores Ruby redefines all methods that may
+  # potentially set a GridTableBase, Editor or Renderer, and stores a
+  # reference to them in an instance variable, so they are not disposed
+  # of up when GC sweeps.
+  
+  # These all need to be set up as private methods which default to an
+  # array. This can't be done in initialize b/c that may not be called
+  # when a Grid is loaded from XRC
+  %w| __cell_editors   __col_editors   __row_editors
+      __cell_renderers __col_renderers __row_renderers |.each do | meth |
+    define_method(meth) do
+      instance_variable_get("@#{meth}") || 
+        instance_variable_set("@#{meth}", [])
+    end
+    private meth
+  end
+
+  # Set a grid table base to provide data
+  alias :__set_table :set_table
+  def set_table(table, sel_mode = Wx::Grid::GridSelectCells)
+    __set_table(table, sel_mode)
+    @__grid_table = table
+  end
+
+  # Store the renderers / editors associated with types, if used
+  alias :__register_data_type :register_data_type
+  def register_data_type(type_name, renderer, editor)
+    __register_data_type(type_name, renderer, editor)
+    @__named_type_info ||= {}
+    @__named_type_info[type_name] = [ renderer, editor ]
+  end
+
+  # store default editor
+  wx_set_default_editor = self.instance_method(:set_default_editor)
+  define_method(:set_default_editor) do | editr |
+    wx_set_default_editor.bind(self).call(editr)
+    @__default_editor = editr
+  end
+
+  # store default renderer
+  wx_set_default_renderer = self.instance_method(:set_default_renderer)
+  define_method(:set_default_renderer) do | rendr |
+    wx_set_default_renderer.bind(self).call(rendr)
+    @__default_renderer = rendr
+   end
+
+  # store cell editors
+  wx_set_cell_editor = self.instance_method(:set_cell_editor)
+  define_method(:set_cell_editor) do | row, col, editr |
+    wx_set_cell_editor.bind(self).call(row, col, editr)
+    __cell_editors[row] ||= []
+    __cell_editors[row][col] = editr
+   end
+
+  # store cell renderer
+  wx_set_cell_renderer = self.instance_method(:set_cell_renderer)
+  define_method(:set_cell_renderer) do | row, col, rendr |
+    wx_set_cell_renderer.bind(self).call(row, col, rendr)
+    __cell_renderers[row] ||= []
+    __cell_renderers[row][col] = rendr
+  end
+
+  # Store an editor and/or renderer for a whole column
+  wx_set_col_attr = self.instance_method(:set_col_attr)
+  define_method(:set_col_attr) do | col, attr |
+    wx_set_col_attr.bind(self).call(col, attr)
+    if attr.has_editor
+      __col_editors[col] = attr.get_editor(self, 0, col)
+    end
+    if attr.has_renderer
+      __col_renderers[col] = attr.get_renderer(self, 0, col)
+    end
+  end  
+
+  # Store an editor and/or renderer for a whole row
+  wx_set_row_attr = self.instance_method(:set_row_attr)
+  define_method(:set_row_attr) do | row, attr |
+    wx_set_row_attr.bind(self).call(row, attr)
+    if attr.has_editor
+      __row_editors[row] = attr.get_editor(self, row, 0)
+    end
+    if attr.has_renderer
+      __row_renderers[row] = attr.get_renderer(self, row, 0)
+    end
+  end  
+
+  # This and the following methods do a bit of book-keeping - as rows
+  # and columns are deleted and inserted, the position of the columns
+  # and rows with stored editors and renderers may move.
+  alias :__insert_rows :insert_rows
+  def insert_rows(pos = 0, num = 1, update_labels = true)
+    __insert_rows(pos, num, update_labels)
+    num.times { __row_editors.insert(pos, nil) }
+    num.times { __row_renderers.insert(pos, nil) }
+    num.times { __cell_editors.insert(pos, []) }
+    num.times { __cell_renderers.insert(pos, []) }
+  end
+  
+  alias :__insert_cols :insert_cols
+  def insert_cols(pos = 0, num = 1, update_labels = true)
+    __insert_cols(pos, num, update_labels)
+    num.times { __col_editors.insert(pos, nil) }
+    num.times { __col_renderers.insert(pos, nil) }
+    num.times do
+      __cell_editors.map { | col | col.insert(pos, []) if col }
+    end
+    num.times do
+      __cell_renderers.map { | col | col.insert(pos, []) if col }
+    end
+  end
+
+  alias :__delete_rows :delete_rows
+  def delete_rows(pos = 0, num = 1, update_labels = true)
+    __delete_rows(pos, num, update_labels)
+    __row_editors.slice!(pos, num)
+    __row_renderers.slice!(pos, num)
+    __cell_editors.slice!(pos, num)
+    __cell_renderers.slice!(pos, num)
+  end
+ 
+  alias :__delete_cols :delete_cols
+  def delete_cols(pos = 0, num = 1, update_labels = true)
+    __delete_cols(pos, num, update_labels)
+    __col_editors.slice!(pos, num)
+    __col_renderers.slice!(pos, num)
+    num.times do
+      __cell_editors.map { | col | col.slice!(pos, num) if col }
+    end
+    num.times do
+      __cell_renderers.map { | col | col.slice!(pos, num) if col }
+    end
+  end
+end

data/lib/wx/classes/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/classes/helpcontroller.rb

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

data/lib/wx/classes/helpcontrollerhelpprovider.rb

@@ -0,0 +1,23 @@
+# Pure-ruby implementation of the corresponding Wx class. Shows a
+# relevant section of help, if available, or a native popup
+require 'wx/classes/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/classes/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/classes/htmlhelpcontroller.rb

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

data/lib/wx/classes/htmlwindow.rb

@@ -0,0 +1,14 @@
+class Wx::HtmlWindow
+  # imitate the in-built LoadFile method
+  def load_file(file)
+    set_page( File.read(file) )
+  end
+  
+  # This is called from within wxWidgets whenever a URL is being
+  # opened. The method may return true, to signal that the opening
+  # should be permitted, false or nil to signal that it should be
+  # blocked, or a string URL to which it should be redirected
+  def on_opening_url(url)
+    true
+  end
+end

data/lib/wx/classes/icon.rb

@@ -0,0 +1,32 @@
+# 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/classes/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
+
+  # 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