wxruby 1.9.6-x86-mingw32

data/samples/etc/scrollwin.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# Example demonstrating the use of Wx::ScrolledWindow and the
+# ScrollWinEvents
+
+class ScrollFrame < Wx::Frame
+  def initialize(title)
+    super(nil, -1, 'Thumb Scrolling Test', 
+          Wx::DEFAULT_POSITION, Wx::Size.new(400, 300), 
+          Wx::SYSTEM_MENU|Wx::CAPTION|Wx::RESIZE_BORDER|
+                          Wx::MAXIMIZE_BOX|Wx::MINIMIZE_BOX|Wx::CLOSE_BOX)
+
+    @scroll_win = Wx::ScrolledWindow.new(self, -1)
+    # Set the interior size (pixels) of the scrolling window
+    @scroll_win.set_virtual_size(1000, 1500)
+    # Set the number of pixels moved per 'line' / click on the scrollbars
+    @scroll_win.set_scroll_rate(5, 5)
+
+    @button = Wx::Button.new(@scroll_win, -1, 'Press Me', 
+                             Wx::Point.new(200,200), 
+                             Wx::Size.new(125, 20))
+    
+    # NOTE that all ScrollWin event hooks do not take an id - i.e. they
+    # are only generated from the originating Window itself - in this
+    # case, the ScrollWindow. So, we need to do:
+    #  @scroll_win.evt_scrollwin_xxx { ...
+    # AND NOT
+    #  evt_scrollwin_xxx(@scroll_win.get_id) { ...
+    @scroll_win.evt_scrollwin_linedown() { | e | on_line(e, 'down') }
+    @scroll_win.evt_scrollwin_lineup() { | e | on_line(e,'up') }
+    
+    @scroll_win.evt_scrollwin_thumbtrack() { | e | on_thumb(e, 'track') }
+    @scroll_win.evt_scrollwin_thumbrelease() { | e | on_thumb(e, 'release') }
+
+    @scroll_win.evt_scrollwin_pagedown() { | e | on_page(e, 'down') }
+    @scroll_win.evt_scrollwin_pageup() { | e | on_page(e, 'up') }
+
+    # not sure how these are meant to be generated
+    @scroll_win.evt_scrollwin_top() { | e | on_top(e) }
+    @scroll_win.evt_scrollwin_bottom() { | e | on_bottom(e) }
+    @scroll_win.evt_scrollwin { | e | p e }
+  end
+  
+  # Handle scrolling by page - typically done by clicking on the
+  # scrollbar itself, above or below the thumb position
+  # +direction+ is either 'up' (= left, if dealing with a horizontal
+  # scrollbar) or 'down' (= right) - WxRuby generates different events
+  # for these.
+  def on_page(event, direction)
+    pos = event.get_position
+    orient = event.get_orientation == Wx::VERTICAL ? 'VERTICAL' : 'HORIZONTAL'
+    puts "#{orient} scrollbar page #{direction} @ #{pos}"
+    event.skip() # allow default scrolling action
+  end
+
+  
+  # Handle scrolling by line - typically done by clicking the up/down
+  # (or left/right) scroll buttons at the end of the scrollbar.
+  # +direction+ is either 'up' (= left, if dealing with a horizontal
+  # scrollbar) or 'down' (= right)
+  def on_line(event, direction)
+    orient = event.get_orientation == Wx::VERTICAL ? 'VERTICAL' : 'HORIZONTAL'
+    pos = event.get_position
+    puts "#{orient} scrollbar line #{direction} @ #{pos}"
+    event.skip() # allow default action
+  end
+
+  # Handle scrolling done by click-dragging the 'thumb' within a scrollbar.
+  # +action+ contains either 'track' for thumbtrack drag events, or 'release'
+  # for thumb-release
+  def on_thumb(event, action)
+    pos = event.get_position
+    if event.get_orientation == Wx::VERTICAL
+      puts "VERTICAL thumb #{action} @ #{pos}"
+    else
+      puts "HORIZONTAL thumb #{action} @ #{pos}"
+    end
+    event.skip()
+  end
+
+  # (Assuming this should be triggered when the End key is pressed)?
+  def on_bottom(event)
+    puts "bottom"
+  end
+  
+
+  #  (Assuming this should be triggered when the Home/Begin key is pressed)?
+  def on_top(event)
+    puts "top"
+  end
+
+end
+
+class ScrollingApp < Wx::App
+  def on_init
+    frame = ScrollFrame.new('')
+    frame.show(TRUE)
+  end
+end
+
+app = ScrollingApp.new
+app.main_loop()
+

