wxruby3 0.9.1-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

data/samples/widgets/spinbtn.rb

@@ -0,0 +1,443 @@
+# Copyright (c) 2023 M.J.N. Corino = self.next_id The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Adapted for wxRuby from wxWidgets widgets sample
+# Copyright (c) 2001 Vadim Zeitlin
+
+module Widgets
+
+  module SpinBtn
+
+    class SpinBtnPage < Widgets::Page
+
+      module ID
+        include Wx::IDHelper
+
+        Reset = self.next_id(Widgets::Frame::ID::Last)
+        Clear = self.next_id
+        SetValue = self.next_id
+        SetMinAndMax = self.next_id
+        SetBase = self.next_id
+        SetIncrement = self.next_id
+        CurValueText = self.next_id
+        ValueText = self.next_id
+        MinText = self.next_id
+        MaxText = self.next_id
+        BaseText = self.next_id
+        SetIncrementText = self.next_id
+        SpinBtn = self.next_id
+        SpinCtrl = self.next_id
+        SpinCtrlDouble = self.next_id
+
+        Align_Left = 0
+        Align_Centre = 1
+        Align_Right = 2
+      end
+
+      def initialize(book, images)
+        super(book, images, :spinbtn)
+
+        @chkVert = nil
+        @chkArrowKeys = nil
+        @chkWrap = nil
+        @chkProcessEnter = nil
+        @radioAlign = nil
+        @spinbtn = nil
+        @spinctrl = nil
+        @spinctrldbl = nil
+        @textValue =
+        @textMin =
+        @textMax =
+        @textBase =
+        @textIncrement = nil
+    
+        @min = 0
+        @max = 10
+    
+        @base = 10
+        @increment = 1
+    
+        @sizerSpin = nil
+      end
+
+      Info = Widgets::PageInfo.new(self, 'Spin',
+                                   NATIVE_CTRLS | EDITABLE_CTRLS)
+
+      def get_widget
+        @spinbtn
+      end
+
+      def get_widgets
+        super << @spinctrl << @spinctrldbl
+      end
+  
+      def recreate_widget
+        create_spin
+      end
+  
+      # lazy creation of the content
+      def create_content
+        sizerTop = Wx::HBoxSizer.new
+    
+        # left pane
+        sizerLeft = Wx::StaticBoxSizer.new(Wx::VERTICAL, self, '&Set style')
+        sizerLeftBox = sizerLeft.get_static_box
+    
+        @chkVert = create_check_box_and_add_to_sizer(sizerLeft, '&Vertical', Wx::ID_ANY, sizerLeftBox)
+        @chkArrowKeys = create_check_box_and_add_to_sizer(sizerLeft, '&Arrow Keys', Wx::ID_ANY, sizerLeftBox)
+        @chkWrap = create_check_box_and_add_to_sizer(sizerLeft, '&Wrap', Wx::ID_ANY, sizerLeftBox)
+        @chkProcessEnter = create_check_box_and_add_to_sizer(sizerLeft,
+                                                             'Process &Enter',
+                                                             Wx::ID_ANY, sizerLeftBox)
+
+        sizerLeft.add(5, 5, 0, Wx::GROW | Wx::ALL, 5) # spacer
+    
+        halign = %w[left centre right]
+    
+        @radioAlign = Wx::RadioBox.new(sizerLeftBox, Wx::ID_ANY, '&Text alignment',
+                                       choices: halign, 
+                                       major_dimension: 1)
+    
+        sizerLeft.add(@radioAlign, 0, Wx::GROW | Wx::ALL, 5)
+    
+        sizerLeft.add(5, 5, 0, Wx::GROW | Wx::ALL, 5) # spacer
+    
+        btn = Wx::Button.new(sizerLeftBox, ID::Reset, '&Reset')
+        sizerLeft.add(btn, 0, Wx::ALIGN_CENTRE_HORIZONTAL | Wx::ALL, 15)
+    
+        # middle pane
+        sizerMiddle = Wx::StaticBoxSizer.new(Wx::VERTICAL, self, '&Change spinbtn value')
+        sizerMiddleBox = sizerMiddle.get_static_box
+
+        sizerRow, text = create_sizer_with_text_and_label('Current value',
+                                                          ID::CurValueText,
+                                                          sizerMiddleBox)
+        text.set_editable(false)
+    
+        sizerMiddle.add(sizerRow, 0, Wx::ALL | Wx::GROW, 5)
+
+        sizerRow, @textValue = create_sizer_with_text_and_button(ID::SetValue,
+                                                                 'Set &value',
+                                                                 ID::ValueText,
+                                                                 sizerMiddleBox)
+        sizerMiddle.add(sizerRow, 0, Wx::ALL | Wx::GROW, 5)
+
+        sizerRow, @textMin = create_sizer_with_text_and_button(ID::SetMinAndMax,
+                                                               '&Min and max',
+                                                               ID::MinText,
+                                                               sizerMiddleBox)
+
+        @textMax = Wx::TextCtrl.new(sizerMiddleBox, ID::MaxText, '')
+        sizerRow.add(@textMax, 1, Wx::LEFT | Wx::ALIGN_CENTRE_VERTICAL, 5)
+    
+        @textMin.set_value(@min.to_s)
+        @textMax.set_value(@max.to_s)
+    
+        sizerMiddle.add(sizerRow, 0, Wx::ALL | Wx::GROW, 5)
+
+        sizerRow, @textBase = create_sizer_with_text_and_button(ID::SetBase,
+                                                                'Set &base',
+                                                                ID::BaseText,
+                                                                sizerMiddleBox)
+        @textBase.set_value("10")
+        sizerMiddle.add(sizerRow, 0, Wx::ALL | Wx::GROW, 5)
+
+        sizerRow, @textIncrement = create_sizer_with_text_and_button(ID::SetIncrement,
+                                                                     'Set Increment',
+                                                                     ID::SetIncrementText,
+                                                                     sizerMiddleBox)
+        @textIncrement.set_value( "1" )
+        sizerMiddle.add( sizerRow, 0, Wx::ALL | Wx::GROW, 5 )
+    
+        # right pane
+        sizerRight = Wx::VBoxSizer.new
+        sizerRight.set_min_size(150, 0)
+        @sizerSpin = sizerRight # save it to modify it later
+    
+        reset
+        create_spin
+    
+        # the 3 panes panes compose the window
+        sizerTop.add(sizerLeft, 0, Wx::GROW | (Wx::ALL & ~Wx::LEFT), 10)
+        sizerTop.add(sizerMiddle, 0, Wx::GROW | Wx::ALL, 10)
+        sizerTop.add(sizerRight, 1, Wx::GROW | (Wx::ALL & ~Wx::RIGHT), 10)
+    
+        # final initializations
+        set_sizer(sizerTop)
+        
+        # connect event handlers
+        evt_button(ID::Reset, :on_button_reset)
+        evt_button(ID::SetValue, :on_button_set_value)
+        evt_button(ID::SetMinAndMax, :on_button_set_min_and_max)
+        evt_button(ID::SetBase, :on_button_set_base)
+        evt_button(ID::SetIncrement, :on_button_set_increment)
+    
+        evt_update_ui(ID::SetValue, :on_update_ui_value_button)
+        evt_update_ui(ID::SetMinAndMax, :on_update_ui_min_max_button)
+        evt_update_ui(ID::SetBase, :on_update_ui_base_button)
+    
+        evt_update_ui(ID::Reset, :on_update_ui_reset_button)
+    
+        evt_update_ui(ID::CurValueText, :on_update_ui_cur_value_text)
+    
+        evt_spin(ID::SpinBtn, :on_spin_btn)
+        evt_spin_up(ID::SpinBtn, :on_spin_btn_up)
+        evt_spin_down(ID::SpinBtn, :on_spin_btn_down)
+        evt_spinctrl(ID::SpinCtrl, :on_spin_ctrl)
+        evt_spinctrldouble(ID::SpinCtrlDouble, :on_spin_ctrl_double)
+        evt_text(ID::SpinCtrl, :on_spin_text)
+        evt_text_enter(ID::SpinCtrl, :on_spin_text_enter)
+        evt_text(ID::SpinCtrlDouble, :on_spin_text)
+        evt_text_enter(ID::SpinCtrlDouble, :on_spin_text_enter)
+    
+        evt_checkbox(Wx::ID_ANY, :on_check_or_radio_box)
+        evt_radiobox(Wx::ID_ANY, :on_check_or_radio_box)
+      end
+  
+      protected
+
+      # event handlers
+      def on_button_reset(event)
+        reset
+
+        create_spin
+      end
+
+      def on_button_set_value(event)
+        if @textValue.is_empty
+          @spinctrl.set_value('')
+          @spinctrldbl.set_value('')
+
+          return
+        end
+    
+        val = Integer(@textValue.value) rescue nil
+        if val.nil? || !is_valid_value(val)
+          Wx.log_warning('Invalid spinbtn value.')
+
+          return
+        end
+
+        @spinbtn.set_value(val)
+        @spinctrl.set_value(val)
+        @spinctrldbl.set_value(val)
+      end
+
+      def on_button_set_min_and_max(event)
+        minNew = Integer(@textMin.value) rescue nil
+        maxNew = Integer(@textMax.value) rescue nil
+        if minNew.nil? || maxNew.nil? || minNew > maxNew
+          Wx.log_warning('Invalid min/max values for the spinbtn.')
+
+          return
+        end
+
+        @min = minNew
+        @max = maxNew
+
+        @spinbtn.set_range(minNew, maxNew)
+        @spinctrl.set_range(minNew, maxNew)
+        @spinctrldbl.set_range(minNew, maxNew)
+
+        @sizerSpin.layout
+      end
+
+      def on_button_set_base(event)
+        base = Integer(@textBase.value) rescue nil
+        if base.nil? || base <= 0
+          Wx.log_warning('Invalid base value.')
+          return
+        end
+    
+        @base = base
+        Wx.log_warning("Setting base #{@base} failed.") if !@spinctrl.set_base(@base)
+
+        @sizerSpin.layout
+      end
+
+      def on_button_set_increment(event)
+        increment = @textIncrement.value.to_i
+        if increment == 0
+          Wx.log_warning('Invalid increment value.')
+          return
+        end
+
+        @increment = increment
+        @spinctrl.set_increment(@increment)
+        Wx.log_warning("Setting increment to #{@increment}.")
+      end
+
+      def on_check_or_radio_box(event)
+        create_spin
+      end
+
+      def on_spin_btn(event)
+        value = event.int
+
+        ::Kernel.raise RuntimeError, 'spinbtn value should be the same' unless value == @spinbtn.value
+
+        Wx.log_message("Spin button value changed, now #{value}")
+      end
+
+      def on_spin_btn_up(event)
+        # Demonstrate that these events can be vetoed to prevent the control value
+        # from changing.
+        if event.int == 11
+          Wx.log_message("Spin button prevented from going up to 11 (still #{@spinbtn.value})")
+          event.veto
+          return
+        end
+    
+        Wx.log_message("Spin button value incremented, will be #{event.int} (was #{@spinbtn.value})")
+      end
+
+      def on_spin_btn_down(event)
+        # Also demonstrate that vetoing the event but then skipping the handler
+        # doesn't actually apply the veto.
+        if event.int == 0
+          Wx.log_message('Spin button change not effectively vetoed, will become 0')
+          event.veto
+          event.skip
+        end
+
+        Wx.log_message("Spin button value decremented, will be #{event.int} (was #{@spinbtn.value})")
+      end
+
+      def on_spin_ctrl(event)
+        value = event.int
+
+        ::Kernel.raise RuntimeError, 'spinctrl value should be the same' unless value == @spinctrl.value
+
+        Wx.log_message("Spin control value changed, now #{value}")
+      end
+
+      def on_spin_ctrl_double(event)
+        value = event.value
+
+        Wx.log_message("Spin control value changed, now #{value}")
+      end
+
+      def on_spin_text(event)
+        Wx.log_message("Text changed in spin control, now \"#{event.string}\"")
+      end
+
+      def on_spin_text_enter(event)
+        Wx.log_message("\"Enter\" pressed in spin control, text is \"#{event.string}\"")
+      end
+
+      def on_update_ui_value_button(event)
+        val = @textValue.value.empty? ? false : (Integer(@textValue.value) rescue false)
+        event.enable(val && is_valid_value(val))
+      end
+
+      def on_update_ui_min_max_button(event)
+        min = Integer(@textMin.value) rescue false
+        max = Integer(@textMax.value) rescue false
+        event.enable(min && max && min <= max)
+      end
+
+      def on_update_ui_base_button(event)
+        base = Integer(@textBase.value) rescue false
+        event.enable(base && base > 0)
+      end
+
+      def on_update_ui_reset_button(event)
+        event.enable(!@chkVert.value || @chkWrap.value || @chkProcessEnter.value)
+      end
+
+      def on_update_ui_cur_value_text(event)
+        event.set_text(@spinbtn.value.to_s)
+      end
+  
+      # reset the spinbtn parameters
+      def reset
+        @chkVert.set_value(true)
+        @chkArrowKeys.set_value(true)
+        @chkWrap.set_value(false)
+        @chkProcessEnter.set_value(false)
+        @radioAlign.set_selection(ID::Align_Right)
+      end
+  
+      # (re)create the spinbtn
+      def create_spin
+        flags = get_attrs.default_flags
+    
+        if @chkVert.value
+            flags |= Wx::SP_VERTICAL
+        else
+            flags |= Wx::SP_HORIZONTAL
+        end
+
+        flags |= Wx::SP_ARROW_KEYS if @chkArrowKeys.value
+        flags |= Wx::SP_WRAP if @chkWrap.value
+        flags |= Wx::TE_PROCESS_ENTER if @chkProcessEnter.value
+
+        textFlags = 0
+        case @radioAlign.selection
+        when ID::Align_Left
+          textFlags |= Wx::ALIGN_LEFT  # no-op
+        when ID::Align_Centre
+          textFlags |= Wx::ALIGN_CENTRE_HORIZONTAL
+        when ID::Align_Right
+          textFlags |= Wx::ALIGN_RIGHT
+        else
+          ::Kernel.raise RuntimeError, 'unexpected radiobox selection'
+        end
+    
+        val = @min
+        if @spinbtn
+          valOld = @spinbtn.value
+          val = valOld unless is_valid_value(valOld)
+    
+          @sizerSpin.clear(true) # delete windows 
+        end
+    
+        @spinbtn = Wx::SpinButton.new(self, ID::SpinBtn,
+                                      style: flags)
+        @spinbtn.set_value(val)
+        @spinbtn.set_range(@min, @max)
+    
+        @spinctrl = Wx::SpinCtrl.new(self, ID::SpinCtrl,
+                                     val.to_s,
+                                     style: flags | textFlags,
+                                     min: @min, 
+                                     max: @max, 
+                                     initial: val)
+    
+        @spinctrldbl = Wx::SpinCtrlDouble.new(self, ID::SpinCtrlDouble,
+                                              val.to_s,
+                                              style: flags | textFlags,
+                                              min: @min, 
+                                              max: @max, 
+                                              initial: val, 
+                                              inc: 0.1)
+    
+        # Add spacers, labels and spin controls to the sizer.
+        @sizerSpin.add(0, 0, 1)
+        @sizerSpin.add(Wx::StaticText.new(self, Wx::ID_ANY, 'wxSpinButton'),
+                       0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(@spinbtn, 0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(0, 0, 1)
+        @sizerSpin.add(Wx::StaticText.new(self, Wx::ID_ANY, 'wxSpinCtrl'),
+                       0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(@spinctrl, 0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(0, 0, 1)
+        @sizerSpin.add(Wx::StaticText.new(self, Wx::ID_ANY, 'wxSpinCtrlDouble'),
+                       0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(@spinctrldbl, 0, Wx::ALIGN_CENTRE | Wx::ALL, 5)
+        @sizerSpin.add(0, 0, 1)
+
+        @sizerSpin.layout
+      end
+  
+      # is this spinbtn value in range?
+      def is_valid_value(val)
+        (val >= @min) && (val <= @max)
+      end
+
+    end
+
+  end
+
+end

data/samples/widgets/statbmp.rb

@@ -0,0 +1,130 @@
+# Copyright (c) 2023 M.J.N. Corino = self.next_id The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Adapted for wxRuby from wxWidgets widgets sample
+# Copyright (c) 2001 Vadim Zeitlin
+
+module Widgets
+
+  module StatBmp
+
+    class StatBmpPage < Widgets::Page
+
+      def initialize(book, images)
+        super(book, images, :statbmp)
+      end
+
+      Info = Widgets::PageInfo.new(self, 'StaticBitmap')
+
+      def create_content
+        choices = %w[native generic]
+        @radio = Wx::RadioBox.new(self, Wx::ID_ANY, 'Implementation',
+                                  choices: choices)
+
+        scaleChoices = ['None', 'Fill', 'Aspect Fit', 'Aspect Fill']
+        @scaleRadio = Wx::RadioBox.new(self, Wx::ID_ANY, 'Scale Mode',
+                                       choices: scaleChoices)
+
+        testImage = ''
+        if Wx.has_feature?(:USE_LIBPNG)
+          fn = Wx::ArtLocator.find_art(:toucan, art_section: 'widgets', bmp_type: Wx::BitmapType::BITMAP_TYPE_PNG)
+          testImage = fn if fn
+        end
+        @filepicker = Wx::FilePickerCtrl.new(self, Wx::ID_ANY, testImage)
+    
+        @sbsizer = Wx::StaticBoxSizer.new(Wx::VERTICAL, self, 'wxStaticBitmap inside')
+    
+        leftsizer = Wx::VBoxSizer.new
+        leftsizer.add(@radio, Wx::SizerFlags.new.expand.border)
+        leftsizer.add(@scaleRadio, Wx::SizerFlags.new.expand.border)
+        leftsizer.add(@filepicker, Wx::SizerFlags.new.expand.border)
+        sizer = Wx::HBoxSizer.new
+        sizer.add(leftsizer, Wx::SizerFlags.new.border)
+        sizer.add(@sbsizer, Wx::SizerFlags.new.border)
+        set_sizer(sizer)
+
+        evt_filepicker_changed(Wx::ID_ANY, :on_file_change)
+        evt_radiobox(Wx::ID_ANY, :on_radio_change)
+
+        @statbmp = nil
+        recreate_widget
+      end
+
+      def get_widget
+        @statbmp
+      end
+
+      def recreate_widget
+        if @statbmp
+          @statbmp.destroy
+        end
+
+        bmp = Wx::Bitmap.new
+
+        filepath = @filepicker.path
+        unless filepath.empty?
+          image = Wx::Image.new(filepath)
+          if image.ok?
+            bmp = image
+          else
+            Wx.log_message("Reading image from file '#{filepath}' failed.")
+          end
+        end
+    
+        unless bmp.ok?
+          # Show at least something.
+          bmp = Wx::ArtProvider.get_bitmap(Wx::ART_MISSING_IMAGE)
+        end
+    
+        style = get_attrs.default_flags
+    
+        if @radio.selection == 0
+          @statbmp = Wx::StaticBitmap.new(@sbsizer.get_static_box, Wx::ID_ANY, bmp,
+                                          style: style)
+        else
+          @statbmp = Wx::GenericStaticBitmap.new(@sbsizer.get_static_box, Wx::ID_ANY, bmp,
+                                                 style: style)
+        end
+    
+        scaleMode = Wx::StaticBitmap::ScaleMode.new(@scaleRadio.selection)
+        @statbmp.set_scale_mode(scaleMode)
+        Wx.log_error('Scale mode not supported by current implementation') if @statbmp.get_scale_mode != scaleMode
+
+        sbsizerItem = get_sizer.get_item(@sbsizer)
+        if scaleMode == Wx::StaticBitmap::ScaleMode::Scale_None
+          sbsizerItem.set_proportion(0)
+          sbsizerItem.set_flag(Wx::CENTER)
+        else
+          sbsizerItem.set_proportion(1)
+          sbsizerItem.set_flag(Wx::EXPAND)
+        end
+        @sbsizer.add(@statbmp, Wx::SizerFlags.new(1).expand)
+        get_sizer.layout
+
+        @statbmp.evt_left_down(method(:on_mouse_event))
+
+        # When switching from generic to native control on wxMSW under Wine,
+        # the explicit refresh is necessary
+        @statbmp.refresh
+      end
+  
+      protected
+
+      def on_file_change(_ev)
+        recreate_widget
+      end
+
+      def on_radio_change(_ev)
+        recreate_widget
+      end
+  
+      def on_mouse_event(_event)
+        Wx.log_message('wxStaticBitmap clicked.')
+      end
+
+    end
+
+  end
+
+end