wxruby 1.9.0-i686-linux

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/grid.rb

@@ -0,0 +1,130 @@
+# 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. 
+  # 
+  # 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.
+  #
+  # The code below stores Ruby redefines all methods that may
+  # potentially set an Editor or Renderer, and stores a reference to
+  # it in an instance variable, so they are not disposed of up when GC sweeps.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    wx_init.bind(self).call(*args)
+    @__default_editor   = nil
+    @__default_renderer = nil
+
+    @__cell_editors   = []
+    @__cell_renderers = []
+
+    @__col_renderers = []
+    @__col_editors   = []
+    @__row_renderers = []
+    @__row_editors   = []
+  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
+
+  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  
+
+  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.
+  wx_insert_rows = self.instance_method(:insert_rows)
+  define_method(:insert_rows) do | pos, num |
+    wx_insert_rows.bind(self).call(pos, num)
+    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
+
+  wx_insert_cols = self.instance_method(:insert_cols)
+  define_method(:insert_cols) do | pos, num |
+    wx_insert_cols.bind(self).call(pos, num)
+    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
+
+  wx_delete_rows = self.instance_method(:delete_rows)
+  define_method(:delete_rows) do | pos, num |
+    wx_delete_rows.bind(self).call(pos, num)
+    @__row_editors.slice!(pos, num)
+    @__row_renderers.slice!(pos, num)
+    @__cell_editors.slice!(pos, num)
+    @__cell_renderers.slice!(pos, num)
+  end
+ 
+  wx_delete_cols = self.instance_method(:delete_cols)
+  define_method(:delete_cols) do | pos, num |
+    wx_delete_cols.bind(self).call(pos, num)
+    @__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/helpcontroller.rb

@@ -0,0 +1,5 @@
+class Wx::HelpController
+  def self.instance(*args)
+    @instance ||= new(*args)
+  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,6 @@
+class Wx::HtmlWindow
+  # imitate the in-built LoadFile method
+  def load_file(file)
+    set_page( File.read(file) )
+  end
+end

data/lib/wx/classes/icon.rb

@@ -0,0 +1,14 @@
+class Wx::Icon
+  # 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
+  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
+    end
+    wx_init.bind(self).call(*args)
+  end
+end

data/lib/wx/classes/image.rb

@@ -0,0 +1,14 @@
+class Wx::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 invalid image, 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, "Image file does not exist: #{args[0]}")
+      end
+    end
+    wx_init.bind(self).call(*args)
+  end
+end

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

@@ -0,0 +1,28 @@
+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 locale.kind_of?(Fixnum)
+        new(locale)
+      elsif locale.kind_of?(String) and lang_info = find_language_info(locale)
+        new(lang_info.language)
+      else
+        raise ArgumentError, "Unknown language #{locale}"
+      end
+    end
+  end
+
+  def get_language_name
+    self.class.get_language_name(get_language)
+  end
+end

data/lib/wx/classes/object.rb

@@ -0,0 +1,7 @@
+# The root class for most (not all) WxRuby classes
+class Wx::Object
+  # massage the output of inspect to show the public module name (Wx)
+  def to_s
+    super.sub('ruby2', '')
+  end
+end

data/lib/wx/classes/paintdc.rb

@@ -0,0 +1,12 @@
+# Device Context to paint within an on_paint handler
+class Wx::PaintDC
+  # 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,
+  # preventing serious errors on some platforms.
+  def initialize(*args)
+    Kernel.raise RuntimeError,
+                 "Do not instantiate PaintDC directly; use Window#paint",
+                 caller[1..-1]
+  end
+end

data/lib/wx/classes/point.rb

@@ -0,0 +1,5 @@
+class Wx::Point
+  def to_s
+    "#<Wx::Point: (#{x}, #{y})>"
+  end
+end

data/lib/wx/classes/previewframe.rb

@@ -0,0 +1,13 @@
+# Frame that displays a print preview
+class Wx::PreviewFrame
+  # a PreviewFrame has a preview associated with it that must be
+  # protected from Ruby's GC. However, there is no C++ method to access
+  # the Wx::PrintPreview (only a protected member), so instead we have
+  # to assign it to an instance variable so it is marked correctly when
+  # the frame displaying it is marked.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    wx_init.bind(self).call(*args)
+    @__preview = args[0]
+  end
+end

data/lib/wx/classes/rect.rb

@@ -0,0 +1,5 @@
+class Wx::Rect
+  def to_s
+    "#<Wx::Rect: (#{get_left}, #{get_top}) (#{get_right}, #{get_bottom})>"    
+  end
+end

data/lib/wx/classes/size.rb

@@ -0,0 +1,5 @@
+class Wx::Size
+  def to_s
+    "#<Wx::Size: (#{get_width}, #{get_height})>"
+  end
+end

data/lib/wx/classes/texturlevent.rb

@@ -0,0 +1,6 @@
+class Wx::TextUrlEvent
+  # Returns the string URL  that is being interacted with in this event
+  def get_url
+    get_event_object.get_value[get_url_start .. get_url_end]
+  end
+end

data/lib/wx/classes/timer.rb

@@ -0,0 +1,69 @@
+# Class allowing periodic or timed events to be fired
+class Wx::Timer
+  # This class can be linked to an owner - an instance of a class
+  # derived from EvtHandler which will receive Timer events. However,
+  # event if a Wx::Timer is attached to a Wx::Window, it is (unlike most
+  # classes) NOT automatically deleted when the window is destroyed. If
+  # the Timer continues ticking, it will send events to the
+  # now-destroyed window, causing segfaults. So the little acrobatics
+  # below set up a hook when a Timer's owner is set, and then ensure the
+  # timer is stopped when the window is destroyed.
+
+  # Redefine initialize
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    setup_owner_destruction_hook(args[0])
+    wx_init.bind(self).call(*args)
+  end
+
+  # Redefine set_owner
+  wx_set_owner = self.instance_method(:set_owner)
+  define_method(:set_owner) do | *args |
+    setup_owner_destruction_hook(args[0])
+    wx_set_owner.bind(self).call(*args)
+  end
+
+  private 
+  # This method notes in Ruby the ownership of the timer, from both
+  # sides, and sets up an event hook if needed for the window's
+  # destruction.
+  def setup_owner_destruction_hook(new_owner)
+    this_timer = self
+
+    # Class-wide list of global (unowned) timers
+    @@__unowned_timers__ ||= []
+
+    # remove from list of previous owner
+    if @__owner__
+      @__owner__.instance_eval { @__owned_timers__.delete(this_timer) }
+    end
+
+    # If becoming global unowned timer, add to list of those timers
+    if not new_owner
+      @__owner__ = nil
+      @@__unowned_timers__ << self      
+      return
+    end
+    
+    # Otherwise, if previously unowned, remove from global owned
+    @@__unowned_timers__.delete(self)
+    @__owner__ = new_owner
+
+    # Then add to list of new owner, setting destructor hook if required    
+    new_owner.instance_eval do
+      if not @__owned_timers__
+        @__owned_timers__ = []
+        unless self.kind_of?(Wx::App) # Don't set up hook on App
+          evt_window_destroy do | evt |
+            # If it's the owning window being destroyed...
+            if evt.get_event_object == self
+              @__owned_timers__.each { | timer | timer.stop }
+            end
+            evt.skip
+          end
+        end
+      end
+      @__owned_timers__ << this_timer
+    end
+  end
+end