wxruby64 2.0.1-x64-mingw32

data/lib/wx.rb

@@ -0,0 +1,53 @@
+# Copyright 2004-2006 by Kevin Smith
+# released under the MIT-style wxruby2 license
+
+# This wrapper serves three functions:
+# 1. It loads the binary library 'wxruby2.so' or 'wxruby.dll', while
+#    still allowing applications to just require 'wx'.
+# 2. It sets up the version information
+# 3. It loads in ruby extensions to the core Wx classes.
+
+
+# load the binary library
+require 'wxruby2'
+
+# alias the module
+Wx = Wxruby2
+
+# Load the version information (should be bundled with all released versions)
+begin
+  require 'wx/version'
+rescue LoadError
+  Wx::WXRUBY_VERSION = '0.0.0'
+end
+# 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'
+
+# 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/classes/evthandler.rb'
+class_files = File.join( File.dirname(__FILE__), 'wx', 'classes', '*.rb')
+Dir.glob(class_files) do | class_file | 
+  require 'wx/classes/' + class_file[/\w+\.rb$/]
+end
+
+# Load in syntax sweeteners
+require 'wx/accessors'
+require 'wx/keyword_ctors'
+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 not $__wx_app_ended__ 
+    Wx::THE_APP.on_exit
+  end
+end
+

data/lib/wx/accessors.rb

@@ -0,0 +1,68 @@
+# = WxSugar - Accessors
+#
+# The default WxRuby interface has lots and lots of methods like
+#
+#  * get_position()
+#  * set_size(a_size)
+#  * is_checked()
+#  * can_undo()
+#  * has_style(a_style)
+# 
+# and so on. Methods that retrieve set, or query attributes of an object
+# are more normally in Ruby called simply by the attribute name, or, in
+# other cases, with a predicate method:
+#
+#  * pos = my_widget.position
+#  * my_widget.size = a_size
+#  * my_widget.checked?
+#  * my_widget.can_undo?
+#  * my_widget.has_style?
+#
+# This extension creates an alias for every WxRuby instance method that
+# begins with +get_+, +set_+, +is_+, +can_+ and +has_+. Note that if you are calling a
+# 'setter' method on self, you must explicitly send the message to self:
+# 
+#  # set's self size to be 100px by 100px
+#  self.size = Wx::Size.new(100, 100)
+#  # only sets the value of a local variable 'size'
+#  size = Wx::Size.new
+
+module WxRubyStyleAccessors
+  # Ruby-style method named are implemented by method-missing; if an
+  # unknown method is called, see if it is a rubyish name for a real
+  # method. In principle it would be possible to set up real aliases for
+  # them at start-up, but in practice this is far too slow for all the
+  # classes that need to be started up.
+  def method_missing(sym, *args)
+    case sym.to_s
+    when /^(\w+)\=$/ 
+      meth = "set_#{$1}"
+    when /^((?:has|can)\w+)\?$/
+      meth = $1
+    when /^(\w+)\?$/
+      meth = "is_#{$1}"
+    else
+      meth = "get_#{sym}"
+    end
+    if respond_to?(meth)
+      send(meth, *args)
+    else
+      super
+    end
+  end
+end
+
+# Allow Wx-global functions to be accessed with nice syntax
+module Wx
+  extend WxRubyStyleAccessors
+end
+
+# Apply the syntax extensions to every class, both class methods and
+# instance methods
+all_classes = Wx::constants.collect { | c | Wx::const_get(c) }.grep(Class)
+all_classes.each do | klass |
+  klass.class_eval do
+    include WxRubyStyleAccessors
+    extend WxRubyStyleAccessors
+  end
+end

data/lib/wx/classes/acceleratortable.rb

@@ -0,0 +1,28 @@
+class Wx::AcceleratorTable
+  # Allow new to be called as []
+  class << self
+    alias :[] :new
+  end
+
+  # Allow initialize to be called with a splat-like list of arguments,
+  # and allow entries to be specified in terser form [mod, key, id]
+  # rather than full AcceleratorEntry.new call.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    # Test for old-style arg passing in a single array
+    if args.length == 1 and args.first.kind_of?(Array) and
+       args.first.all? { | e | e.kind_of?(Wx::AcceleratorEntry) }
+      args = args[0]
+    end
+    # Convert to array of AccEntries, to pass in as single array
+    args = args.map do | entry |
+      case entry 
+      when Wx::AcceleratorEntry then entry
+      when Array then Wx::AcceleratorEntry.new(*entry)
+      else Kernel.raise ArgumentError,
+                        "#{entry.inspect} is not a valid AcceleratorTable entry"
+      end
+    end
+    wx_init.bind(self).call(args)
+  end
+end

