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

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]

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

@@ -52,7 +52,7 @@ module Wx
   # This class represents the file chooser dialog.
   # The path and filename are distinct elements of a full file pathname. If path is {Wx::EmptyString}, the current directory will be used. If filename is {Wx::EmptyString}, no default filename will be supplied. The wildcard determines what files are displayed in the file selector, and file extension supplies a type extension for the required filename.
   # The typical usage for the open file dialog is: 
-  # 
+  # ```
   #   void MyFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
   #   {
   #       if (...current content has not been saved...)
@@ -81,9 +81,10 @@ module Wx
   #   
   #       ...
   #   }
+  # ```
   # 
   # The typical usage for the save file dialog is instead somewhat simpler: 
-  # 
+  # ```
   #   void MyFrame::OnSaveAs(wxCommandEvent& WXUNUSED(event))
   #   {
   #       wxFileDialog
@@ -104,16 +105,19 @@ module Wx
   #   
   #       ...
   #   }
+  # ```
   # 
   # == Wildcard Filters
   # 
   # All implementations of the {Wx::FileDialog} provide a wildcard filter. Typing a filename containing wildcards (*, ?) in the filename text item, and clicking on Ok, will result in only those files matching the pattern being displayed. The wildcard may be a specification for multiple types of file with a description for each, such as: 
-  # 
+  # ```
   #   "BMP and GIF files (*.bmp;*.gif)|*.bmp;*.gif|PNG files (*.png)|*.png"
+  # ```
   # 
   # On Mac macOS in the open file dialog the filter choice box is not shown by default. Instead all given wildcards are applied at the same time: So in the above example all bmp, gif and png files are displayed. To enforce the display of the filter choice set the corresponding {Wx::SystemOptions} before calling the file open dialog: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption(wxOSX_FILEDIALOG_ALWAYS_SHOW_TYPES, 1)
+  # ```
   #  But in contrast to Windows and Unix, where the file type choice filters only the selected files, on Mac macOS even in this case the dialog shows all files matching all file types. The files which does not match the currently selected file type are greyed out and are not selectable.
   # 
   # == Dialog Customization

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

@@ -34,7 +34,7 @@ module Wx
     def create(parent, data, title, style=0) end
     
     # Get the {Wx::FindReplaceData} object used by this dialog.
-    # @return [void]
+    # @return [Wx::FindReplaceData]
     def get_data; end
     alias_method :data, :get_data
     

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

@@ -657,6 +657,8 @@ module Wx
   # @see  Wx::SystemSettings 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Font < GDIObject
   
     # Returns a font with the same face/size as the given one but with normal weight and style and not underlined nor stricken through.
@@ -1082,16 +1084,19 @@ module Wx
     #   Creates a font object using the specified font description.
     #   This is the preferred way to create font objects as using this ctor results in more readable code and it is also extensible, e.g. it could continue to be used if support for more font attributes is added in the future. For example, this constructor provides the only way of creating fonts with strike-through style.
     #   Example of creating a font using this ctor: 
-    #   
+    #   ```
     #     wxFont font(wxFontInfo(10).Bold().Underlined());
+    #   ```
     #   @param fontInfo [Wx::FontInfo] 
     #   @return [Font]
     # @overload initialize(pointSize, family, style, weight, underline=false, faceName=(''), encoding=Wx::FontEncoding::FONTENCODING_DEFAULT)
     #   Creates a font object with the specified attributes and size in points.
     #   Notice that the use of this constructor is often more verbose and less readable than using wxFont(const wxFontInfo& font), e.g. the example in that constructor documentation would need to be written as:
     #   
+    #   ```
     #     wxFont font(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,
     #                 wxFONTWEIGHT_BOLD, true);
+    #   ```
     #   
     #   If the desired font does not exist, the closest match will be chosen. Under Windows, only scalable TrueType fonts are used.
     #   @param pointSize [Integer]  Size in points. See {Wx::Font#set_point_size} for more info. Notice that, for historical reasons, the value 70 here is interpreted at {Wx::DEFAULT} and results in creation of the font with the default size and not of a font with the size of 70pt. If you really need the latter, please use SetPointSize(70). Note that this constructor and the matching Create() method overload are the only places in {Wx::Font} API handling {Wx::DEFAULT} specially: neither {Wx::Font#set_point_size} nor the constructor taking {Wx::FontInfo} handle this value in this way.
