wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

data/samples/event/event.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Adapted for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+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
+
+class CountEvent < Wx::CommandEvent
+  EVT_COUNTER = Wx::EvtHandler.register_class(self, nil, 'evt_counter', 1)
+
+  def initialize(id)
+    super(EVT_COUNTER, id)
+  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
+
+  def try_before(event)
+    event_handler.queue_event(CountEvent.new(self.id)) if TargetHitEvent === event
+    super
+  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) }
+    @counter = 0
+    evt_counter(@tgt.get_id) { | e | on_counter(e) }
+    @listening = true
+    evt_size { | e | on_size(e) }
+    setup_menus
+    create_status_bar(2)
+  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 ]
+    set_status_text(msg, 0)
+  end
+
+  def on_counter(evt)
+    @counter += 1
+    set_status_text(@counter.to_s, 1)
+  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)
+
+    Wx::MessageDialog(self, msg, 'About Event Handling',
+                      Wx::OK | Wx::ICON_INFORMATION) do |about_dlg|
+      about_dlg.ok_label = Wx::ButtonLabel.new('Close')
+      about_dlg.show_modal
+    end
+  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
+
+module EventSample
+
+  include WxRuby::Sample if defined? WxRuby::Sample
+
+  def self.describe
+    { file: __FILE__,
+      summary: 'wxRuby event handling example.',
+      description: <<~__TXT
+        wxRuby example demonstrating event handling.
+        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.
+        __TXT
+     }
+  end
+
+  def self.activate
+    frame = TargetFrame.new("Event Handling Sample")
+    frame.show
+    frame
+  end
+
+  if $0 == __FILE__
+    Wx::App.run { EventSample.activate }
+  end
+
+end

data/samples/event/threaded.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Adapted for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require 'wx'
+
+# This simple sample demonstrates how to use Ruby (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.
+
+# 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 ProgressUpdateEvent < Wx::CommandEvent
+  # Create a new unique constant identifier, associate this class
+  # with events of that identifier, and create a shortcut 'evt_update_progress'
+  # method for setting up this handler.
+  EVT_UPDATE_PROGRESS = Wx::EvtHandler.register_class(self, nil, 'evt_update_progress', 0)
+
+  def initialize(value, gauge)
+    # The constant id is the arg to super
+    super(EVT_UPDATE_PROGRESS)
+    # simply use instance variables to store custom event associated data
+    @value = value
+    @gauge = gauge
+  end
+
+  attr_reader :value, :gauge
+end
+
+# 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)
+    # progress update handler
+    evt_update_progress(:on_progress_update)
+    frame = self
+    # show ten gauges
+    10.times do |gauge_ix|
+      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 asynchronously (more ways than 1)
+          if (gauge_ix % 2) == 0
+            frame.event_handler.queue_event(ProgressUpdateEvent.new(i+1, gauge_ix))
+          else
+            frame.call_after(:update_gauge, gauge_ix, i+1)
+          end
+        end
+      end
+      @gauges << gauge
+      sizer.add(gauge, 0, Wx::GROW|Wx::ALL, 2)
+    end
+    panel.sizer = sizer
+    sizer.fit(panel)
+  end
+
+  def update_gauge(gauge_ix, value)
+    @gauges[gauge_ix].value = value
+  end
+
+  def on_progress_update(evt)
+    update_gauge(evt.gauge, evt.value)
+  end
+end
+
+# This app class creates a frame, and, importantly, a timer to allow
+# the threads some computing time
+class GaugeApp < Wx::App
+  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
+
+module ThreadSample
+
+  include WxRuby::Sample if defined? WxRuby::Sample
+
+  def self.describe
+    { file: __FILE__,
+      summary: 'wxRuby threading example.',
+      description: <<~__TXT
+        wxRuby example demonstrating how to use ruby threads in wxRuby.
+        This simple sample demonstrates how to use Ruby (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.
+        __TXT
+    }
+  end
+
+  def self.run
+    execute(__FILE__)
+  end
+
+  if $0 == __FILE__
+    GaugeApp.run
+  end
+
+end

data/samples/event/update_ui_event.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Adapted for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+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
+
+module UpdateUISample
+
+  include WxRuby::Sample if defined? WxRuby::Sample
+
+  def self.describe
+    { file: __FILE__,
+      summary: 'Simple wxRuby UpdateUIEvent example.',
+      description: 'Simple wxRuby example demonstrating UpdateUIEvent handling.' }
+  end
+
+  def self.activate
+    frame = UpdateUIFrame.new
+    frame.show
+    frame
+  end
+
+  if $0 == __FILE__
+    Wx::App.run { UpdateUISample.activate }
+  end
+
+end

data/samples/grid/grid.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2004-2008 wxRuby development team
+# Adapted for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+require 'wx'
+
+class MyTextCellEditor < Wx::GRID::GridCellTextEditor
+  def apply_edit(row, col, grid)
+    grid.set_cell_value(row, col, "'#{get_value}'" )
+  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::WXRUBY_VERSION)
+
+    # 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_selected 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_changed 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::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 )
+
+    cell_attr = Wx::GRID::GridCellAttr.new
+    cell_attr.editor = MyTextCellEditor.new
+    @grid.set_row_attr(1, cell_attr)
+    cell_attr2 = Wx::GRID::GridCellAttr.new
+    cell_attr2.editor = cell_attr.editor(@grid, 1, 1)
+    @grid.set_row_attr(2, cell_attr2)
+
+    # 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::GRID::GridCellAttr.new
+    cell_attr.set_background_colour( Wx::LIGHT_GREY )
+    cell_attr.set_renderer( Wx::GRID::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::GRID::GridCellNumberEditor.new(5, 20)
+    @grid.set_cell_value(3, 1, 'Number editor below')
+    @grid.set_cell_editor(4, 1, editor)
+
+    editor = Wx::GRID::GridCellFloatEditor.new(4, 2)
+    @grid.set_cell_value(3, 2, 'Float editor below')
+    @grid.set_cell_editor(4, 2, editor)
+
+    editor = Wx::GRID::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::GRID::GridCellBoolEditor.new)
+    @grid.set_cell_renderer(6, 0, Wx::GRID::GridCellBoolRenderer.new)
+    @grid.set_cell_value(6, 1, 'Cell to the left displayed as boolean')
+  end
+  
+end
+
+module GridSample
+
+  include WxRuby::Sample if defined? WxRuby::Sample
+
+  def self.describe
+    { file: __FILE__,
+      summary: 'wxRuby Grid example.',
+      description: 'wxRuby example showcasing Grid control features.' }
+  end
+
+  def self.activate
+    frame = GridFrame.new(nil, -1, "Grid Sample",
+                          Wx::Point.new(10, 100),
+                          Wx::Size.new(630,400))
+    frame.show
+    frame
+  end
+
+  if $0 == __FILE__
+    Wx::App.run do
+      gc_stress
+      GridSample.activate
+    end
+  end
+
+end