wxruby3 0.9.0.pre.beta.14-x64-mingw-ucrt → 0.9.0.pre.rc.2-x64-mingw-ucrt

data/lib/wx/doc/gen/event_filter.rb

@@ -0,0 +1,88 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A global event filter for pre-processing all the events generated in the program.
+  # This is a very simple class which just provides {Wx::EventFilter#filter_event} virtual method to be called by {Wx::EvtHandler} before starting process of any event. Thus, inheriting from this class and overriding {Wx::EventFilter#filter_event} allows capturing and possibly handling or ignoring all the events happening in the program. Of course, having event filters adds additional overhead to every event processing and so should not be used lightly and your {Wx::EventFilter#filter_event} code should try to return as quickly as possible, especially for the events it is not interested in.
+  # An example of using this class: 
+  # ```ruby
+  # # This class allows determining the last time the user has worked with
+  # # this application:
+  # class LastActivityTimeDetector < Wx::EventFilter
+  #   def initialize
+  #     Wx::EvtHandler.add_filter(self)
+  # 
+  #     @last = Time.now
+  #   end
+  # 
+  #   def clear
+  #     Wx::EvtHandler.remove_filter(self)
+  #   end
+  # 
+  #   def filter_event(event)
+  #     # Update the last user activity
+  #     t = event.get_event_type
+  #     case t
+  #     when Wx::EVT_KEY_DOWN, 
+  #          Wx::EVT_MOTION, 
+  #          Wx::EVT_LEFT_DOWN,
+  #          Wx::EVT_RIGHT_DOWN,
+  #          Wx::EVT_MIDDLE_DOWN
+  #       @last = Time.now
+  #     end
+  # 
+  #     # Continue processing the event normally as well.
+  #     Event_Skip
+  #   end
+  # 
+  #   # This function could be called periodically from some timer to
+  #   # do something (e.g. hide sensitive data or log out from remote
+  #   # server) if the user has been inactive for some time period.
+  #   def is_inactive_for?(diff)
+  #     (Time.now - diff) > @last
+  #   end
+  # 
+  # end
+  # ```
+  # 
+  # Notice that {Wx::App} derives from {Wx::EventFilter} and is registered as an event filter during its creation so you may also override {Wx::EventFilter#filter_event} method in your {Wx::App}-derived class and, in fact, this is often the most convenient way to do it. However creating a new class deriving directly from {Wx::EventFilter} allows isolating the event filtering code in its own separate class and also having several independent filters, if necessary.
+  # Category:  {Wx::Events}
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class EventFilter < ::Object
+  
+    # Process event as usual.
+    # 
+    Event_Skip = -1
+    
+    # Don't process the event normally at all.
+    # 
+    Event_Ignore = 0
+    
+    # Event was already handled, don't process it normally.
+    # 
+    Event_Processed = 1
+    
+    # Default constructor.
+    # Constructor does not register this filter using {Wx::EvtHandler.add_filter}, it's your responsibility to do it when necessary.
+    # Notice that the objects of this class can't be copied.
+    # @return [EventFilter]
+    def initialize; end
+    
+    # Override this method to implement event pre-processing.
+    # This method allows filtering all the events processed by the program, so you should try to return quickly from it to avoid slowing down the program to a crawl.
+    # Although the return type of this method is int, this is only due to backwards compatibility concerns and the actual return value must be one of the Event_XXX constants defined above:
+    # - Event_Skip to continue processing the event normally (this should be used in most cases).- Event_Ignore to not process this event at all (this can be used to suppress some events).- Event_Processed to not process this event normally but indicate that it was already processed by the event filter and so no default processing should take place either (this should only be used if the filter really did process the event).
+    # @param event [Wx::Event] 
+    # @return [Integer]
+    def filter_event(event) end
+    
+  end # EventFilter
+  
+
+end

data/lib/wx/doc/gen/event_list.rb

@@ -1112,6 +1112,13 @@ class Wx::EvtHandler
   # @yieldparam [Wx::MediaEvent] event the event to handle
   def evt_media_pause(id, meth = nil, &block) end
   
+  # User clicked on a hyperlink. 
+  # Processes a {Wx::EVT_HYPERLINK} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::HyperlinkEvent] event the event to handle
+  def evt_hyperlink(id, meth = nil, &block) end
+  
   # Process a {Wx::EVT_BUTTON} event, when the button is clicked. 
   # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
   # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
@@ -1130,7 +1137,7 @@ class Wx::EvtHandler
   # @yieldparam [Wx::CommandEvent] event the event to handle
   def evt_choice(id, meth = nil, &block) end
   
-  # Process a {Wx::EVT_COMBOBOX} event, when an item on the list is selected. Note that calling {Wx::ComboBox#get_value} returns the new value of selection. 
+  # Process a {Wx::EVT_COMBOBOX} event, when an item on the list is selected. 
   # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
   # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
   # @yieldparam [Wx::CommandEvent] event the event to handle
