wxruby 1.9.6-x86-mswin32-60

data/LICENSE

@@ -0,0 +1,53 @@
+wxRuby2
+Copyright (c) 2004-2007 wxRuby Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+
+
+
+
+
+
+============================================================================
+THE FOLLOWING IS NOT PART OF THE LICENSE, NOR IS IT LEGAL ADVICE!
+
+wxRuby and wxWidgets
+--------------------
+Normally, wxRuby is distributed with a binary copy of wxWidgets. If you 
+distribute the wxRuby gem, you are bound to the requirements of the 
+copy of wxWidgets within. Fortunately, those requirements do not impose 
+any serious restrictions.
+
+
+wxWidgets License Summary (from the wxWidgets README)
+-----------------------------------------------------
+In summary, the licence is LGPL plus a clause allowing unrestricted 
+distribution of application binaries. To answer a FAQ, you don't have to 
+distribute any source if you wish to write commercial applications using 
+wxWidgets.
+
+
+Required Credits and Attribution
+--------------------------------
+
+Generally, neither wxWidgets nor wxRuby require attribution, beyond 
+retaining existing copyright notices. However, if you build your own 
+custom wxWidgets library, there may be portions that require specific 
+attributions or credits, such as TIFF or JPEG support. See the wxWidgets 
+README and license files for details.

data/README

