wxruby 1.9.3-universal-darwin

data/samples/etc/threaded.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2006 Kevin B. Smith
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+begin
+  require 'wx'
+rescue LoadError => no_wx_err
+  begin
+    require 'rubygems'
+    require 'wx'
+  rescue LoadError
+    raise no_wx_err
+  end
+end
+
+# 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 
+    t = Wx::Timer.new(self, THREAD_TIMER_ID)
+    # When the timer "ticks", switch control to other ruby threads
+    evt_timer(THREAD_TIMER_ID) { Thread.pass }
+    # Start the timer to 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.
+    t.start(25)
+    prog = ProgressFrame.new
+    prog.show
+  end
+end
+
+GaugeApp.new.main_loop

data/samples/etc/wizard.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2006 Kevin B. Smith
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+begin
+  require 'wx'
+rescue LoadError => no_wx_err
+  begin
+    require 'rubygems'
+    require 'wx'
+  rescue LoadError
+    raise no_wx_err
+  end
+end
+
+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,184 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2007 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+begin
+  require 'rubygems'
+  require 'wx'
+rescue LoadError
+  require 'wx'
+end
+
+# 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()

data/samples/grid/grid.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+begin
+  require 'wx'
+rescue LoadError => no_wx_err
+  begin
+    require 'rubygems' 
+    load 'wx'
+  rescue
+    raise no_wx_err
+  end
+end
+
+
+class GridFrame < Wx::Frame
+
+  def initialize(parent, id = -1, title = "MyFrame", 
+                  pos   = Wx::DEFAULT_POSITION,
+                  size  = Wx::DEFAULT_SIZE,
+                  style = Wx::DEFAULT_FRAME_STYLE)
+
+    super(parent, id, title, pos, size, style)
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    create_status_bar()
+    set_status_text(Wx::VERSION_STRING)
+
+    # panel = Wx::Panel.new(self)
+    sel_menu = Wx::Menu.new
+    sel_menu.append(1002, 'Select all', 'Select all')
+    evt_menu(1002) { @grid.select_all }
+    sel_menu.append(1003, 'Select row 2', 'Select row 2')
+    evt_menu(1003) { @grid.select_row(1) }
+    sel_menu.append(1004, 'Select column 4', 'Select col 4')
+    evt_menu(1004) { @grid.select_col(3) }
+    sel_menu.append(1005, 'Select block', 'Select block')
+    evt_menu(1005) { @grid.select_block(1, 1, 6, 3) }
+    menu_bar = Wx::MenuBar.new
+    menu_bar.append(sel_menu, 'Select')
+    set_menu_bar(menu_bar)
+
+    make_grid(self)
+    sizer.add(@grid, 1, Wx::ALL|Wx::GROW, 4)
+    set_sizer(sizer)
+
+    evt_grid_cell_left_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_right_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is right clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_left_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is double clicked")
+      evt.skip
+    end 
+
+    evt_grid_cell_right_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} is right double clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_left_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_right_click() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is right clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_left_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} labelis double clicked")
+      evt.skip
+    end 
+
+    evt_grid_label_right_dclick() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} label is right double clicked")
+      evt.skip
+    end 
+
+    evt_grid_select_cell() do |evt|
+      set_status_text("#{evt.get_row} x #{evt.get_col} cell is selected")
+      evt.skip
+    end
+    
+    evt_grid_row_size do |evt|
+      set_status_text("Row #{evt.get_row_or_col} size changed")
+      evt.skip
+    end
+
+    evt_grid_col_size do |evt|
+      set_status_text("Column #{evt.get_row_or_col} size changed")
+      evt.skip
+    end
+
+    evt_grid_editor_shown do |evt|
+      set_status_text("Begin editing")
+      evt.skip
+    end
+
+    evt_grid_editor_hidden do |evt|
+      set_status_text("End editing")
+      evt.skip
+    end
+
+    evt_grid_range_select do |evt|
+      top = evt.get_top_left_coords
+      bottom = evt.get_bottom_right_coords
+      set_status_text("[ #{top[0].to_s} x #{top[1].to_s} ] to [ #{bottom[0].to_s} x #{bottom[1].to_s} ] is selected")
+    end 
+
+    evt_grid_editor_created do |evt|
+      set_status_text("Control #{evt.get_control} created")
+      evt.skip
+    end
+
+    evt_grid_cell_change() do |evt|
+      set_status_text("Cell #{evt.get_row} x #{evt.get_col} has changed")
+    end
+  end
+
+  # Create a wxGrid object
+  def make_grid(panel)
+    @grid = Wx::Grid.new(panel, -1)
+
+    # Then we call CreateGrid to set the dimensions of the grid
+    # (11 rows and 12 columns in this example)
+    @grid.create_grid( 20, 12 )
+    @grid.set_default_cell_background_colour(Wx::WHITE)
+    # We can set the sizes of individual rows and columns
+    # in pixels, and the label value string
+    @grid.set_row_size( 0, 60 )
+    @grid.set_row_label_value( 0, "Row1" )
+    @grid.set_row_label_alignment(Wx::ALIGN_CENTRE, Wx::ALIGN_CENTRE)
+    
+    @grid.set_col_size( 0, 120 )
+    @grid.set_col_label_value( 0, "Col1" )
+    @grid.set_col_label_alignment(Wx::ALIGN_CENTRE, Wx::ALIGN_CENTRE)
+    
+    # And set grid cell contents as strings
+    @grid.set_cell_value( 0, 0, "wxGrid is good" )
+
+    # We can specify that some cells are read-only
+    @grid.set_cell_value( 0, 2, "Read-only" )
+    @grid.set_read_only( 0, 2 )
+
+    # Colours can be specified for grid cell contents
+    @grid.set_cell_value(1, 1, "white on red")
+    @grid.set_cell_text_colour(1, 1, Wx::WHITE)
+    @grid.set_cell_background_colour(1, 1, Wx::RED)
+
+    # We can specify the some cells will store numeric 
+    # values rather than strings. Here we set grid column 6 
+    # to hold floating point values displayed with width 
+    # of 2 and precision of 2. The column is highlighted in light grey
+    cell_attr = Wx::GridCellAttr.new
+    cell_attr.set_background_colour( Wx::LIGHT_GREY )
+    cell_attr.set_renderer( Wx::GridCellFloatRenderer.new(2, 2) )
+
+    @grid.set_col_attr(5, cell_attr)
+    @grid.set_cell_value(0, 5, "3.1415")
+    @grid.set_cell_value(0, 6, 
+                         "The whole column to the left uses float format")
+    
+    # Custom Editors Can be used
+    editor = Wx::GridCellNumberEditor.new(5, 20)
+    @grid.set_cell_value(3, 1, 'Number editor below')
+    @grid.set_cell_editor(4, 1, editor)
+
+    editor = Wx::GridCellFloatEditor.new(4, 2)
+    @grid.set_cell_value(3, 2, 'Float editor below')
+    @grid.set_cell_editor(4, 2, editor)
+
+    editor = Wx::GridCellChoiceEditor.new(['foo', 'bar', 'baz'])
+    @grid.set_cell_value(3, 3, 'Choice editor below')
+    @grid.set_cell_editor(4, 3, editor)
+
+    @grid.auto_size_row(3, true)
+
+    # Display of cells can be customised
+    @grid.set_cell_editor(6, 0, Wx::GridCellBoolEditor.new)
+    @grid.set_cell_renderer(6, 0, Wx::GridCellBoolRenderer.new)
+    @grid.set_cell_value(6, 1, 'Cell to the left displayed as boolean')
+  end
+  
+end
+
+class GridApp < Wx::App
+  def on_init
+    frame = GridFrame.new(nil, -1, "Grid Sample",
+                         Wx::Point.new(10, 100),
+                         Wx::Size.new(630,400))
+
+    set_top_window(frame)
+    frame.show()
+  end
+end
+
+GridApp.new.main_loop()