@@ -1199,7 +1206,7 @@ class Wx::EvtHandler
   # @yieldparam [Wx::CommandEvent] event the event to handle
   def evt_text(id, meth = nil, &block) end
   
-  # Process a {Wx::EVT_TEXT_ENTER} event, when RETURN is pressed in the combobox (notice that the combobox must have been created with {Wx::TE_PROCESS_ENTER} style to receive this event). 
+  # Process a {Wx::EVT_TEXT_ENTER} event, when RETURN is pressed in the combobox. 
   # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
   # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
   # @yieldparam [Wx::CommandEvent] event the event to handle
@@ -1330,6 +1337,20 @@ class Wx::EvtHandler
   # @yieldparam [Wx::BookCtrlEvent] event the event to handle
   def evt_notebook_page_changing(id, meth = nil, &block) end
   
+  # Respond to a {Wx::EVT_SEARCH} event, generated when the search button is clicked. Note that this does not initiate a search on its own, you need to perform the appropriate action in your event handler. You may use 
+  # Processes a {Wx::EVT_SEARCH} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::CommandEvent] event the event to handle
+  def evt_search(id, meth = nil, &block) end
+  
+  # Respond to a {Wx::EVT_SEARCH_CANCEL} event, generated when the cancel button is clicked. 
+  # Processes a {Wx::EVT_SEARCH_CANCEL} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::CommandEvent] event the event to handle
+  def evt_search_cancel(id, meth = nil, &block) end
+  
   # Process a {Wx::EVT_SPINCTRL} event, which is generated whenever the numeric value of the spin control is updated. 
   # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
   # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc

data/lib/wx/doc/gen/events.rb

@@ -574,13 +574,17 @@ module Wx
     # The return value is a combination of {Wx::KeyModifier::MOD_ALT}, {Wx::KeyModifier::MOD_CONTROL}, {Wx::KeyModifier::MOD_SHIFT} and {Wx::KeyModifier::MOD_META} bit masks. Additionally, {Wx::KeyModifier::MOD_NONE} is defined as 0, i.e. corresponds to no modifiers (see {Wx::MouseEvent#has_any_modifiers}) and {Wx::KeyModifier::MOD_CMD} is either {Wx::KeyModifier::MOD_CONTROL} (MSW and Unix) or {Wx::KeyModifier::MOD_META} (Mac), see {Wx::MouseEvent#cmd_down}. See {Wx::KeyModifier} for the full list of modifiers.
     # Notice that this function is easier to use correctly than, for example, {Wx::MouseEvent#control_down} because when using the latter you also have to remember to test that none of the other modifiers is pressed:
     # 
-    #   if ( ControlDown() && !AltDown() && !ShiftDown() && !MetaDown() )
-    #       ... handle Ctrl-XXX ...
+    # ```ruby
+    #   if event.control_down && !event.alt_down && !event.shift_down && !event.meta_down
+    #     # ... handle Ctrl-XXX ...
+    # ```
     # 
     # and forgetting to do it can result in serious program bugs (e.g. program not working with European keyboard layout where AltGr key which is seen by the program as combination of CTRL and ALT is used). On the other hand, you can simply write:
     # 
-    #   if ( GetModifiers() == wxMOD_CONTROL )
-    #       ... handle Ctrl-XXX ...
+    # ```ruby
+    #   if event.get_modifiers == Wx::KeyModifier::MOD_CONTROL
+    #     # ... handle Ctrl-XXX ...
+    # ```
     # 
     # with this function.
     # @return [Integer]
@@ -681,7 +685,7 @@ module Wx
     def initialize(x=0, y=0) end
     
     # Returns a reference to the cursor specified by this event.
-    # @return [void]
+    # @return [Wx::Cursor]
     def get_cursor; end
     alias_method :cursor, :get_cursor
     
@@ -925,18 +929,18 @@ module Wx
   end # PressAndTapEvent
   
   # This event class contains information about key press and release events.