data/samples/etc/system_settings.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# This example lists the various system settings that WxRuby knows
+# about. To use it, run it and use the 'View' menu to list the different
+# groups of settings available.
+
+# A class to display system settings in a spreadsheet-like table.
+class SystemSettingsTable < Wx::Grid
+  def initialize(parent)
+    super(parent, -1)
+    max_length = [ COLOURS.length, FONTS.length, METRICS.length ].max
+    create_grid( max_length, 3)
+
+    set_row_label_size(0)
+    set_row_label_alignment(Wx::ALIGN_RIGHT, Wx::ALIGN_CENTRE)
+
+    set_col_label_value(0, 'Name')
+    set_col_size(0, 200)
+    set_col_label_value(1, 'Value')
+    set_col_size(1, 100)
+    set_col_label_value(2, 'Description')
+    set_col_size(2, 300)
+  end
+
+  # blank out all row labels from +from_row+ to the end of the grid.
+  def tidy_row_labels(from_row = 0)
+    from_row.upto( get_number_rows - 1 ) do | row |
+      set_row_label_value(row, '')
+    end
+  end
+
+  # display a settings constant name +const+, its value +value+ and a
+  # text description +desc+ of that setting in the row +row+
+  def list(row, const, val, desc)
+    set_cell_value(row, 0, const)
+    set_cell_value(row, 1, val.to_s() )
+    set_cell_value(row, 2, desc)
+  end
+
+  # List the elements of the system's colour scheme, giving each one's
+  # Wx constant name, its RGB value in hex, and the description of how it
+  # is used.
+  def list_colours
+    clear_grid()
+    COLOURS.each_with_index do | item, i |
+      constant_name, description = *item
+      const = Wx::const_get(constant_name)
+      # obtain a Wx::Colour object for the named constantb
+      colour  = Wx::SystemSettings.get_colour(const)
+      colour_hex = '#%02X%02X%02X' % 
+                [ colour.red, colour.green, colour.blue ]
+      list( i, constant_name, colour_hex, description )
+    end
+    tidy_row_labels(COLOURS.length)
+  end
+
+  # List the standard system fonts, giving each one's Wx contant name,
+  # the font's platform descriptor, and a description of its use.
+  def list_fonts
+    clear_grid()
+    FONTS.each_with_index do | item, i |
+      constant_name, description = *item
+      const = Wx::const_get(constant_name)
+      # obtain a standard system font
+      font  = Wx::SystemSettings.get_font(const)
+      font_desc = "%s %ipt" % 
+                             [ font.get_face_name, font.get_point_size ]
+      list( i, constant_name, font_desc, description )
+    end
+    tidy_row_labels(FONTS.length)
+  end
+
+  # List various standard measurements of GUI elements and areas, such as
+  # the size of the screen, cursor, icons and window borders. For each
+  # one, the WxRuby constant name, the value (usually in pixels), and a
+  # short description of its use is given.
+  # 
+  # Not all metrics are implemented in Wx on all platforms; undefined
+  # values are shown as '-1'.
+  def list_metrics
+    clear_grid()
+    METRICS.each_with_index do | item, i |
+      constant_name, description = *item
+      const = Wx::const_get(constant_name)
+      # obtain a standard system metric
+      metric = Wx::SystemSettings.get_metric(const)
+      list( i, constant_name, metric, description )
+    end
+    tidy_row_labels(METRICS.length)
+  end
+
+  # copied from WxWidgets 2.6.2 documentation
+  COLOURS = [
+    [ 'SYS_COLOUR_SCROLLBAR', 'The scrollbar grey area.' ],
+    [ 'SYS_COLOUR_BACKGROUND', 'The desktop colour.' ],
+    [ 'SYS_COLOUR_ACTIVECAPTION', 'Active window caption.' ],
+    [ 'SYS_COLOUR_INACTIVECAPTION', 'Inactive window caption.' ],
+    [ 'SYS_COLOUR_MENU', 'Menu background.' ],
+    [ 'SYS_COLOUR_WINDOW', 'Window background.' ],
+    [ 'SYS_COLOUR_WINDOWFRAME', 'Window frame.' ],
+    [ 'SYS_COLOUR_MENUTEXT', 'Menu text.' ],
+    [ 'SYS_COLOUR_WINDOWTEXT', 'Text in windows.' ],
+    [ 'SYS_COLOUR_CAPTIONTEXT', 'Text in caption, size box and scrollbar arrow box.' ],
+    [ 'SYS_COLOUR_ACTIVEBORDER', 'Active window border.' ],
+    [ 'SYS_COLOUR_INACTIVEBORDER', 'Inactive window border.' ],
+    [ 'SYS_COLOUR_APPWORKSPACE', 'Background colour MDI applications.' ],
+    [ 'SYS_COLOUR_HIGHLIGHT', 'Item(s) selected in a control.' ],
+    [ 'SYS_COLOUR_HIGHLIGHTTEXT', 'Text of item(s) selected in a control.' ],
+    [ 'SYS_COLOUR_BTNFACE', 'Face shading on push buttons.' ],
+    [ 'SYS_COLOUR_BTNSHADOW', 'Edge shading on push buttons.' ],
+    [ 'SYS_COLOUR_GRAYTEXT', 'Greyed (disabled) text.' ],
+    [ 'SYS_COLOUR_BTNTEXT', 'Text on push buttons.' ],
+    [ 'SYS_COLOUR_INACTIVECAPTIONTEXT', 'Colour of text in active captions.' ],
+    [ 'SYS_COLOUR_BTNHIGHLIGHT', 'Highlight colour for buttons (same as wxSYS_COLOUR_3DHILIGHT).' ],
+    [ 'SYS_COLOUR_3DDKSHADOW', 'Dark shadow for three-dimensional display elements.' ],
+    [ 'SYS_COLOUR_3DLIGHT', 'Light colour for three-dimensional display elements.' ],
+    [ 'SYS_COLOUR_INFOTEXT', 'Text colour for tooltip controls.' ],
+    [ 'SYS_COLOUR_INFOBK', 'Background colour for tooltip controls.' ],
+    [ 'SYS_COLOUR_DESKTOP', 'Same as wxSYS_COLOUR_BACKGROUND.' ],
+    [ 'SYS_COLOUR_3DFACE', 'Same as wxSYS_COLOUR_BTNFACE.' ],
+    [ 'SYS_COLOUR_3DSHADOW', 'Same as wxSYS_COLOUR_BTNSHADOW.' ],
+    [ 'SYS_COLOUR_3DHIGHLIGHT', 'Same as wxSYS_COLOUR_BTNHIGHLIGHT.' ],
+    [ 'SYS_COLOUR_3DHILIGHT', 'Same as wxSYS_COLOUR_BTNHIGHLIGHT.' ],
+    [ 'SYS_COLOUR_BTNHILIGHT', 'Same as wxSYS_COLOUR_BTNHIGHLIGHT.' ]
+  ]
+
+  # copied from WxWidgets 2.6.2 documentation
+  FONTS = [
+    [ 'SYS_OEM_FIXED_FONT', 'Original equipment manufacturer dependent fixed-pitch font.' ],
+    [ 'SYS_ANSI_FIXED_FONT', 'Windows fixed-pitch font.' ],
+    [ 'SYS_ANSI_VAR_FONT', 'Windows variable-pitch (proportional) font.' ],
+    [ 'SYS_SYSTEM_FONT', 'System font.' ],
+    [ 'SYS_DEVICE_DEFAULT_FONT', 'Device-dependent font (Windows NT only).' ],
+    [ 'SYS_DEFAULT_GUI_FONT', 'Default font for user interface objects such as menus and dialog boxes.' ]
+  ]
+
+  # copied from WxWidgets 2.6.2 documentation
+  METRICS = [
+    [ 'SYS_MOUSE_BUTTONS', 'Number of buttons on mouse, or zero if no mouse was installed.' ],
+    [ 'SYS_BORDER_X', 'Width of single border.' ],
+    [ 'SYS_BORDER_Y', 'Height of single border.' ],
+    [ 'SYS_CURSOR_X', 'Width of cursor.' ],
+    [ 'SYS_CURSOR_Y', 'Height of cursor.' ],
+    [ 'SYS_DCLICK_X', 'Width in pixels of rectangle within which two successive mouse clicks must fall to generate a double-click.' ],
+    [ 'SYS_DCLICK_Y', 'Height in pixels of rectangle within which two successive mouse clicks must fall to generate a double-click.' ],
+    [ 'SYS_DRAG_X', 'Width in pixels of a rectangle centered on a drag point to allow for limited movement of the mouse pointer before a drag operation begins.' ],
+    [ 'SYS_DRAG_Y', 'Height in pixels of a rectangle centered on a drag point to allow for limited movement of the mouse pointer before a drag operation begins.' ],
+    [ 'SYS_EDGE_X', 'Width of a 3D border, in pixels.' ],
+    [ 'SYS_EDGE_Y', 'Height of a 3D border, in pixels.' ],
+    [ 'SYS_HSCROLL_ARROW_X', 'Width of arrow bitmap on horizontal scrollbar.' ],
+    [ 'SYS_HSCROLL_ARROW_Y', 'Height of arrow bitmap on horizontal scrollbar.' ],
+    [ 'SYS_HTHUMB_X', 'Width of horizontal scrollbar thumb.' ],
+    [ 'SYS_ICON_X', 'The default width of an icon.' ],
+    [ 'SYS_ICON_Y', 'The default height of an icon.' ],
+    [ 'SYS_ICONSPACING_X', 'Width of a grid cell for items in large icon view, in pixels. Each item fits into a rectangle of this size when arranged.' ],
+    [ 'SYS_ICONSPACING_Y', 'Height of a grid cell for items in large icon view, in pixels. Each item fits into a rectangle of this size when arranged.' ],
+    [ 'SYS_WINDOWMIN_X', 'Minimum width of a window.' ],
+    [ 'SYS_WINDOWMIN_Y', 'Minimum height of a window.' ],
+    [ 'SYS_SCREEN_X', 'Width of the screen in pixels.' ],
+    [ 'SYS_SCREEN_Y', 'Height of the screen in pixels.' ],
+    [ 'SYS_FRAMESIZE_X', 'Width of the window frame for a wxTHICK_FRAME window.' ],
+    [ 'SYS_FRAMESIZE_Y', 'Height of the window frame for a wxTHICK_FRAME window.' ],
+    [ 'SYS_SMALLICON_X', 'Recommended width of a small icon (in window captions, and small icon view).' ],
+    [ 'SYS_SMALLICON_Y', 'Recommended height of a small icon (in window captions, and small icon view).' ],
+    [ 'SYS_HSCROLL_Y', 'Height of horizontal scrollbar in pixels.' ],
+    [ 'SYS_VSCROLL_X', 'Width of vertical scrollbar in pixels.' ],
+    [ 'SYS_VSCROLL_ARROW_X', 'Width of arrow bitmap on a vertical scrollbar.' ],
+    [ 'SYS_VSCROLL_ARROW_Y', 'Height of arrow bitmap on a vertical scrollbar.' ],
+    [ 'SYS_VTHUMB_Y', 'Height of vertical scrollbar thumb.' ],
+    [ 'SYS_CAPTION_Y', 'Height of normal caption area.' ],
+    [ 'SYS_MENU_Y', 'Height of single-line menu bar.' ],
+    [ 'SYS_NETWORK_PRESENT', '1 if there is a network present, 0 otherwise.' ],
+    [ 'SYS_PENWINDOWS_PRESENT', '1 if PenWindows is installed, 0 otherwise.' ],
+    [ 'SYS_SHOW_SOUNDS', 'Non-zero if the user requires an application to present information visually in situations where it would otherwise present the information only in audible form; zero otherwise.' ],
+    [ 'SYS_SWAP_BUTTONS', 'Non-zero if the meanings of the left and right mouse buttons are swapped; zero otherwise.' ]
+  ]
+end
+
+
+# A simple frame that just shows a table with the System Settings in it.
+class SettingsFrame < Wx::Frame
+
+  def initialize(title, pos = Wx::DEFAULT_POSITION, size = Wx::DEFAULT_SIZE)
+    super(nil, -1, title, pos, size)
+    sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
+    @table = SystemSettingsTable.new(self)
+    sizer.add(@table, 1, Wx::ADJUST_MINSIZE|Wx::GROW|Wx::ALL, 2)
+    self.set_sizer(sizer)
+    construct_menus()
+    @table.list_colours()
+  end
+
+  ID_SHOW_COLOURS = 1
+  ID_SHOW_FONTS   = 2
+  ID_SHOW_METRICS = 3
+  def construct_menus()
+    menu_bar = Wx::MenuBar.new()
+
+    menu_file = Wx::Menu.new()
+    menu_file.append(Wx::ID_EXIT, "E&xit\tAlt-X", "Quit this program")
+    menu_bar.append(menu_file, "&File")
+    evt_menu(Wx::ID_EXIT) { on_quit() }
+
+    menu_view = Wx::Menu.new()
+    menu_view.append(ID_SHOW_COLOURS, 
+                     "Show &Colours", "Show system colours")
+    evt_menu(ID_SHOW_COLOURS) { @table.list_colours() }
+    menu_view.append(ID_SHOW_FONTS, 
+                     "Show &Fonts", "Show system fonts")
+    evt_menu(ID_SHOW_FONTS) { @table.list_fonts() }
+    menu_view.append(ID_SHOW_METRICS, 
+                     "Show &Metrics", "Show system metrics")
+    evt_menu(ID_SHOW_METRICS) { @table.list_metrics() }
+    menu_bar.append(menu_view, "&View")
+
+    menu_help = Wx::Menu.new()
+    menu_help.append(Wx::ID_ABOUT, "&About...\tF1", "Show about dialog")
+    evt_menu(Wx::ID_ABOUT) { on_about() }
+    menu_bar.append(menu_help, "&Help")
+
+    set_menu_bar(menu_bar)
+  end
+
+  def on_quit()
+    close(TRUE)
+  end
+
+  def on_about()
+    msg =  sprintf("This is the About dialog of the minimal sample.\n" \
+                    "Welcome to %s", Wx::VERSION_STRING)
+    Wx::message_box(msg, "About Minimal", Wx::OK|Wx::ICON_INFORMATION, self)
+  end
+end
+
+class MyApp < Wx::App
+  def on_init()
+    frame = SettingsFrame.new("System Settings", 
+                        Wx::DEFAULT_POSITION,
+                        Wx::Size.new(600, 400) )
+    frame.show(TRUE)
+  end
+end
+
+# run the app
+MyApp.new.main_loop()

