wxruby-ruby19 1.9.10-x86-mingw32

data/samples/etc/toolbar_sizer_additem.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+require 'rubygems' rescue LoadError
+
+require 'wx'
+
+# Simple test application for keyword arguments to Sizer#add_item and
+# ToolBar#add_item. Originally contributed by Chauk-Mean P
+
+Wx::App.run do
+  frame = Wx::Frame.new( nil, 
+                         :title => 'ToolBar and Sizer API enhancements') do
+    
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    
+    button1 = Wx::Button.new(self, :label => 'Button 1')
+    button2 = Wx::Button.new(self, :label => 'Button 2')
+    button3 = Wx::Button.new(self, :label => 'Button 3')
+
+    # Sizer#add_item usage
+    # use of positional arguments
+    sizer.add_item(button1, -1, 1, Wx::EXPAND)
+    # use of a spacer
+    sizer.add_item([20, 15])
+    # use of keyword arguments without index
+    sizer.add_item(button3, :proportion => 1, :flag => Wx::EXPAND)
+    # use of keyword arguments with index specified
+    sizer.add_item(button2, :index => 1, :proportion => 1, :flag => Wx::EXPAND)
+    self.sizer = sizer
+
+    # ToolBar#add_item usage
+    toolbar = create_tool_bar( Wx::TB_HORIZONTAL|Wx::TB_FLAT )
+    # provide only a bitmap
+    new_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_NEW) )
+    # use of keyword arguments without pos
+    save_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_FILE_SAVE), 
+                                     :short_help => "Save")
+    # use of keyword arguments with pos
+    open_item_id = toolbar.add_item( Wx::ArtProvider.bitmap(Wx::ART_FILE_OPEN), 
+                                     :position => 1, 
+                                     :short_help => "Open")
+    toolbar.realize
+    
+    # tool item event handling
+    evt_tool new_item_id do
+      Wx::message_box "New clicked"
+    end
+    
+  end
+
+  frame.show
+end
+

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()

data/samples/event/update_ui_event.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+begin
+  require 'rubygems' 
+rescue LoadError
+end
+require 'wx'
+
+# Demonstrating the use of evt_update_ui to keep menu items and controls
+# in sync in being enabled/disabled, checked/unchecked.
+# 
+# evt_update_ui is called repeatedly whenever the item is (or is about
+# to become) visible; by calling methods on the passed event object, the
+# state of the control is updated. For complex applications, this can be
+# a lot simpler (less code, more reliable) than having to remember to
+# update all the relevant controls and items whenever the state changes.
+#
+# In the example below, the application is globally in edit mode. This
+# mode can be changed either from a menu item, or via a
+# checkbox. Whichever is used to change, the state of the other should
+# be kept in sync
+class UpdateUIFrame < Wx::Frame
+  def initialize
+    super(nil, :title => 'Update UI example', :size => [ 400, 300 ])
+    @edit_mode = false
+
+    # First, set up the menus
+    self.menu_bar = Wx::MenuBar.new
+    menu_edit = Wx::Menu.new
+
+    # Toggle case-change menu item
+    menu_edit.append_check_item(Wx::ID_EDIT, 'Allow case change')
+    # When the item is called, toggle edit mode
+    evt_menu(Wx::ID_EDIT) { @edit_mode = ! @edit_mode }
+    # Give the menu item a check or not, depending on mode
+    evt_update_ui(Wx::ID_EDIT) { | evt | evt.check(@edit_mode) }
+
+    # Upcase menu item
+    up_case = menu_edit.append('Upper case')
+    evt_menu(up_case) { @txt.value = @txt.value.upcase }
+    evt_update_ui(up_case) { | evt | evt.enable(@edit_mode) }
+
+    # Lowercase menu item
+    up_case = menu_edit.append('Lower case')
+    evt_menu(up_case) { @txt.value = @txt.value.downcase }
+    evt_update_ui(up_case) { | evt | evt.enable(@edit_mode) }
+
+    menu_bar.append(menu_edit, "&Edit")
+
+    # Second, the frame contents
+    self.sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+
+    # A text control
+    @txt = Wx::TextCtrl.new( self, 
+                             :value => 'Welcome to wxRuby',
+                             :style => Wx::TE_MULTILINE )
+    sizer.add(@txt, 1, Wx::GROW|Wx::ALL, 5)
+
+    # A checkbox, use the Wx::ID_EDIT id to share evt code with the
+    # corresponding menu item
+    @cbx = Wx::CheckBox.new( self, 
+                             :id => Wx::ID_EDIT, 
+                             :label => 'Allow case change')
+    evt_checkbox(@cbx) { @edit_mode = ! @edit_mode }
+
+    sizer.add(@cbx, 0, Wx::RIGHT|Wx::ALL, 5)
+    sizer.layout
+  end
+end
+
+Wx::App.run { UpdateUIFrame.new.show }

data/samples/grid/grid.rb

@@ -0,0 +1,198 @@
+#!/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 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()