-  # The main information carried by this event is the key being pressed or released. It can be accessed using one of {Wx::KeyEvent#get_unicode_key}, {Wx::KeyEvent#get_key_code} or {Wx::KeyEvent#get_raw_key_code} functions. For the printable characters, {Wx::KeyEvent#get_unicode_key} should be used as it works for any keys, including non-Latin-1 characters that can be entered when using national keyboard layouts. {Wx::KeyEvent#get_key_code} should be used to handle special characters (such as cursor arrows keys or HOME or INS and so on) which correspond to {Wx::KeyCode} enum elements above the WXK_START constant. While {Wx::KeyEvent#get_key_code} also returns the character code for Latin-1 keys for compatibility, it doesn't work for Unicode characters in general and will return WXK_NONE for any non-Latin-1 ones. If both {Wx::KeyEvent#get_unicode_key} and {Wx::KeyEvent#get_key_code} return WXK_NONE then the key has no WXK_xxx mapping and {Wx::KeyEvent#get_raw_key_code} can be used to distinguish between keys, but raw key codes are platform specific. For these reasons, it is recommended to always use {Wx::KeyEvent#get_unicode_key} and only fall back to {Wx::KeyEvent#get_key_code} if {Wx::KeyEvent#get_unicode_key} returned WXK_NONE, meaning that the event corresponds to a non-printable special keys, then optionally check {Wx::KeyEvent#get_raw_key_code} if {Wx::KeyEvent#get_key_code} also returned WXK_NONE or simply ignore that key.
+  # The main information carried by this event is the key being pressed or released. It can be accessed using one of {Wx::KeyEvent#get_unicode_key}, {Wx::KeyEvent#get_key_code} or {Wx::KeyEvent#get_raw_key_code} functions. For the printable characters, {Wx::KeyEvent#get_unicode_key} should be used as it works for any keys, including non-Latin-1 characters that can be entered when using national keyboard layouts. {Wx::KeyEvent#get_key_code} should be used to handle special characters (such as cursor arrows keys or HOME or INS and so on) which correspond to {Wx::KeyCode} enum elements above the {Wx::K_START} constant. While {Wx::KeyEvent#get_key_code} also returns the character code for Latin-1 keys for compatibility, it doesn't work for Unicode characters in general and will return {Wx::K_NONE} for any non-Latin-1 ones. If both {Wx::KeyEvent#get_unicode_key} and {Wx::KeyEvent#get_key_code} return {Wx::K_NONE} then the key has no WXK_xxx mapping and {Wx::KeyEvent#get_raw_key_code} can be used to distinguish between keys, but raw key codes are platform specific. For these reasons, it is recommended to always use {Wx::KeyEvent#get_unicode_key} and only fall back to {Wx::KeyEvent#get_key_code} if {Wx::KeyEvent#get_unicode_key} returned {Wx::K_NONE}, meaning that the event corresponds to a non-printable special keys, then optionally check {Wx::KeyEvent#get_raw_key_code} if {Wx::KeyEvent#get_key_code} also returned {Wx::K_NONE} or simply ignore that key.
   # While these three functions can be used with the events of {Wx::EVT_KEY_DOWN}, {Wx::EVT_KEY_UP} and {Wx::EVT_CHAR} types, the values returned by them are different for the first two events and the last one. For the latter, the key returned corresponds to the character that would appear in e.g. a text zone if the user pressed the key in it. As such, its value depends on the current state of the Shift key and, for the letters, on the state of Caps Lock modifier. For example, if A key is pressed without Shift being held down, {Wx::KeyEvent} of type {Wx::EVT_CHAR} generated for this key press will return (from either {Wx::KeyEvent#get_key_code} or {Wx::KeyEvent#get_unicode_key} as their meanings coincide for ASCII characters) key code of 97 corresponding the ASCII value of a. And if the same key is pressed but with Shift being held (or Caps Lock being active), then the key could would be 65, i.e. ASCII value of capital A.
   # However for the key down and up events the returned key code will instead be A independently of the state of the modifier keys i.e. it depends only on physical key being pressed and is not translated to its logical representation using the current keyboard state. Such untranslated key codes are defined as follows:
   # - For the letters they correspond to the upper case value of the letter.- For the other alphanumeric keys (e.g. 7 or <code>+</code>), the untranslated key code corresponds to the character produced by the key when it is pressed without Shift. E.g. in standard US keyboard layout the untranslated key code for the key <code>=/+</code> in the upper right corner of the keyboard is 61 which is the ASCII value of <code>=</code>.- For the rest of the keys (i.e. special non-printable keys) it is the same as the normal key code as no translation is used anyhow.
   # 
-  # Notice that the first rule applies to all Unicode letters, not just the usual Latin-1 ones. However for non-Latin-1 letters only {Wx::KeyEvent#get_unicode_key} can be used to retrieve the key code as {Wx::KeyEvent#get_key_code} just returns WXK_NONE in this case.
+  # Notice that the first rule applies to all Unicode letters, not just the usual Latin-1 ones. However for non-Latin-1 letters only {Wx::KeyEvent#get_unicode_key} can be used to retrieve the key code as {Wx::KeyEvent#get_key_code} just returns {Wx::K_NONE} in this case.
   # Also, note that {Wx::EVT_CHAR} events are not generated for keys which do not have a wxWidgets mapping, so {Wx::KeyEvent#get_raw_key_code} should never be required for this event.
   # To summarize: you should handle {Wx::EVT_CHAR} if you need the translated key and {Wx::EVT_KEY_DOWN} if you only need the value of the key itself, independent of the current keyboard state.
   # Not all key down events may be generated by the user. As an example, {Wx::EVT_KEY_DOWN} with <code>=</code> key code can be generated using the standard US keyboard layout but not using the German one because the <code>=</code> key corresponds to Shift-0 key combination in this layout and the key code for it is 0, not <code>=</code>. Because of this you should avoid requiring your users to type key events that might be impossible to enter on their keyboard.
   # 
