wxruby3 0.9.3 → 0.9.5

data/tests/test_combo_ctrl.rb

@@ -0,0 +1,196 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+require_relative './lib/wxframe_runner'
+require_relative './lib/text_entry_tests'
+
+class ComboCtrlCtrlTests < WxRuby::Test::GUITests
+
+  include TextEntryTests
+
+  class LVComboPopup < Wx::ListView
+
+    include Wx::ComboPopup
+
+    def initialize
+      # call default control ctor; need to call Wx::ListView#create later
+      super
+    end
+
+    def init
+      @value = -1
+    end
+
+    def create(parent)
+      # need to finish creating the list view here
+      # as calling super here would just call Wx::ComboPopup#create and not Wx::ListView#create
+      # we need to use Ruby magic
+      wx_lv_create = (Wx::ListView.instance_method :create).bind(self)
+      wx_lv_create.call(parent, 1, [0,0], Wx::DEFAULT_SIZE)
+      evt_motion :on_mouse_move
+      evt_left_up :on_mouse_click
+    end
+    
+    # Return pointer to the created control
+    def get_control
+      self
+    end
+
+    def lv_find_item(*args)
+      unless @wx_lv_find_item
+        @wx_lv_find_item = (Wx::ListView.instance_method :find_item).bind(self)
+      end
+      @wx_lv_find_item.call(*args)
+    end
+    protected :lv_find_item
+
+    # Translate string into a list selection
+    def set_string_value(s)
+      n = lv_find_item(-1, s)
+      if n >= 0 && n < get_item_count
+        select(n)
+        @value = n
+      end
+    end
+ 
+    # Get list selection as a string
+    def get_string_value
+      return get_item_text(@value) if @value >= 0
+      ''
+    end
+ 
+    # Do mouse hot-tracking (which is typical in list popups)
+    def on_mouse_move(event)
+      # Move selection to cursor ...
+    end
+ 
+    # On mouse left up, set the value and close the popup
+    def on_mouse_click(_event)
+      @value = get_first_selected
+ 
+      # Send event as well ...
+ 
+      dismiss
+    end
+
+  end
+
+  def setup
+    super
+    @combo = Wx::ComboCtrl.new(frame_win, name: 'ComboCtrl')
+    @combo.set_popup_control(LVComboPopup.new)
+  end
+
+  def cleanup
+    @combo.destroy
+    super
+  end
+
+  attr_reader :combo
+  alias :text_entry :combo
+
+  def fill_list(list)
+    list.insert_item(0, 'This is the first item')
+    list.insert_item(1, 'This is the second item')
+    list.insert_item(2, 'This is the third item')
+    list.insert_item(3, 'This is the fourth item')
+  end
+
+  def test_popup
+    assert_equal('', combo.get_value)
+
+    assert_kind_of(Wx::ComboPopup, combo.get_popup_control)
+    assert_kind_of(Wx::ListView, combo.get_popup_control)
+    assert_kind_of(Wx::ListView, combo.get_popup_control.get_control)
+
+    assert_nothing_raised { fill_list(combo.get_popup_control) }
+    combo.popup
+
+    combo.set_value_by_user('This is the second item')
+
+    assert_equal('This is the second item', combo.get_popup_control.get_string_value)
+
+    combo.dismiss
+  end
+
+end
+
+class OwnerDrawnCBTests < WxRuby::Test::GUITests
+
+  include TextEntryTests
+
+  class TestODComboBox < Wx::OwnerDrawnComboBox
+
+    def on_draw_item(dc, rect, item, _flags)
+      return if item == Wx::NOT_FOUND
+
+      dc.set_text_foreground(Wx::BLACK)
+      dc.draw_text(get_string(item),
+                   rect.x + 3,
+                   rect.y + ((rect.height - dc.char_height)/2))
+    end
+
+    def on_draw_background(dc, rect, item,  flags)
+      # If item is selected or even, or we are painting the
+      # combo control itself, use the default rendering.
+      if flags.anybits?(Wx::ODCB_PAINTING_CONTROL|Wx::ODCB_PAINTING_SELECTED) || (item & 1) == 0
+        super(dc,rect,item,flags)
+        return
+      end
+
+      # Otherwise, draw every other background with different colour.
+      bgCol = Wx::Colour.new(240,240,250)
+      dc.set_brush(Wx::Brush.new(bgCol))
+      dc.set_pen(Wx::Pen.new(bgCol))
+      dc.draw_rectangle(rect)
+    end
+
+    def on_measure_item(_item)
+      48
+    end
+
+    def on_measure_item_width(_item)
+      -1 # default - will be measured from text width
+    end
+
+  end
+
+  def setup
+    super
+    @combo = TestODComboBox.new(frame_win, name: 'ODComboBox')
+  end
+
+  def cleanup
+    @combo.destroy
+    super
+  end
+
+  attr_reader :combo
+  alias :text_entry :combo
+
+  def fill_list(list)
+    list.append('This is the first item')
+    list.append('This is the second item')
+    list.append('This is the third item')
+    list.append('This is the fourth item')
+  end
+
+  def test_popup
+    assert_equal('', combo.get_value)
+
+    assert_kind_of(Wx::ComboPopup, combo.get_popup_control)
+    assert_kind_of(Wx::ComboPopupWx, combo.get_popup_control)
+    assert_kind_of(Wx::VListBox, combo.get_popup_control.get_control)
+
+    assert_nothing_raised { fill_list(combo) }
+    combo.popup
+
+    combo.set_value_by_user('This is the third item')
+
+    assert_equal('This is the third item', combo.get_popup_control.get_string_value)
+
+    combo.dismiss
+  end
+
+end

