wxruby3 0.9.2-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

data/samples/event/event.rb

@@ -15,185 +15,192 @@ require 'wx'
 # 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
+module Event
+
+  # 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 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]
+    # Returns the distance (in pixels) from the centre of the target
+    def distance
+      client_data[:distance]
+    end
   end
-end
 
-class CountEvent < Wx::CommandEvent
-  EVT_COUNTER = Wx::EvtHandler.register_class(self, nil, 'evt_counter', 1)
+  class CountEvent < Wx::CommandEvent
+    EVT_COUNTER = Wx::EvtHandler.register_class(self, nil, 'evt_counter', 1)
 
-  def initialize(id)
-    super(EVT_COUNTER, id)
+    def initialize(id)
+      super(EVT_COUNTER, id)
+    end
   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
+  # 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)
 
-  # What point is at the centre (assuming this control is always square)
-  def centre_point
-    size.width / 2
-  end
+    def initialize(parent, *args)
+      super(parent, *args)
 
-  # 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
+      # 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
-  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
+    # What point is at the centre (assuming this control is always square)
+    def centre_point
+      size.width / 2
     end
-  end
 
-  def try_before(event)
-    event_handler.queue_event(CountEvent.new(self.id)) if TargetHitEvent === event
-    super
-  end
-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
 
-# 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
+    # 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
 
-  # 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)
+    def try_before(event)
+      event_handler.queue_event(CountEvent.new(self.id)) if TargetHitEvent === event
+      super
+    end
   end
 
-  def on_counter(evt)
-    @counter += 1
-    set_status_text(@counter.to_s, 1)
-  end
+  # Container frame for the target control
+  class TargetFrame < Wx::Frame
+    def initialize(title)
+      super(nil, :title => title, :size => [300, 300])
 
-  # 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
+      self.icon = Wx.Icon(:sample, Wx::BITMAP_TYPE_XPM, art_path: File.join(__dir__, '..'))
 
-  # 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
+      @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) }
-      menu_bar.check(TOGGLE_LISTEN, true)
-      self.status_text = ''
+      @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
-  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)
+    # 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
 
-    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
+    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
-  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)
+    # 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
+
 end
 
 module EventSample
@@ -213,7 +220,7 @@ module EventSample
   end
 
   def self.activate
-    frame = TargetFrame.new("Event Handling Sample")
+    frame = Event::TargetFrame.new("Event Handling Sample")
     frame.show
     frame
   end

data/samples/event/threaded.rb

@@ -27,6 +27,8 @@ require 'wx'
 # wxRuby's Timer class to explicitly allocate time for non-GUI threads
 # to run. The latter technique is shown here.
 
+module Threaded
+
 # 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.
@@ -55,6 +57,9 @@ class ProgressFrame < Wx::Frame
   STEPS = 20
   def initialize
     super(nil, :title => 'Threading demo')
+
+    self.icon = Wx.Icon(:sample, Wx::BITMAP_TYPE_XPM, art_path: File.join(__dir__, '..'))
+
     @gauges = []
     panel = Wx::Panel.new(self)
     sizer = Wx::BoxSizer.new(Wx::VERTICAL)
@@ -107,6 +112,8 @@ class GaugeApp < Wx::App
   end
 end
 
+end
+
 module ThreadSample
 
   include WxRuby::Sample if defined? WxRuby::Sample
@@ -140,7 +147,7 @@ module ThreadSample
   end
 
   if $0 == __FILE__
-    GaugeApp.run
+    Threaded::GaugeApp.run
   end
 
 end

data/samples/event/update_ui_event.rb

@@ -11,66 +11,73 @@
 
 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
+module UpdateUIEvent
+
+  # 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 ])
+
+      self.icon = Wx.Icon(:sample, Wx::BITMAP_TYPE_XPM, art_path: File.join(__dir__, '..'))
+
+      @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
+
 end
 
 module UpdateUISample
@@ -84,7 +91,7 @@ module UpdateUISample
   end
 
   def self.activate
-    frame = UpdateUIFrame.new
+    frame = UpdateUIEvent::UpdateUIFrame.new
     frame.show
     frame
   end