-  # Another difference between key and char events is that another kind of translation is done for the latter ones when the Control key is pressed: char events for ASCII letters in this case carry codes corresponding to the ASCII value of Ctrl-Latter, i.e. 1 for Ctrl-A, 2 for Ctrl-B and so on until 26 for Ctrl-Z. This is convenient for terminal-like applications and can be completely ignored by all the other ones (if you need to handle Ctrl-A it is probably a better idea to use the key event rather than the char one). Notice that currently no translation is done for the presses of <code></code>[, <code>\</code>, <code></code>], <code>^</code> and _ keys which might be mapped to ASCII values from 27 to 31. Since version 2.9.2, the enum values WXK_CONTROL_A - WXK_CONTROL_Z can be used instead of the non-descriptive constant values 1-26.
-  # Finally, modifier keys only generate key events but no char events at all. The modifiers keys are WXK_SHIFT, WXK_CONTROL, WXK_ALT and various WXK_WINDOWS_XXX from {Wx::KeyCode} enum.
+  # Another difference between key and char events is that another kind of translation is done for the latter ones when the Control key is pressed: char events for ASCII letters in this case carry codes corresponding to the ASCII value of Ctrl-Latter, i.e. 1 for Ctrl-A, 2 for Ctrl-B and so on until 26 for Ctrl-Z. This is convenient for terminal-like applications and can be completely ignored by all the other ones (if you need to handle Ctrl-A it is probably a better idea to use the key event rather than the char one). Notice that currently no translation is done for the presses of <code></code>[, <code>\</code>, <code></code>], <code>^</code> and _ keys which might be mapped to ASCII values from 27 to 31. Since version 2.9.2, the enum values {Wx::K_CONTROL}_A - {Wx::K_CONTROL}_Z can be used instead of the non-descriptive constant values 1-26.
+  # Finally, modifier keys only generate key events but no char events at all. The modifiers keys are {Wx::K_SHIFT}, {Wx::K_CONTROL}, {Wx::K_ALT} and various {Wx::K_WINDOWS}_XXX from {Wx::KeyCode} enum.
   # Modifier keys events are special in one additional aspect: usually the keyboard state associated with a key press is well defined, e.g. {Wx::KeyboardState#shift_down} returns true only if the Shift key was held pressed when the key that generated this event itself was pressed. There is an ambiguity for the key press events for Shift key itself however. By convention, it is considered to be already pressed when it is pressed and already released when it is released. In other words, {Wx::EVT_KEY_DOWN} event for the Shift key itself will have {Wx::KeyModifier::MOD_SHIFT} in {Wx::KeyEvent#get_modifiers} and {Wx::KeyEvent#shift_down} will return true while the {Wx::EVT_KEY_UP} event for Shift itself will not have {Wx::KeyModifier::MOD_SHIFT} in its modifiers and {Wx::KeyEvent#shift_down} will return false.
   # <b>Tip:</b> You may discover the key codes and modifiers generated by all the keys on your system interactively by running the Key Event Sample wxWidgets sample and pressing some keys in it.
   # If a key down (EVT_KEY_DOWN) event is caught and the event handler does not call <code>event.Skip()</code> then the corresponding char event (EVT_CHAR) will not happen. This is by design and enables the programs that handle both types of events to avoid processing the same key twice. As a consequence, if you do not want to suppress the {Wx::EVT_CHAR} events for the keys you handle, always call <code>event.Skip()</code> in your {Wx::EVT_KEY_DOWN} handler. Not doing may also prevent accelerators defined using this key from working.
@@ -976,44 +980,34 @@ module Wx
     def initialize(keyEventType=Wx::EVT_NULL) end
     
     # Returns the key code of the key that generated this event.