@@ -1155,12 +1160,15 @@ module Wx
   
   # This class is a helper used for {Wx::Font} creation using named parameter idiom: it allows specifying various {Wx::Font} attributes using the chained calls to its clearly named methods instead of passing them in the fixed order to {Wx::Font} constructors.
   # For example, to create an italic font with the given face name and size you could use: 
-  # 
+  # ```
   #   wxFont font(wxFontInfo(12).FaceName("Helvetica").Italic());
+  # ```
   # 
   # Notice that all of the methods of this object return a reference to the object itself, allowing the calls to them to be chained as in the example above.
   # All methods taking boolean parameters can be used to turn the specified font attribute on or off and turn it on by default.
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class FontInfo < ::Object
   
     # @overload initialize()

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

@@ -15,6 +15,8 @@ module Wx
   # @see  Wx::FontDialog 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class FontData < Object
   
     # Constructor.

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

@@ -25,7 +25,7 @@ module Wx
   class FontDialog < Dialog
   
     # Returns the font data associated with the font dialog.
-    # @return [void]
+    # @return [Wx::FontData]
     def get_font_data; end
     alias_method :font_data, :get_font_data
     

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

@@ -50,7 +50,9 @@ module Wx
   # 
   # The default frame style is for normal, resizable frames. To create a frame which cannot be resized by user, you may use the following combination of styles:
   # 
+  # ```
   #   wxDEFAULT_FRAME_STYLE & ~(wxRESIZE_BORDER | wxMAXIMIZE_BOX)
+  # ```
   # 
   # See also the Window Styles.
   # 
@@ -238,8 +240,6 @@ module Wx
     
     # Sets the widths of the fields in the status bar.
     # The widths of the variable fields are calculated from the total width of all fields, minus the sum of widths of the non-variable fields, divided by the number of variable fields.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes the field widths as parameters.
     # @param n [Integer]  The number of fields in the status bar. It must be the same used in CreateStatusBar.
     # @param widths_field [int]  Must contain an array of n integers, each of which is a status field width in pixels. A value of -1 indicates that the field is variable width; at least one field must be -1. You should delete this array after calling {Wx::Frame#set_status_widths}.
     # @return [void]
@@ -255,8 +255,9 @@ module Wx
     # Returns a {Wx::TaskBarButton} pointer representing the taskbar button of the window under Windows 7 or later. The returned {Wx::TaskBarButton} may be used, if non-NULL, to access the functionality including thumbnail representations, thumbnail toolbars, notification and status overlays, and progress indicators.
     # The returned pointer must not be deleted, it is owned by the frame and will be only deleted when the frame itself is destroyed.
     # This function is not available in the other ports by design, any occurrences of it in the portable code must be guarded by 
-    # 
+    # ```
     #   #ifdef __WXMSW__ 
+    # ```
     #  preprocessor guards.
     # @return [Wx::TaskBarButton]
     def msw_get_task_bar_button; end

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

@@ -40,6 +40,7 @@ module Wx
     # You probably won't use it. See the Note for details.
     # It is seldom used by the application programmer but you will need it if you are writing your own virtual FS. For example you may need something similar to {Wx::MemoryInputStream}, but because {Wx::MemoryInputStream} doesn't free the memory when destroyed and thus passing a memory stream pointer into {Wx::FSFile} constructor would lead to memory leaks, you can write your own class derived from {Wx::FSFile}:
     # 
+    # ```
     #   class wxMyFSFile : public wxFSFile
     #   {
     #       private:
@@ -49,6 +50,7 @@ module Wx
     #           ~wxMyFSFile() {free(m_Mem);}
     #               // of course dtor is virtual ;-)
     #   };
+    # ```
     # 
     # If you are not sure of the meaning of these params, see the description of the GetXXXX() functions.
     # @param stream [IO]  The input stream that will be used to access data
@@ -113,6 +115,8 @@ module Wx
   # @see Wx::StreamBuffer 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class StreamBase < ::Object
   
     # Creates a dummy stream object.
@@ -166,6 +170,8 @@ module Wx
   # 
   # Category:  {Wx::Streams}
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class InputStream < StreamBase
   
     # Creates a dummy input stream.
@@ -230,6 +236,8 @@ module Wx
   # 
   # Category:  {Wx::Streams}
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class OutputStream < StreamBase
   
     # Creates a dummy {Wx::OutputStream} object.