data/tests/test_config.rb

@@ -13,21 +13,21 @@ class TestConfig < Test::Unit::TestCase
     'RootEntry4' => 3.14,
     'Group1' => {
       'Group1Entry' => 'Group1 string',
-      'Group1.1' => {
-        'Group1.1Integer' => 999,
-        'Group1.1Bignum' => 2**999,
-        'Group1.1Float' => (2**999)-0.1
+      'Group1_1' => {
+        'Group1_1Integer' => 999,
+        'Group1_1Bignum' => 2**999,
+        'Group1_1Float' => (2**999)-0.1
       }
     },
     'Group2' => {
-      'Group2.1' => {
-        'Group2.1.1' => {
+      'Group2_1' => {
+        'Group2_1_1' => {
           'String' => 'hello'
         },
-        'Group2.1.2' => {
+        'Group2_1_2' => {
           'String' => 'world'
         },
-        'Group2.1.3' => {
+        'Group2_1_3' => {
           'True' => true,
           'False' => false
         }
@@ -35,79 +35,222 @@ class TestConfig < Test::Unit::TestCase
     }
   }
 
+  def stringified_entry(val)
+    case val
+    when TrueClass,FalseClass
+      val ? '1' : '0'
+    when Float
+      '%g' % val
+    else
+      val.to_s
+    end
+  end
+
+  def stringified(val)
+    val.is_a?(::Hash) ? val.inject({}) { |hash, pair| hash[pair.first] = stringified(pair.last); hash } : stringified_entry(val)
+  end
+
+  def assert_true_cfg(val)
+    assert_block('expected "1" or true') do
+      val == '1' || val == 1 || val == true
+    end
+  end
+
+  def assert_false_cfg(val)
+    assert_block("expected '0' or false") do
+      val == '0' || val == 0 || val == false
+    end
+  end
+
+  def assert_equal_cfg(expected, val)
+    assert_block("expected #{expected.is_a?(::Hash) ? stringified(expected) : %Q['#{stringified(expected)}']} \nor #{expected}\nbut got #{val}") do
+      expected == val || stringified(expected) == stringified(val)
+    end
+  end
+
   def run_config_tests(cfg)
-    assert_equal(DEMO_CONFIG, cfg.to_h)
+    assert_equal_cfg(DEMO_CONFIG, cfg.to_h)
 
-    assert_equal(4, cfg.number_of_entries)
-    assert_equal(2, cfg.number_of_groups)
-    assert_equal(12, cfg.number_of_entries(recurse: true))
-    assert_equal(7, cfg.number_of_groups(recurse: true))
+    assert_equal_cfg(4, cfg.number_of_entries)
+    assert_equal_cfg(2, cfg.number_of_groups)
+    assert_equal_cfg(12, cfg.number_of_entries(recurse: true))
+    assert_equal_cfg(7, cfg.number_of_groups(recurse: true))
 
     assert_true(cfg.has_entry?('/RootEntry2'))
     assert_true(cfg.has_entry?('/Group1/Group1Entry'))
-    assert_true(cfg.has_entry?('/Group2/Group2.1/Group2.1.2/String'))
+    assert_true(cfg.has_entry?('/Group2/Group2_1/Group2_1_2/String'))
 
-    assert_false(cfg.has_entry?('/Group2/Group2.2/Group2.1.2/String'))
+    assert_false(cfg.has_entry?('/Group2/Group2.2/Group2_1_2/String'))
 
     assert_true(cfg.has_group?('/Group2'))
-    assert_true(cfg.has_group?('/Group1/Group1.1'))
-    assert_true(cfg.has_group?('/Group2/Group2.1/Group2.1.2'))
+    assert_true(cfg.has_group?('/Group1/Group1_1'))
+    assert_true(cfg.has_group?('/Group2/Group2_1/Group2_1_2'))
 
-    assert_false(cfg.has_group?('/Group2/Group2.1/Group2.1.2/String'))
+    assert_false(cfg.has_group?('/Group2/Group2_1/Group2_1_2/String'))
 
-    grp = cfg['/Group1/Group1.1']
+    grp = cfg['/Group1/Group1_1']
 
-    assert_equal(DEMO_CONFIG['Group1']['Group1.1'], grp.to_h)
+    assert_equal_cfg(DEMO_CONFIG['Group1']['Group1_1'], grp.to_h)
 
     assert_equal(3, grp.number_of_entries)
     assert_equal(0, grp.number_of_groups)
 
-    assert_true(grp.has_entry?('Group1.1Integer'))
+    assert_true(grp.has_entry?('Group1_1Integer'))
     assert_false(grp.has_entry?('Group1Entry'))
     assert_true(grp.has_entry?('../Group1Entry'))
 
-    assert_true(grp.has_group?('/Group2/Group2.1/Group2.1.2'))
+    assert_true(grp.has_group?('/Group2/Group2_1/Group2_1_2'))
 
     assert_equal('This is a string value', cfg['/RootEntry1'])
-    assert_equal(true, cfg['/RootEntry2'])
-    assert_equal(101, cfg['/RootEntry3'])
-    assert_equal(3.14, cfg['/RootEntry4'])
+    assert_equal_cfg(true, cfg['/RootEntry2'])
+    assert_equal_cfg(101, cfg['/RootEntry3'])
+    assert_equal_cfg(3.14, cfg['/RootEntry4'])
 
-    grp = cfg['/Group2/Group2.1/Group2.1.3']
-    assert_true(grp.get('True'))
-    assert_false(grp.get('False'))
-    assert_nil(grp.get('../Group2.1.2/String'))
+    grp = cfg['/Group2/Group2_1/Group2_1_3']
+    assert_true_cfg(grp.get('True'))
+    assert_false_cfg(grp.get('False'))
+    assert_raise(ArgumentError) { grp.get('../Group2_1_2/String') }
 
-    assert_true(grp['True'])
-    assert_false(grp['False'])
-    assert_equal('world', grp['../Group2.1.2/String'])
+    assert_true_cfg(grp['True'])
+    assert_false_cfg(grp['False'])
+    assert_equal('world', grp['../Group2_1_2/String'])
 
     cfg.set('RootEntry1', 'Altered string value')
     assert_equal('Altered string value', cfg['RootEntry1'])
     assert_equal('Altered string value', cfg['/RootEntry1'])
     assert_equal('Altered string value', cfg.get('RootEntry1'))
 
-    cfg.set('RootEntry3', cfg.get('RootEntry3')+99)
-    assert_equal(200, cfg['/RootEntry3'])
+    cfg.set('RootEntry3', cfg.read('RootEntry3', ::Integer)+99)
+    assert_equal_cfg(200, cfg['/RootEntry3'])
+
+    cfg.set('Group1', { 'Group1_2' => { 'Integer' => 777 }})
+    assert_equal_cfg(777, cfg['/Group1/Group1_2/Integer'])
+
+    cfg['/Group1/Group1_2/Integer'] = 666
+    assert_equal_cfg(666, cfg['/Group1/Group1_2'].get('Integer'))
+
+    cfg['/Group1/Group1_2'] = { 'Float' => 0.3330 }
+    assert_equal_cfg(0.3330, cfg['/Group1/Group1_2'].get('Float'))
+
+    assert_equal(0.3330, cfg.read('/Group1/Group1_2/Float').to_f)
+    assert_equal(0.3330, cfg.read('/Group1/Group1_2/Float', Float))
+    assert_equal(0.3330, cfg.read('/Group1/Group1_2/Float', ->(v) { v.to_f }))
+
+    cfg.replace(DEMO_CONFIG) # reset
+  end
+
+  def run_auto_accessor_tests(cfg)
+    assert_not_nil(cfg.RootEntry2)
+    assert_not_nil(cfg.Group1.Group1Entry)
+    assert_not_nil(cfg.Group2.Group2_1.Group2_1_2.String)
+
+    assert_nil(cfg.Group2.Group2_1.Group2_1_2.AString)
+
+    assert_kind_of(cfg.class::Group, cfg.Group2)
+    assert_kind_of(cfg.class::Group, cfg.Group1.Group1_1)
+    assert_kind_of(cfg.class::Group, cfg.Group2.Group2_1.Group2_1_2)
+
+    assert_not_kind_of(cfg.class::Group, cfg.Group2.Group2_1.Group2_1_2.String)
+
+    grp = cfg.Group1
+
+    assert_equal_cfg(DEMO_CONFIG['Group1'], grp.to_h)
+
+    assert_not_nil(grp.Group1Entry)
+    assert_nil(grp.Group1_1Integer)
+
+    assert_kind_of(grp.class, grp.Group1_1)
+    assert_not_nil(grp.Group1_1.Group1_1Integer)
+
+    assert_true(grp.has_entry?('../RootEntry1'))
+
+    assert_true(grp.has_group?('/Group2/Group2_1/Group2_1_2'))
+
+    assert_equal_cfg('This is a string value', cfg.RootEntry1)
+    assert_equal_cfg(true, cfg.RootEntry2)
+    assert_equal_cfg(101, cfg.RootEntry3)
+    assert_equal_cfg(3.14, cfg.RootEntry4)
 
-    cfg.set('Group1', { 'Group1.2' => { 'Integer' => 777 }})
-    assert_equal(777, cfg['/Group1/Group1.2/Integer'])
+    grp = cfg.Group2.Group2_1.Group2_1_3
+    assert_true_cfg(grp.True)
+    assert_false_cfg(grp.False)
 
-    cfg['/Group1/Group1.2/Integer'] = 666
-    assert_equal(666, cfg['/Group1/Group1.2'].get('Integer'))
+    assert_true_cfg(grp['True'])
+    assert_false_cfg(grp['False'])
+    assert_equal_cfg('world', grp['../Group2_1_2/String'])
 
-    cfg['/Group1/Group1.2'] = { 'Float' => 0.3330 }
-    assert_equal(0.3330, cfg['/Group1/Group1.2'].get('Float'))
+    cfg.RootEntry1 = 'Altered string value'
+    assert_equal_cfg('Altered string value', cfg['RootEntry1'])
+    assert_equal_cfg('Altered string value', cfg['/RootEntry1'])
+    assert_equal_cfg('Altered string value', cfg.get('RootEntry1'))
+    assert_equal_cfg('Altered string value', cfg.RootEntry1)
+
+    cfg.RootEntry3 = (Kernel.Integer(cfg.RootEntry3) rescue 0)+99
+    assert_equal_cfg(200, cfg.RootEntry3)
+
+    cfg.Group1 = { 'Group1_2' => { 'Integer' => 777 }}
+    assert_equal_cfg(777, cfg.Group1.Group1_2.Integer)
+
+    cfg.Group1.Group1_2.Integer = 666
+    assert_equal_cfg(666, cfg.Group1.Group1_2.get('Integer'))
+
+    cfg.Group1.Group1_2 = { 'Float' => 0.3330 }
+    assert_equal_cfg(0.3330, cfg.Group1.Group1_2.get('Float'))
+
+    cfg.replace(DEMO_CONFIG) # reset
+  end
+
+  def run_env_var_tests(cfg)
+    # by default expansion is on
+
+    # add a number of entries for env var in new group 'Environment'
+    cfg['/Environment/HOME'] = '$HOME'
+    cfg['Environment'].USER = Wx::PLATFORM == 'WXMSW' ? '%USERNAME%' : '${USER}'
+    cfg['/Environment/PATH'] = '$(PATH)'
+
+    assert_equal(ENV['HOME'], cfg.Environment['HOME'])
+    assert_equal(ENV[Wx::PLATFORM == 'WXMSW' ?  'USERNAME' : 'USER'], cfg['/Environment/USER'])
+    assert_equal(ENV['PATH'], cfg.Environment.PATH)
+
+    # test escaping
+    cfg['/Environment/Escaped_HOME'] = '\$HOME'
+    cfg['/Environment/Escaped_HOME2'] = '\\$HOME'
+    cfg['/Environment/Escaped_HOME3'] = '\\\$HOME'
+
+    assert_equal('$HOME', cfg.Environment['Escaped_HOME'])
+    assert_equal('$HOME', cfg.Environment['Escaped_HOME2'])
+    assert_equal('\$HOME', cfg.Environment['Escaped_HOME3'])
+
+    cfg['/Environment/NONSENSE'] = '${NonExistingLongNonsenseVariable}'
+
+    assert_equal('${NonExistingLongNonsenseVariable}', cfg.Environment['NONSENSE'])
+
+    cfg['/Environment/MULTIPLE'] = "$HOME / #{Wx::PLATFORM == 'WXMSW' ? '%USERNAME%' : '${USER}'}"
+
+    assert_equal("#{ENV['HOME']} / #{Wx::PLATFORM == 'WXMSW' ? ENV['USERNAME'] : ENV['USER']}", cfg.Environment['MULTIPLE'])
+
+    # disable env var expansion
+    cfg.expand_env_vars = false
+    begin
+      assert_equal('$HOME', cfg.Environment['HOME'])
+    ensure
+      # re-enable
+      cfg.set_expand_env_vars(true)
+    end
   end
 
   def test_basic
     cfg = Wx::Config.new(DEMO_CONFIG)
 
     run_config_tests(cfg)
+    run_auto_accessor_tests(cfg)
+    run_env_var_tests(cfg)
   end
 
   def test_global
-    cfg = Wx::ConfigBase.create
+    cfg = Wx::ConfigBase.create(true, use_hash_config: true)
+
+    assert_kind_of(Wx::Config, cfg)
 
     cfg.replace(DEMO_CONFIG)
 
@@ -116,6 +259,8 @@ class TestConfig < Test::Unit::TestCase
     assert_equal(cfg, Wx::ConfigBase.get(false))
 
     run_config_tests(cfg)
+    run_auto_accessor_tests(cfg)
+    run_env_var_tests(cfg)
 
     cfg_old = Wx::ConfigBase.set(nil)
 
@@ -123,8 +268,28 @@ class TestConfig < Test::Unit::TestCase
     assert_nil(Wx::ConfigBase.get(false))
   end
 
+  # default registry based config does not seem to do well in CI build env
+  unless is_ci_build? && Wx::PLATFORM == 'WXMSW'
+
+  def test_default_wx
+    Wx::ConfigBase.set(nil) # reset global instance
+    cfg = Wx::ConfigBase.get # forced auto creation of default config
+
+    assert_kind_of(Wx::ConfigWx, cfg)
+
+    cfg.replace(DEMO_CONFIG)
+
+    run_config_tests(cfg)
+    run_auto_accessor_tests(cfg)
+    run_env_var_tests(cfg)
+
+    assert_true(cfg.clear) # cleanup
+  end
+
+  end
+
   def test_html_help
-    cfg = Wx::ConfigBase.create
+    cfg = Wx::ConfigBase.create(true, use_hash_config: true)
 
     assert_true(cfg.to_h.empty?)
 

data/tests/test_persistence.rb

@@ -0,0 +1,142 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+require_relative './lib/wxframe_runner'
+
+class TopLevelPersistenceTests < WxRuby::Test::GUITests
+
+  PERSIST_ROOT = 'Persistent_Options'
+
+  def run_frame_props_tests
+    Wx.persistent_register_and_restore(frame_win, 'TestFrame')
+
+    frame_win.size = [450, 350]
+    frame_win.position = [100, 150]
+
+    Wx::PersistenceManager.get.save_and_unregister(frame_win)
+
+    cfg = Wx::ConfigBase.get
+    assert_kind_of(Wx::ConfigBase, cfg)
+    grp = cfg.get(PERSIST_ROOT)
+    assert_kind_of(cfg.class::Group, grp)
+    grp = grp.get('Window')
+    assert_kind_of(cfg.class::Group, grp)
+    grp = grp.get('TestFrame')
+    assert_kind_of(cfg.class::Group, grp)
+
+    assert_equal(100, Integer(grp['x']))
+    assert_equal(150, Integer(grp['y']))
+    assert_equal(450, Integer(grp.w))
+    assert_equal(350, Integer(grp.h))
+
+    grp.x = 110
+    grp.y = 140
+
+    assert_equal(110, Integer(grp['x']))
+    assert_equal(140, Integer(grp['y']))
+
+    Wx.persistent_register_and_restore(frame_win, 'TestFrame')
+
+    assert_equal(Wx::Point.new(110, 140), frame_win.position)
+
+    Wx::PersistenceManager.get.unregister(frame_win)
+  end
+
+  def test_frame_props_ruby_config
+    # force creation of hash based Wx::Config instance
+    Wx::ConfigBase.create(true, use_hash_config: true)
+
+    run_frame_props_tests
+
+    Wx::ConfigBase.get.clear
+  end
+
+  # default registry based config does not seem to do well in CI build env
+  unless is_ci_build? && Wx::PLATFORM == 'WXMSW'
+
+  def test_frame_props_default_config
+    # force creation of default C++ config instance
+    Wx::ConfigBase.create(true)
+
+    run_frame_props_tests
+
+    Wx::ConfigBase.get.clear
+  end
+
+  end
+
+  class PersistentButton < Wx::PersistentWindowBase
+
+    def get_kind
+      'Button'
+    end
+
+    def save
+      save_value('w', get.size.width)
+      save_value('h', get.size.height)
+      save_value('label', get.label)
+      save_value('my_custom_value', get.my_custom_value)
+    end
+
+    def restore
+      get.size = [Integer(restore_value('w')), Integer(restore_value('h'))]
+      get.label = restore_value('label')
+      get.my_custom_value = Float(restore_value('my_custom_value'))
+      true
+    end
+
+  end
+
+  class MyButton < Wx::Button
+
+    def initialize(parent=nil, name)
+      super(parent, label: '', name: name)
+      @my_custom_value = ''
+    end
+
+    attr_accessor :my_custom_value
+
+    def create_persistent_object
+      PersistentButton.new(self)
+    end
+
+  end
+
+  def test_custom_persistent_object
+    # force creation of hash based Wx::Config instance
+    Wx::ConfigBase.create(true, use_hash_config: true)
+
+    assert_false(Wx::ConfigBase.get.has_group?(PERSIST_ROOT))
+
+    btn = MyButton.new(frame_win, 'AButton')
+    btn.label = 'Hello world'
+    btn.my_custom_value = 3.14
+
+    Wx::PersistenceManager.get.register(btn)
+
+    assert_false(Wx::ConfigBase.get.has_group?(PERSIST_ROOT))
+
+    # destroying window should save and unregister
+    btn.destroy
+    btn = nil
+
+
+    assert_true(Wx::ConfigBase.get.has_group?(PERSIST_ROOT))
+
+    cfg = Wx::ConfigBase.get[PERSIST_ROOT]['Button']['AButton']
+    assert_true(cfg.has_entry?('w'))
+    assert_true(cfg.has_entry?('h'))
+    assert_true(cfg.has_entry?('label'))
+    assert_true(cfg.has_entry?('my_custom_value'))
+
+
+    btn = MyButton.new(frame_win, 'AButton')
+
+    Wx::PersistenceManager.get.register_and_restore(btn)
+
+    assert_equal('Hello world', btn.label)
+    assert_equal(3.14, btn.my_custom_value)
+  end
+
+end