-    # ASCII symbols return normal ASCII values, while events from special keys such as "left cursor arrow" (WXK_LEFT) return values outside of the ASCII range. See {Wx::KeyCode} for a full list of the virtual key codes.
-    # Note that this method returns a meaningful value only for special non-alphanumeric keys or if the user entered a Latin-1 character (this includes ASCII and the accented letters found in Western European languages but not letters of other alphabets such as e.g. Cyrillic). Otherwise it simply method returns WXK_NONE and {Wx::KeyEvent#get_unicode_key} should be used to obtain the corresponding Unicode character.
-    # Using {Wx::KeyEvent#get_unicode_key} is in general the right thing to do if you are interested in the characters typed by the user, {Wx::KeyEvent#get_key_code} should be only used for special keys (for which {Wx::KeyEvent#get_unicode_key} returns WXK_NONE). To handle both kinds of keys you might write: 
+    # ASCII symbols return normal ASCII values, while events from special keys such as "left cursor arrow" ({Wx::K_LEFT}) return values outside of the ASCII range. See {Wx::KeyCode} for a full list of the virtual key codes.
+    # Note that this method returns a meaningful value only for special non-alphanumeric keys or if the user entered a Latin-1 character (this includes ASCII and the accented letters found in Western European languages but not letters of other alphabets such as e.g. Cyrillic). Otherwise it simply method returns {Wx::K_NONE} and {Wx::KeyEvent#get_unicode_key} should be used to obtain the corresponding Unicode character.
+    # Using {Wx::KeyEvent#get_unicode_key} is in general the right thing to do if you are interested in the characters typed by the user, {Wx::KeyEvent#get_key_code} should be only used for special keys (for which {Wx::KeyEvent#get_unicode_key} returns nil). To handle both kinds of keys you might write: 
+    # ```ruby
+    #   def on_char(event)
+    #      uc = event.get_unicode_key
+    #      if uc
+    #        # It's a "normal" character. Notice that this includes
+    #        # control characters in 1..31 range, e.g. Wx::K_RETURN or
+    #        # Wx::K_BACK, so check for them explicitly.
+    #        if uc.ord >= 32
+    #          Wx.log_message("You pressed '#{uc}'")
+    #        else
+    #          # It's a control character
+    #          ...
+    #        end
+    #      else # No Unicode equivalent.
+    #        # It's a special key, deal with all the known ones:
+    #        case event.get_key_code
+    #        when Wx::K_LEFT, Wx::K_RIGHT
+    #            ... move cursor ...
     # 
-    #   void MyHandler::OnChar(wxKeyEvent& event)
-    #   {
-    #       wxChar uc = event.GetUnicodeKey();
-    #       if ( uc != WXK_NONE )
-    #       {
-    #           // It's a "normal" character. Notice that this includes
-    #           // control characters in 1..31 range, e.g. WXK_RETURN or
-    #           // WXK_BACK, so check for them explicitly.
-    #           if ( uc >= 32 )
-    #           {
-    #               wxLogMessage("You pressed '%c'", uc);
-    #           }
-    #           else
-    #           {
-    #               // It's a control character
-    #               ...
-    #           }
-    #       }
-    #       else // No Unicode equivalent.
-    #       {
-    #           // It's a special key, deal with all the known ones:
-    #           switch ( event.GetKeyCode() )
-    #           {
-    #               case WXK_LEFT:
-    #               case WXK_RIGHT:
-    #                   ... move cursor ...
-    #                   break;
-    #   
-    #               case WXK_F1:
-    #                   ... give help ...
-    #                   break;
-    #           }
-    #       }
-    #   }
+    #        when Wx::K_F1:
+    #            ... give help ...
+    #        end
+    #      end
+    #   end
+    # ```
     # @return [Integer]
     def get_key_code; end
     alias_method :key_code, :get_key_code
@@ -1050,7 +1044,7 @@ module Wx
     alias_method :raw_key_flags, :get_raw_key_flags
     
     # Returns the Unicode character corresponding to this key event.
-    # If the key pressed doesn't have any character value (e.g. a cursor key) this method will return WXK_NONE. In this case you should use {Wx::KeyEvent#get_key_code} to retrieve the value of the key.
+    # If the key pressed doesn't have any character value (e.g. a cursor key) this method will return nil. In this case you should use {Wx::KeyEvent#get_key_code} to retrieve the value of the key.
     # This function is only available in Unicode build, i.e. when {Wx::Setup::USE_UNICODE} is 1.
     # @return [String]
     def get_unicode_key; end
@@ -1086,13 +1080,17 @@ module Wx
     # The return value is a combination of {Wx::KeyModifier::MOD_ALT}, {Wx::KeyModifier::MOD_CONTROL}, {Wx::KeyModifier::MOD_SHIFT} and {Wx::KeyModifier::MOD_META} bit masks. Additionally, {Wx::KeyModifier::MOD_NONE} is defined as 0, i.e. corresponds to no modifiers (see {Wx::KeyEvent#has_any_modifiers}) and {Wx::KeyModifier::MOD_CMD} is either {Wx::KeyModifier::MOD_CONTROL} (MSW and Unix) or {Wx::KeyModifier::MOD_META} (Mac), see {Wx::KeyEvent#cmd_down}. See {Wx::KeyModifier} for the full list of modifiers.
     # Notice that this function is easier to use correctly than, for example, {Wx::KeyEvent#control_down} because when using the latter you also have to remember to test that none of the other modifiers is pressed:
     # 