data/samples/etc/threaded.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# This simple sample demonstrates how to use Ruby 1.8's lightweight
+# (green) threads to execute non-GUI code in parallel with a wxRuby
+# GUI. This strategy is useful in a number of situations:
+# 
+# * To keep the GUI responsive whilst computationally intensive
+#   operations are carried out in the background
+# * To keep the GUI responsive while waiting for networking operations
+#   to complete 
+# 
+# The basic problem is that, as with other Ruby GUI toolkits, non-GUI
+# threads will not, by default, get allocated time to run while Ruby is
+# busy in Wx code - the main wxRuby event loop. Strategies to deal with
+# this include using non-blocking IO, and, more generically, using
+# wxRuby's Timer class to explicitly allocate time for non-GUI threads
+# to run. The latter technique is shown here.
+
+# This frame shows a set of progress bars which monitor progress of
+# long-running tasks. In this example, this long-running task is
+# emulated by simply sleep-ing for random periods, but could equally be
+# downloading from a socket or parsing a file.
+class ProgressFrame < Wx::Frame
+  STEPS = 20
+  def initialize
+    super(nil, :title => 'Threading demo')
+    @gauges = []
+    panel = Wx::Panel.new(self)
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    # show ten gauges
+    10.times do 
+      gauge = Wx::Gauge.new(panel, :range => STEPS)
+      # For each gauge, start a new thread in which the task runs
+      Thread.new do 
+        # The long-running task
+        STEPS.times do | i |
+          sleep rand(100) / 50.0
+          # Update the main GUI
+          gauge.value = i + 1
+        end
+      end
+      @gauges << gauge
+      sizer.add(gauge, 0, Wx::GROW|Wx::ALL, 2)
+    end
+    panel.sizer = sizer
+    sizer.fit(panel)
+  end
+end
+
+# This app class creates a frame, and, importantly, a timer to allow
+class GaugeApp < Wx::App
+  # Get a guaranteed-unique id
+  THREAD_TIMER_ID = Wx::ID_HIGHEST + 1
+  def on_init
+    # Create a global application timer that passes control to other
+    # ruby threads. The timer will run every 1/40 second (25ms). Higher
+    # values will make the other threads run more often, but will
+    # eventually degrade the responsiveness of the GUI.
+    Wx::Timer.every(25) { Thread.pass }
+    prog = ProgressFrame.new
+    prog.show
+  end
+end
+
+GaugeApp.new.main_loop