data/lib/wx/classes/animation.rb

@@ -0,0 +1,18 @@
+class Wx::Animation < Wx::GDIObject
+  # 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 bitmap, which may cause faults later
+  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, 
+                      "Animation file does not exist: #{args[0]}" )
+      end
+      res = wx_init.bind(self).call()
+      res.load_file(args[0], args[1] || Wx::ANIMATION_TYPE_ANY)
+    else
+      wx_init.bind(self).call(*args)
+    end
+  end
+end

data/lib/wx/classes/app.rb

@@ -0,0 +1,51 @@
+# Copyright 2004-2006 by Kevin Smith
+# released under the MIT-style wxruby2 license
+
+# Controller class which creates and manages all windows.
+class Wx::App
+  # Convenience class method to create simple apps. Starts an
+  # application main_loop, setting up initial windows etc as specified
+  # in the passed block.
+  # block 
+  def self.run(&block)
+    app_klass = Class.new(self)
+    app_klass.class_eval do
+      define_method(:on_init, &block)
+    end
+    the_app = app_klass.new
+    the_app.main_loop
+  end
+
+  # This is a class method in Wx, but permit it to be an instance method
+  # in wxRuby
+  def is_main_loop_running
+    Wx::App.is_main_loop_running
+  end
+
+  # This method handles failed assertions from within the WxWidgets C++
+  # code. These messages are only generated by a DEBUG build of
+  # WxRuby. Such messages usually indicate that the API is being used
+  # incorrectly; the file/line reference points to the place in the
+  # WxWidgets source code where the assertion was made.
+  define_method(:on_assert_failure) do | file, line, condition, message |
+    warn "Wx WARNING: #{message} (#{file}:#{line})"
+  end
+
+  # For use in development only, of no practical use in production code.
+  # This method causes Ruby's garbage collection to run (roughly) at
+  # interval +interval+ (seconds) - the default is 1, i.e. every
+  # second. This should help ferret out bugs in memory management more
+  # quickly.
+  def gc_stress(interval = 1)
+    # Ruby 1.9 provides this built-in version, but doesn't like the 1.8
+    # version at all - results in frequent segfaults.
+    if RUBY_VERSION >= "1.9.0"
+      GC.stress
+    else # Ruby 1.8
+      t = Wx::Timer.new(self, 9999)
+      evt_timer(9999) { Thread.pass }
+      Thread.new { loop { sleep interval; GC.start } }
+      t.start(100)
+    end
+  end
+end

data/lib/wx/classes/artprovider.rb

@@ -0,0 +1,31 @@
+# Class which can supply icons and bitmaps
+class Wx::ArtProvider
+  # Keep a note of supplied ArtProviders to prevent them being GC'd
+  @__art_provs = []
+
+  class << self 
+    wx_insert = instance_method(:insert)
+    define_method(:insert) do | art_prov |
+      wx_insert.bind(self).call(art_prov)
+      @__art_provs.unshift(art_prov)
+    end
+
+    wx_pop = instance_method(:pop)
+    define_method(:pop) do
+      wx_pop.bind(self).call
+      @__art_provs.pop
+    end
+
+    wx_push = instance_method(:push)
+    define_method(:push) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.push(art_prov)
+    end
+
+    wx_remove = instance_method(:remove)
+    define_method(:remove) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.delete(art_prov)
+    end
+  end
+end

data/lib/wx/classes/auinotebook.rb

@@ -0,0 +1,9 @@
+# Advanced User Interface Notebook - draggable panes etc
+class Wx::AuiNotebook
+  # 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/classes/bitmap.rb