-    #   if ( ControlDown() && !AltDown() && !ShiftDown() && !MetaDown() )
-    #       ... handle Ctrl-XXX ...
+    # ```ruby
+    #   if event.control_down && !event.alt_down && !event.shift_down && !event.meta_down
+    #     # ... handle Ctrl-XXX ...
+    # ```
     # 
     # and forgetting to do it can result in serious program bugs (e.g. program not working with European keyboard layout where AltGr key which is seen by the program as combination of CTRL and ALT is used). On the other hand, you can simply write:
     # 
-    #   if ( GetModifiers() == wxMOD_CONTROL )
-    #       ... handle Ctrl-XXX ...
+    # ```ruby
+    #   if event.get_modifiers == Wx::KeyModifier::MOD_CONTROL
+    #     # ... handle Ctrl-XXX ...
+    # ```
     # 
     # with this function.
     # @return [Integer]
@@ -1273,45 +1271,38 @@ module Wx
   
   # A paint event is sent when a window's contents needs to be repainted.
   # The handler of this event must create a {Wx::PaintDC} object and use it for painting the window contents. For example: 
-  # 
-  #   void MyWindow::OnPaint(wxPaintEvent& event)
-  #   {
-  #       wxPaintDC dc(this);
-  #   
-  #       DrawMyDocument(dc);
-  #   }
+  # ```ruby
+  #   def on_paint(event)
+  #     self.pain do |dc|
+  #        draw_my_document(dc)
+  #     end
+  #   end
+  # ```
   # 
   # Notice that you must not create other kinds of {Wx::DC} (e.g. {Wx::ClientDC} or {Wx::WindowDC}) in EVT_PAINT handlers and also don't create {Wx::PaintDC} outside of this event handlers.
   # You can optimize painting by retrieving the rectangles that have been damaged and only repainting these. The rectangles are in terms of the client area, and are unscrolled, so you will need to do some calculations using the current view position to obtain logical, scrolled units. Here is an example of using the {Wx::RegionIterator} class: 
-  # 
-  #   // Called when window needs to be repainted.
-  #   void MyWindow::OnPaint(wxPaintEvent& event)
-  #   {
-  #       wxPaintDC dc(this);
-  #   
-  #       // Find Out where the window is scrolled to
-  #       int vbX,vbY;                     // Top left corner of client
-  #       GetViewStart(&vbX,&vbY);
-  #   
-  #       int vX,vY,vW,vH;                 // Dimensions of client area in pixels
-  #       wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
-  #   
-  #       while (upd)
-  #       {
-  #           vX = upd.GetX();
-  #           vY = upd.GetY();
-  #           vW = upd.GetW();
-  #           vH = upd.GetH();
-  #   
-  #           // Alternatively we can do this:
-  #           // wxRect rect(upd.GetRect());
-  #   
-  #           // Repaint this rectangle
-  #           ...some code...
-  #   
-  #           upd ++ ;
-  #       }
-  #   }
+  # ```ruby
+  #   # Called when window needs to be repainted.
+  #   def on_paint(event)
+  #     self.paint do |dc|
+  #       # Find Out where the window has scrolled to
+  #       vb_pt = get_view_start # Top left corner of client
+  #     
+  #       Wx::RegionIterator.for_region(get_update_region) do |region_it|
+  # 
+  #         int vX,vY,vW,vH                 
+  #         wxRegionIterator upd(GetUpdateRegion()) # get the update rect list
+  #     
+  #         region_it.each do |rct|
+  #           # rct == Dimensions of client area to repaint in pixels
+  #     
+  #            # Repaint this rectangle
+  #            ...some code...
+  #         end
+  #       end
+  #     end
+  #   end
+  # ```
   # 
   # Please notice that in general it is impossible to change the drawing of a standard control (such as {Wx::Button}) and so you shouldn't attempt to handle paint events for them as even if it might work on some platforms, this is inherently not portable and won't work everywhere.
   # 
@@ -1447,9 +1438,9 @@ module Wx
     # @param eventType [Integer] 
     # @param active [true,false] 
     # @param id [Integer] 
-    # @param ActivationReason [Reason] 
+    # @param activationReason [Reason] 
     # @return [ActivateEvent]
-    def initialize(eventType=Wx::EVT_NULL, active=true, id=0, ActivationReason=Wx::ActivateEvent::Reason::Reason_Unknown) end
+    def initialize(eventType=Wx::EVT_NULL, active=true, id=0, activationReason=Wx::ActivateEvent::Reason::Reason_Unknown) end
     
     # Returns true if the application or window is being activated, false otherwise.
     # @return [true,false]
@@ -1549,22 +1540,21 @@ module Wx
   # If you don't destroy the window, you should call {Wx::CloseEvent#veto} to let the calling code know that you did not destroy the window. This allows the {Wx::Window#close} function to return true or false depending on whether the close instruction was honoured or not.
   # Example of a {Wx::CloseEvent} handler:
   # 