data/samples/etc/wizard.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+
+class MyFrame < Wx::Frame
+  def initialize(title, pos, size)
+    super(nil, :title => title, :position => pos, :size => size)
+
+    menuFile = Wx::Menu.new
+    helpMenu = Wx::Menu.new
+    helpMenu.append(Wx::ID_ABOUT, "&About...\tF1", "Show about dialog")
+    menuFile.append(Wx::ID_EXIT, "E&xit\tAlt-X", "Quit this program")
+    menuBar = Wx::MenuBar.new
+    menuBar.append(menuFile, "&File")
+    menuBar.append(helpMenu, "&Help")
+    self.menu_bar = menuBar
+
+    create_status_bar(1)
+    self.status_text = "Welcome to wxRuby!"
+    s = Wx::StaticText.new(self, :label => 'The Wizard has completed')
+    evt_menu Wx::ID_EXIT, :on_quit
+    evt_menu Wx::ID_ABOUT, :on_about
+
+    w = Wx::Wizard.new(self, :title => 'The WxRuby Wizard')
+    p1 = Wx::WizardPageSimple.new(w)
+    s = Wx::StaticText.new(p1, :label => 'This is the first page')
+
+    p2 = Wx::WizardPageSimple.new(w, p1)
+    p1.set_next(p2)
+    s = Wx::StaticText.new(p2, :label => 'This is the second page')
+
+    p3 = Wx::WizardPageSimple.new(w, p2)
+    p2.set_next(p3)
+    s = Wx::StaticText.new(p3, :label => 'This is the final page')
+
+    evt_wizard_page_changed(w) { p "page changed" }
+    evt_wizard_page_changing(w) { p "page changing" }
+    evt_wizard_help(w) { p "wizard help" }
+    evt_wizard_cancel(w) { p "wizard cancelled" }
+    evt_wizard_finished(w) { p "wizard finished" }
+
+    w.run_wizard(p1)
+  end
+
+  def on_quit
+    close(true)
+  end
+
+  def on_about
+    msg =  sprintf("This is the About dialog of the wizard sample.\n" \
+                    "Welcome to %s", Wx::VERSION_STRING)
+    Wx::message_box(msg, "About Wizard", Wx::OK|Wx::ICON_INFORMATION, self)
+  end
+end
+
+class RbApp < Wx::App
+  def on_init
+    frame = MyFrame.new("Wizard wxRuby App",
+                        Wx::Point.new(50, 50), 
+                        Wx::Size.new(450, 340))
+    frame.show(true)
+
+  end
+end
+
+app = RbApp.new
+app.main_loop()
+