@@ -0,0 +1,297 @@
+README for wxruby2
+
+Version 1.9.x
+
+This is wxruby2, the second generation of wxRuby, a library 
+that allows Ruby programs to use the wxWidgets GUI toolkit. 
+It is released under a permissive MIT-style license
+(see the LICENSE file for details).
+
+This version is a beta release, in preparation for a stable release of
+wxruby version 2.0.
+
+------------------------FAQ---------------------------
+
+- What platforms and operating systems are supported in wxRuby2?
+
+  Currently the following are fully supported:
+
+  Windows NT/2000/XP/Vista (i686)
+  OS X 10.4+ (i686 and PowerPc)
+  Linux (i686 + AMD-64)
+
+  It is unlikely that support for old Windows OS's (3.1, 95, 98, ME)
+  will be added to wxRuby2 in the near future, as these operating
+  systems have very limited support for Unicode.
+
+- Why would I choose wxruby over FXRuby, Ruby/GTK, or one of the other 
+   GUI toolkits? Isn't wxruby arriving "too late"?
+   
+   There are several great GUI toolkits available for Ruby, but we 
+   like wxruby better because it has a combination of features that no 
+   other toolkit has:
+   
+     - Cross-platform (MSWindows, Mac OS X, Linux)
+     - Native widgets when possible
+     - Provides a wide selection of widgets
+     - Simple license that is compatible with proprietary and Free Software 
+     - Mature foundation (wxWidgets has been around for over 10 years)
+
+   The really big feature is native widgets. The only other cross-platform 
+   toolkits that use native widgets are either limited (Tk) or expensive if 
+   you want to develop proprietary software (Qt). We are not saying that 
+   those toolkits are bad! Just that wxruby offers a unique set of 
+   features.
+   
+- Why are native widgets important or helpful?
+
+   For one thing, it means that end-users do not have to adjust to a 
+   "foreign" interface. It also ensures maximum compatibility with 
+   "assistive technology" such as screen readers for blind users. 
+   It also allows apps to respect any themes the user may have chosen 
+   through their operating system. No matter how hard a toolkit may try 
+   to emulate a particular UI, there will always be differences in the 
+   look or behavior.
+   
+- How does wxruby2 relate to wxruby (and the wxruby 0.6.0 release)?
+
+   wxruby2 is the "next generation" of wxruby. It is being developed 
+   by the same wxruby team, and is intended to replace the older 
+   code base. wxruby2 is built using SWIG, a powerful tool that makes 
+   it much easier to create and maintain wrappers around C/C++ libraries.
+   
+- Why should I use wxruby2 instead of wxruby?
+
+   First, because development on the original wxruby codebase has stopped. 
+   Everyone is working on wxruby2, so it will continue to improve. Beyond 
+   that, wxruby2 has these advantages over wxruby 0.6.0:
+   
+     - Available as binary gems for MSWindows, OS X, and Linux (GTK)
+	 - Support for more classes, and more methods within classes
+	 - Unicode support
+	 - Vastly improved support for OS X
+	 - Looks much better under Linux because it uses GTK+2
+	 - Simpler and more permissive license 
+	 - Wraps wxWidgets 2.8.7 instead of the older 2.4 series
+	 
+- Is wxruby2 ready for "production" use?
+
+  Yes, pretty much. This is a beta release, and there may be some bugs
+  in some methods, or memory leaks. This release includes all the
+  classes and features that are proposed for inclusion in wxruby 2.0.
+
+  It is considerably more stable and fully-featured than the old 0.6.0
+  release, which was never really stable enough for heavy-duty
+  production use.
+   
+- Does wxruby2 support the Xxx class?
+
+   See the "Documentation" section of the README file, or check the 
+   wxruby web site: http://wxruby.org
+   
+- How are the wxruby 0.6.0 and wxruby2 licenses different?
+
+  wxruby 0.6.0 was released under the wxWindows license, which is a 
+  modified LGPL. It is a good, fair license, allowing use in both Free 
+  Software and proprietary applications. However, it is long and complex, 
+  and is more appropriate for compiled code. wxruby2 is available under a 
+  *very* simple MIT-style license, which allows just about any use with 
+  very few restrictions.
+   
+- I am getting an error trying to compile wxruby2
+
+  Please double-check the requirements. You may be using the wrong
+  version of SWIG, wxWidgets, or some other tool. Double-check the
+  instructions on the wxRuby wiki (http://wxruby.rubyforge.org/)
+  
+  If you need help, please ask your question on the wxruby mailing list 
+  (see the link at http://wxruby.org). 
+
+- I am getting an error trying to run any wxruby2 application, such as 
+  the samples that are included in the gem.
+  
+  If you are using Linux, be sure you have configured your system to 
+  have RUBYOPT=-rubygems. This can be done in .bashrc or /etc/environment, 
+  depending on your distribution and preferences. [More details to follow].
+  
+- Why aren't the wx network, file, date, database and other non-GUI
+  classes supported?
+
+  Because Ruby has its own versions of each of them, providing
+  cross-platform abstractions of these functions with familiar syntax
+  and methods. We assume you are writing your application in Ruby, so it
+  makes sense to keep as much code as possible in Ruby. We have only
+  wrapped the wx classes that are necessary to write GUI code.
+
+  There may be some advantages to porting the Wx network classes into
+  ruby, if they work better with multi-(native)-threaded code. This is
+  currently under evaluation.
+  
+- Why has it taken so long for wxruby2 to be released?
+
+  Nobody is getting paid to develop wxruby, so each of the wxruby developers 
+  are limited in the amount of time they can dedicate to the project. We are 
+  always looking for more volunteers to help code, test, document, manage 
+  the bug list, handle publicity, or do other necessary chores.
+  
+  Wrapping wx is a big project that requires a wide variety of skills. As of 
+  February 2008, the wxRuby project has over 100,000 lines of code, including 
+  ruby, C++, and SWIG scripts. If we weren't using SWIG it would be far bigger.
+
+
+For more details, see the project home page:
+  http://wxruby.org/
+
+
+------------------------USING WXRUBY---------------------------
+INSTALLING:
+
+wxRuby is available as binary gems for MS Windows, Mac OS X, and Linux
+with GTK+ 2. Unless you wish to work on wxRuby itself, we strongly
+recommend installing the gem rather than building from source.
+
+REQUIREMENTS TO CREATE AND RUN WXRUBY APPS:
+
+- Ruby 1.8
+- MS Windows NT/2000/XP/Vista, Mac OS X 10.4+, or Linux with GTK+ 2, 
+
+- On Windows, gdiplus.pll and msvcp71.dll. These are available on most
+  systems, but can be downloaded and installed for free from the
+  internet
+- On Linux, libgstreamer. This can be installed from most package sources
+
+SAMPLES:
+
+There is a samples/ directory containing many small sample wxRuby apps 
+that demonstrate how to use various classes. A few samples do not work 
+across all platforms at this time.
+	
+The bigdemo sample is fairly comprehensive, but not all of the 
+sections work on all platforms. 
+
+
+WRITING YOUR OWN WXRUBY APP:
+
+To use wxruby-swig in your app, use:
+  require 'wx'
+  
+samples/minimal.rb can be used as a template for creating your 
+own wxruby application.
+
+
+DOCUMENTATION:
+
+- wxRuby-specific API documentation can be found here:
+
+    http://wxruby.org/doc/
+	
+   (Note: This documentation is auto-generated from the C++ wxWidgets API
+   docs. There are some broken links, some sample code in C++, and some
+   sections which do not apply to ruby. The documentation is continually
+   being improved.)
+
+- The latest version of the documentation can be downloaded from the
+  wxRuby 'Files' section on Rubyforge.
+
+  http://www.rubyforge.org/frs/?group_id=35
+
+- Tables summarizing which wx classes are and are not supported can 
+  be found here:
+  
+    http://wxruby.org/wiki/wiki.pl?ClassesSupportedByCategory
+	
+- Most wxWidgets and wxPython tutorials and references can also be used, if 
+  you remember that wxRuby uses ruby_style_naming for methods and variables 
+  instead of MixedCase as used by wxWidgets.
+  
+
+
+API DIFFERENCES FROM WXWIDGETS:
+- In many cases, wxRuby follows the lead of wxPython (or in some cases, 
+  wxPerl), adjusting certain method calls when the C++ style doesn't fit 
+  dynamic languages.
+- Since initialize is reserved in ruby, use SplitterWindow#init instead.
+- Many wx classes have not been wrapped because native ruby classes work 
+  as well or better. These include wxDateTime, wxString, networking 
+  classes, database classes.
+- log_message and log_status take a single string parameter, 
+  rather than a format string followed by additional values 
+  to be inserted. Use Ruby's sprintf if required.
+
+----------------------COMPILING WXRUBY--------------------------
+REQUIREMENTS TO COMPILE/BUILD WXRUBY ITSELF
+
+- rake 
+- SWIG, version 1.3.32 or later. Earlier versions will not work correctly.
+- wxWidgets 2.8.x SDK. See further information on the wxruby website for
+  recommended compile-time options for wxWidgets.
+
+
+OBTAINING THE SOURCE:
+
+Source code is hosted in Subversion at rubyforge.org. See the links on
+the wxruby web site (http://wxruby.org). Check out the wxruby2
+Subversion module (not the old wxruby module).
+  
+
+BUILDING:
+
+From the top-level directory (typically wxruby2/), 
+just start the rake build with the command:
+
+  rake
+  
+There is no ./configure step, nor do you need to run ruby extconf.rb.
+
+
+INSTALLING THE LIBRARY:
+
+You can install the library using:
+  rake install
+  
+Note that on some systems you may need to be "root" to do this.
+To manually install, copy all the files in the lib/ subdirectory 
+to somewhere on your ruby library path, such as a ruby extensions 
+directory.
+
+
+PORTING TO OTHER PLATFORMS
+
+Platform-dependent rakefiles are used to set up compiler-specific
+settings. The following platforms are currently fully supported:
+
+  Mac OSX (gcc):        rakemacosx.rb
+  MS Windows (VC++):    rakemswin.rb
+  Linux (GTK2 + gcc):   rakelinux.rb
+  
+For other platforms, you may need to edit the appropriate
+platform-dependent rake file if your system is not yet supported, or if
+it is unusual. These files are found in the rake subdirectory:
+
+  MS Windows BC++:      rakebccwin.rb
+  MS Windows MingGW:    rakemingw.rb
+  MS Windows Cygwin:    rakecygwin.rb
+  NetBSD:               rakenetbsd.rb
+
+When editing a platform-dependent rakefile, you might 
+merely need to set one or more of the following variables:
+
+    $extra_cppflags
+    $extra_ldflags
+    $extra_objs
+    $extra_libs
+
+
+CREDITS
+
+Kevin Smith set up the wxruby2 project using SWIG and did much of the
+work that still forms the core of the library in its present form. Over
+the years dozens of volunteers have contributed invaluable patches and
+new functionality. The list is too long to give here, but their
+contributions are recorded in the wxruby mailing list archives.
+
+-----------------------------------------------------------
+
+LEAD MAINTAINER:
+  Alex Fenton
+  alex at pressure dot to

data/lib/wx/accessors.rb

@@ -0,0 +1,52 @@
+# = WxSugar - Accessors
+#
+# The default WxRuby interface has lots and lots of methods like
+#
+#  * get_position()
+#  * set_size(a_size)
+#  * is_checked()
+# 
+# and so on. Methods that retrieve set, or query attributes of an object
+# are more normally in Ruby called simply by the attribute name:
+#
+#  * position()
+#  * size = a_size
+#  * checked?
+#
+# This extension creates an alias for every WxRuby instance method that
+# begins with +get_+, +set_+ or +is_+. 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
+  def method_missing(sym, *args)
+    case sym.to_s
+    when /^(.*)\=$/
+      meth = "set_#{$1}"
+    when /^(.*)\?$/
+      meth = "is_#{$1}"
+    else
+      meth = "get_#{sym}"
+    end
+    if respond_to?(meth)
+      send(meth, *args)
+    else
+      e = NoMethodError.new("undefined method '#{sym}' for #{self.inspect}")
+      e.set_backtrace(caller)
+      Kernel.raise e
+    end
+  end
+end
+
+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,45 @@
+# 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)
+    t = Wx::Timer.new(self, 9999)
+    evt_timer(9999) { Thread.pass }
+    Thread.new { loop { sleep interval; GC.start } }
+    t.start(100)
+  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/bitmap.rb

@@ -0,0 +1,28 @@
+class Wx::Bitmap
+  # Constructor copying data from an image
+  def self.from_image(img, depth = -1)
+    new(img, depth)
+  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 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, "Bitmap file does not exist: #{args[0]}")
+      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,45 @@
+# 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)
+    super(item)
+    __wx_item_data[count - 1] = data
+  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,16 @@
+class Wx::Clipboard
+  class << self
+    # 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 = Wx::Clipboard.new
+      unless clip.open
+        Kernel.raise "Could not open clipboard"
+      end
+      yield clip
+    ensure
+      clip.close
+    end
+  end
+end