-  #   void MyFrame::OnClose(wxCloseEvent& event)
-  #   {
-  #       if ( event.CanVeto() && m_bFileNotSaved )
-  #       {
-  #           if ( wxMessageBox("The file has not been saved... continue closing?",
-  #                             "Please confirm",
-  #                             wxICON_QUESTION | wxYES_NO) != wxYES )
-  #           {
-  #               event.Veto();
-  #               return;
-  #           }
-  #       }
+  # ```ruby
+  #   def on_close(event)
+  #     if event.can_veto? && @file_not_saved
+  #       if Wx.message_box("The file has not been saved... continue closing?",
+  #                         "Please confirm",
+  #                         Wx::ICON_QUESTION | Wx::YES_NO) != Wx::YES)
+  #         event.veto
+  #         return
+  #       end
+  #     end
   #   
-  #       Destroy();  // you may also do:  event.Skip();
-  #                   // since the default event handler does call Destroy(), too
-  #   }
+  #     destroy  # you may also do:  event.skip
+  #              # since the default event handler does call #destroy too
+  #   end
+  # ```
   # 
   # See also <code>samples/dialogs</code> for a full example of interrupting closing an application when there are e.g. unsaved files.
   # The EVT_END_SESSION event is slightly different as it is sent by the system when the user session is ending (e.g. because of log out or shutdown) and so all windows are being forcefully closed. At least under MSW, after the handler for this event is executed the program is simply killed by the system. Because of this, the default handler for this event provided by wxWidgets calls all the usual cleanup code (including {Wx::App#on_exit}) so that it could still be executed and exit()s the process itself, without waiting for being killed. If this behaviour is for some reason undesirable, make sure that you define a handler for this event in your {Wx::App}-derived class and do not call <code>event.Skip()</code> in it (but be aware that the system will still kill your application).
@@ -1796,8 +1786,9 @@ module Wx
     
     # Returns the identifier of the button changing state.
     # The return value is 
-    # 
+    # ```
     #   1 << n 
+    # ```
     #  where n is the index of the button changing state, which can also be retrieved using {Wx::JoystickEvent#get_button_ordinal}.
     # Note that for n equal to 1, 2, 3 or 4 there are predefined {Wx::JOY_BUTTONn} constants which can be used for more clarity, however these constants are not defined for the buttons beyond the first four.
     # @return [Integer]
@@ -1949,13 +1940,13 @@ module Wx
     
     # Returns true if the UI element can be checked.
     # For the event handlers that can be used for multiple items, not all of which can be checked, this method can be useful to determine whether to call {Wx::UpdateUIEvent#check} on the event object or not, i.e. the main use case for this method is: 
-    # 
-    #   void MyWindow::OnUpdateUI(wxUpdateUIEvent& event)
-    #   {
-    #       ....
-    #       if ( event.IsCheckable() )
-    #           event.Check(...some condition...);
-    #   }
+    # ```ruby
+    #   def on_update_ui(event)
+    #     ....
+    #     if event.is_checkable
+    #       event.check(...some condition...)
+    #   end
+    # ```
     # @return [true,false]
     def is_checkable; end
     alias_method :checkable?, :is_checkable

data/lib/wx/doc/gen/evt_handler.rb

@@ -21,30 +21,7 @@ module Wx
   
     # Queue event for a later processing.
     # This method is similar to {Wx::EvtHandler#process_event} but while the latter is synchronous, i.e. the event is processed immediately, before the function returns, this one is asynchronous and returns immediately while the event will be processed at some later time (usually during the next event loop iteration).
-    # Another important difference is that this method takes ownership of the event parameter, i.e. it will delete it itself. This implies that the event should be allocated on the heap and that the pointer can't be used any more after the function returns (as it can be deleted at any moment).
-    # {Wx::EvtHandler#queue_event} can be used for inter-thread communication from the worker threads to the main thread, it is safe in the sense that it uses locking internally and avoids the problem mentioned in {Wx::EvtHandler#add_pending_event} documentation by ensuring that the event object is not used by the calling thread any more. Care should still be taken to avoid that some fields of this object are used by it, notably any {Wx::String} members of the event object must not be shallow copies of another {Wx::String} object as this would result in them still using the same string buffer behind the scenes. For example: 
-    # 
-    #   void FunctionInAWorkerThread(const wxString& str)
-    #   {
-    #       wxCommandEvent* evt = new wxCommandEvent;
-    #   
-    #       // NOT evt->SetString(str) as this would be a shallow copy
-    #       evt->SetString(str.c_str()); // make a deep copy
-    #   
-    #       wxTheApp->QueueEvent( evt );
-    #   }
-    # 
-    # Note that you can use {Wx::ThreadEvent} instead of {Wx::CommandEvent} to avoid this problem: 
-    # 
-    #   void FunctionInAWorkerThread(const wxString& str)
-    #   {
-    #       wxThreadEvent evt;
-    #       evt.SetString(str);
-    #   
-    #       // wxThreadEvent::Clone() makes sure that the internal wxString
-    #       // member is not shared by other wxString instances:
-    #       wxTheApp->QueueEvent( evt.Clone() );
-    #   }
+    # Another important difference is that this method takes ownership of the event parameter, i.e. it will delete it itself. This implies that the pointer can't be used any more after the function returns (as it can be deleted at any moment).
     # 
     # Finally notice that this method automatically wakes up the event loop if it is currently idle by calling {wake_up_idle} so there is no need to do it manually when using it.
     # @param event [Wx::Event]  A heap-allocated event to be queued, {Wx::EvtHandler#queue_event} takes ownership of it. This parameter shouldn't be NULL.