data/samples/event/event.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# This sample demonstrates how to dynamically connect and disconnect
+# event handlers, and how to create custom event types and listeners
+# associated with user-defined control classes.
+
+# A custom type of event associated with a target control. Note that for
+# user-defined controls, the associated event should inherit from
+# Wx::CommandEvent rather than Wx::Event.
+class TargetHitEvent < Wx::CommandEvent
+  # Create a new unique constant identifier, associate this class
+  # with events of that identifier, and create a shortcut 'evt_target'
+  # method for setting up this handler.
+  EVT_HIT_TARGET = Wx::EvtHandler.register_class(self, nil, 'evt_target', 1) 
+  
+  def initialize(target, score, distance)
+    # The constant id is the arg to super
+    super(EVT_HIT_TARGET)
+    # client_data should be used to store any information associated
+    # with the event.
+    self.client_data = { :score => score, :distance => distance  }
+    self.id = target.get_id
+  end
+
+  # Returns the points score associated with this event
+  def score
+    client_data[:score]
+  end
+
+  # Returns the distance (in pixels) from the centre of the target
+  def distance
+    client_data[:distance]
+  end
+end
+
+# An example of a simple user-written control, which displays a
+# "bulls-eye" like target, and sends events with a score and distance 
+class TargetControl < Wx::Window
+  TargetCircle = Struct.new(:radius, :score, :brush)
+
+  def initialize(parent, *args)
+    super(parent, *args)
+
+    # Set up the scores and sizes of the rings
+    @radii = [
+      TargetCircle[ 0.1, 20, Wx::RED_BRUSH ],
+      TargetCircle[ 0.25, 10, Wx::BLUE_BRUSH ],
+      TargetCircle[ 0.4, 5, Wx::GREEN_BRUSH ] ]
+    evt_paint { | e | on_paint(e) }
+    evt_left_down { | e | on_left_down(e) }
+  end
+
+  # What point is at the centre (assuming this control is always square)
+  def centre_point
+    size.width / 2
+  end
+
+  # Called whenever the target is repainted, draws a series of
+  # concentric circles
+  def on_paint(evt)
+    paint do | dc |
+      dc.clear
+      @radii.reverse_each do | circ |
+        dc.brush = circ.brush
+        dc.draw_circle(centre_point, centre_point, 
+                       ( size.width * circ.radius).to_i )
+      end
+    end
+  end
+
+  # Test if the target was hit, and generate a TargetHitEvent if so
+  def on_left_down(evt)
+    # quick bit of pythagoras...
+    distance = Math.sqrt( ( evt.x - centre_point ) ** 2  + 
+                          ( evt.y - centre_point ) ** 2 )
+    # See which target ring, if any, was hit by the event
+    @radii.each do | circ | 
+      if distance < ( size.width * circ.radius)
+        # Create an instance of the event
+        evt = TargetHitEvent.new(self, circ.score, distance)
+        # This sends the event for processing by listeners
+        event_handler.process_event(evt)
+        break
+      end
+    end
+  end
+end
+
+# Container frame for the target control
+class TargetFrame < Wx::Frame
+  def initialize(title)
+    super(nil, :title => title, :size => [300, 300])
+    @tgt = TargetControl.new(self)
+    # This user-defined event handling method was set up by
+    # EvtHandler.register_class, above
+    evt_target(@tgt.get_id) { | e | on_target(e) }
+    @listening = true
+    evt_size { | e | on_size(e) }
+    setup_menus
+    create_status_bar
+  end
+
+  # What's done when the target is hit
+  def on_target(evt)
+    msg = "Target hit for score %i, %.2f pixels from centre" % 
+          [ evt.score, evt.distance ]
+    self.status_text = msg
+  end
+
+  # Keep the target centred and square
+  def on_size(evt)
+    smaller = [ evt.size.width, evt.size.height ].min
+    @tgt.centre
+    @tgt.size = Wx::Size.new(smaller, smaller)
+    @tgt.refresh
+  end
+  
+  # Toggle whether or not we are listening for events from the bulls-eye
+  # target
+  def on_toggle_connect
+    if @listening
+      # Remove :evt_target event handler for the @tgt
+      disconnect(@tgt.get_id, Wx::ID_ANY, :evt_target)
+      menu_bar.check(TOGGLE_LISTEN, false)
+      self.status_text = "Ignoring target events"
+      @listening = false
+    else
+      # Restore evt_target event handler for the @tgt
+      evt_target(@tgt.get_id) { | e | on_target(e) }
+      menu_bar.check(TOGGLE_LISTEN, true)
+      self.status_text = ''
+      @listening = true
+    end
+  end
+
+  def on_about
+    msg =  sprintf("This is the About dialog of the event handling sample.\n" \
+                   "Welcome to wxRuby, version %s", Wx::WXRUBY_VERSION)
+
+    about_dlg = Wx::MessageDialog.new( self, msg, 'About Event Handling',
+                                       Wx::OK|Wx::ICON_INFORMATION )
+    about_dlg.show_modal
+
+  end
+
+  TOGGLE_LISTEN = 1001
+  def setup_menus
+    menu_file = Wx::Menu.new
+    menu_help = Wx::Menu.new
+    menu_help.append(Wx::ID_ABOUT, "&About...\tF1", "Show about dialog")
+    evt_menu(Wx::ID_ABOUT) { on_about }
+    menu_file.append(Wx::ID_EXIT, "E&xit\tAlt-X", "Quit this program")
+    evt_menu(Wx::ID_EXIT) { self.close }
+    menu_file.append_check_item(TOGGLE_LISTEN, "L&isten for events", 
+                                 "Toggle listening for target events")
+    evt_menu(TOGGLE_LISTEN) { on_toggle_connect }
+
+    menu_bar = Wx::MenuBar.new
+    menu_bar.append(menu_file, "&File")
+    menu_bar.append(menu_help, "&Help")
+
+    self.menu_bar = menu_bar
+    menu_bar.check(TOGGLE_LISTEN, true)
+  end
+end
+
+class TargetApp < Wx::App
+  def on_init
+    TargetFrame.new("Event Handling Sample").show
+    return true
+  end
+end
+
+a = TargetApp.new
+a.main_loop()