@@ -0,0 +1,59 @@
+# A platform-dependent image that can be drawn on the screen
+class Wx::Bitmap
+  # Allow wxRuby to guess the type of an image file from its extension.
+  BITMAP_TYPE_GUESS = { 
+    'bmp'  => Wx::BITMAP_TYPE_BMP,
+    'gif'  => Wx::BITMAP_TYPE_GIF,
+    'ico'  => Wx::BITMAP_TYPE_ICO,
+    'jpeg' => Wx::BITMAP_TYPE_JPEG,
+    'jpg'  => Wx::BITMAP_TYPE_JPEG,
+    'pbm'  => Wx::BITMAP_TYPE_PNM,
+    'pcx'  => Wx::BITMAP_TYPE_PCX,
+    'pgm'  => Wx::BITMAP_TYPE_PNM,
+    'png'  => Wx::BITMAP_TYPE_PNG,
+    'pnm'  => Wx::BITMAP_TYPE_PNM,
+    'ppm'  => Wx::BITMAP_TYPE_PNM,
+    'tga'  => Wx::BITMAP_TYPE_TGA,
+    'tif'  => Wx::BITMAP_TYPE_TIF,
+    'tiff' => Wx::BITMAP_TYPE_TIF,
+    'xbm'  => Wx::BITMAP_TYPE_XBM,
+    'xpm'  => Wx::BITMAP_TYPE_XPM
+  }
+
+  # Constructor copying data from an image
+  def self.from_image(img, depth = -1)
+    new(img, depth)
+  end
+
+  # Ruby methods that switch class are conventionally named to_foo
+  alias :to_image :convert_to_image
+
+  # 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 bitmap, which may cause faults
+  # later. Also, be helpful and try to guess the bitmap type from the
+  # filename if it's not specified
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    # If creating from a file, check it exists
+    if args[0].kind_of? String
+      if not File.exist?( File.expand_path(args[0]) )
+        Kernel.raise(ArgumentError, "Bitmap 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
+
+  # Accepts a block, which will be passed a device context which can be
+  # used to draw upon the Bitmap
+  def draw
+    dc = Wx::MemoryDC.new
+    dc.select_object(self)
+    yield dc
+    dc.select_object( Wx::NULL_BITMAP )
+  end
+end

data/lib/wx/classes/busycursor.rb

@@ -0,0 +1,12 @@
+# Emulates the wxWidgets BusyCursor class, by providing a scope within
+# which a busy cursor will be shown
+class Wx::BusyCursor
+  # Only one class method, optionally accepting a cursor that should be
+  # shown, defaulting to an hour glass cursor.
+  def self.busy(cursor = Wx::HOURGLASS_CURSOR)
+    Wx::begin_busy_cursor(cursor)
+    yield
+  ensure
+    Wx::end_busy_cursor
+  end
+end

data/lib/wx/classes/checklistbox.rb

@@ -0,0 +1,46 @@
+# A ListBox, where each item has a checkbox next to it
+class Wx::CheckListBox
+  # wxRuby redefinitions of core methods to add item data support (not
+  # available in wxWidgets). Use a private method to initialize and
+  # access the data, rather than in initialize(), b/c can't guarantee
+  # that initialize will be called (eg when loaded from XRC)
+  def __wx_item_data
+    @__wx_item_data ||= []
+  end
+  private :__wx_item_data
+
+  # Call method in ControlWithItems, then sync item data
+  def append(item, data = nil)
+    i = super(item)
+    __wx_item_data[count - 1] = data
+    return i
+  end
+
+  # Call method in ControlWithItems, then sync item data
+  def clear
+    super
+    __wx_item_data.clear
+  end
+
+  # delete is defined in Wx::CheckListBox, so must be called in this class
+  wx_delete = self.instance_method(:delete)
+  define_method(:delete) do | n |
+    wx_delete.bind(self).call(n)
+    __wx_item_data.delete_at(n)
+  end
+
+  # Returns an array of indices of items that are currently checked.
+  def get_checked_items
+    find_all { | i | checked?(i) }    
+  end
+  
+  # Wholly redefined here
+  def get_item_data(n)
+    __wx_item_data[n]
+  end
+
+  # Wholly redefined here
+  def set_item_data(n, data)
+    __wx_item_data[n] = data
+  end
+end

data/lib/wx/classes/choice.rb

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

data/lib/wx/classes/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/classes/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 
+    @@__clip_data.clear
+    wx_clear.bind(self).call
+  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