@@ -126,9 +103,10 @@ module Wx
     
     # Sets the pointer to the next handler.
     # See {Wx::EvtHandler#process_event} for more info about how the chains of event handlers are internally used. Also remember that {Wx::EvtHandler} uses double-linked lists and thus if you use this function, you should also call {Wx::EvtHandler#set_previous_handler} on the argument passed to this function: 
-    # 
-    #   handlerA->SetNextHandler(handlerB);
-    #   handlerB->SetPreviousHandler(handlerA);
+    # ```ruby
+    #   handlerA.set_next_handler(handlerB)
+    #   handlerB.set_previous_handler(handlerA)
+    # ```
     # @see How Events are Processed 
     # @param handler [Wx::EvtHandler]  The event handler to be set as the next handler. Cannot be NULL.
     # @return [void]
@@ -159,13 +137,13 @@ module Wx
     
     # Add an event filter whose FilterEvent() method will be called for each and every event processed by wxWidgets.
     # The filters are called in LIFO order and {Wx::App} is registered as an event filter by default. The pointer must remain valid until it's removed with {Wx::EvtHandler.remove_filter} and is not deleted by {Wx::EvtHandler}.
-    # @param filter [Wx::EventFilter] 
+    # @param filter [Wx::EventFilter,Wx::App] 
     # @return [void]
     def self.add_filter(filter) end
     
     # Remove a filter previously installed with {Wx::EvtHandler.add_filter}.
     # It's an error to remove a filter that hadn't been previously added or was already removed.
-    # @param filter [Wx::EventFilter] 
+    # @param filter [Wx::EventFilter,Wx::App] 
     # @return [void]
     def self.remove_filter(filter) end
     
@@ -179,19 +157,18 @@ module Wx
     # Method called by {Wx::EvtHandler#process_event} before examining this object event tables.
     # This method can be overridden to hook into the event processing logic as early as possible. You should usually call the base class version when overriding this method, even if {Wx::EvtHandler} itself does nothing here, some derived classes do use this method, e.g. {Wx::Window} implements support for {Wx::Validator} in it.
     # Example: 
-    # 
-    #   class MyClass : public BaseClass // inheriting from wxEvtHandler
-    #   {
+    # ```ruby
+    #   class MyClass < BaseClass # inheriting from Wx::EvtHandler
     #   ...
-    #   protected:
-    #       virtual bool TryBefore(wxEvent& event)
-    #       {
-    #           if ( MyPreProcess(event) )
-    #               return true;
+    #   protected
+    #     def try_before(event)
+    #       if my_pre_process(event)
+    #         return true
     #   
-    #           return BaseClass::TryBefore(event);
-    #       }
-    #   };
+    #       super
+    #     end
+    #   end
+    # ```
     # @see Wx::EvtHandler#process_event 
     # @param event [Wx::Event] 
     # @return [true,false]
@@ -200,19 +177,18 @@ module Wx
     # Method called by {Wx::EvtHandler#process_event} as last resort.
     # This method can be overridden to implement post-processing for the events which were not processed anywhere else.
     # The base class version handles forwarding the unprocessed events to {Wx::App} at {Wx::EvtHandler} level and propagating them upwards the window child-parent chain at {Wx::Window} level and so should usually be called when overriding this method: 
-    # 
-    #   class MyClass : public BaseClass // inheriting from wxEvtHandler
-    #   {
+    # ```ruby
+    #   class MyClass < BaseClass # inheriting from Wx::EvtHandler
     #   ...
-    #   protected:
-    #       virtual bool TryAfter(wxEvent& event)
-    #       {
-    #           if ( BaseClass::TryAfter(event) )
-    #               return true;
-    #   
-    #           return MyPostProcess(event);
-    #       }
-    #   };
+    #   protected
+    #     def try_after(event)
+    #       if super
+    #         return true
+    # 
+    #       my_post_process(event)
+    #     end
+    #   end
+    # ```
     # @see Wx::EvtHandler#process_event 
     # @param event [Wx::Event] 
     # @return [true,false]