wxruby3 0.9.0.pre.rc.3-x64-mingw-ucrt → 0.9.1-x64-mingw-ucrt

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

@@ -41,25 +41,25 @@ module Wx
     # Returns true if the OnIdle function processing this event requested more processing time.
     # 
     # @see Wx::IdleEvent#request_more 
-    # @return [true,false]
+    # @return [Boolean]
     def more_requested; end
     
     # Tells wxWidgets that more processing is required.
     # This function can be called by an OnIdle handler for a window or window event handler to indicate that {Wx::App::OnIdle} should forward the OnIdle event once more to the application windows.
     # If no window calls this function during OnIdle, then the application will remain in a passive event loop (not calling OnIdle) until a new event is posted to the application by the windowing system.
     # @see Wx::IdleEvent#more_requested 
-    # @param needMore [true,false] 
+    # @param needMore [Boolean] 
     # @return [void]
     def request_more(needMore=true) end
     
     # Static function returning a value specifying how wxWidgets will send idle events: to all windows, or only to those which specify that they will process the events.
     # 
     # @see Wx::IdleEvent.set_mode. 
-    # @return [IdleMode]
+    # @return [Wx::IdleMode]
     def self.get_mode; end
     
     # Static function for specifying how wxWidgets will send idle events: to all windows, or only to those which specify that they will process the events.
-    # @param mode [IdleMode]  Can be one of the {Wx::IdleMode} values. The default is {Wx::IdleMode::IDLE_PROCESS_ALL}.
+    # @param mode [Wx::IdleMode]  Can be one of the {Wx::IdleMode} values. The default is {Wx::IdleMode::IDLE_PROCESS_ALL}.
     # @return [void]
     def self.set_mode(mode) end
     
@@ -76,7 +76,7 @@ module Wx
   class NotifyEvent < CommandEvent
   
     # Constructor (used internally by wxWidgets only).
-    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param eventType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @return [Wx::NotifyEvent]
     def initialize(eventType=Wx::EVT_NULL, id=0) end
@@ -87,7 +87,7 @@ module Wx
     def allow; end
     
     # Returns true if the change is allowed ({Wx::NotifyEvent#veto} hasn't been called) or false otherwise (if it was).
-    # @return [true,false]
+    # @return [Boolean]
     def is_allowed; end
     alias_method :allowed?, :is_allowed
     
@@ -166,7 +166,7 @@ module Wx
   class ScrollEvent < CommandEvent
   
     # Constructor.
-    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param commandType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @param pos [Integer] 
     # @param orientation [Integer] 
@@ -230,7 +230,7 @@ module Wx
   class ScrollWinEvent < Event
   
     # Constructor.
-    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param commandType [Wx::CommandLinkButton::EventType] 
     # @param pos [Integer] 
     # @param orientation [Integer] 
     # @return [Wx::ScrollWinEvent]
@@ -261,7 +261,7 @@ module Wx
   end # ScrollWinEvent
   
   # This event class contains information about the events generated by the mouse: they include mouse buttons press and release events and mouse move events.
-  # All mouse events involving the buttons use {Wx::MOUSE_BTN_LEFT} for the left mouse button, {Wx::MOUSE_BTN_MIDDLE} for the middle one and {Wx::MOUSE_BTN_RIGHT} for the right one. And if the system supports more buttons, the {Wx::MOUSE_BTN_AUX1} and {Wx::MOUSE_BTN_AUX2} events can also be generated. Note that not all mice have even a middle button so a portable application should avoid relying on the events from it (but the right button click can be emulated using the left mouse button with the control key under Mac platforms with a single button mouse).
+  # All mouse events involving the buttons use {Wx::MouseButton::MOUSE_BTN_LEFT} for the left mouse button, {Wx::MouseButton::MOUSE_BTN_MIDDLE} for the middle one and {Wx::MouseButton::MOUSE_BTN_RIGHT} for the right one. And if the system supports more buttons, the {Wx::MouseButton::MOUSE_BTN_AUX1} and {Wx::MouseButton::MOUSE_BTN_AUX2} events can also be generated. Note that not all mice have even a middle button so a portable application should avoid relying on the events from it (but the right button click can be emulated using the left mouse button with the control key under Mac platforms with a single button mouse).
   # For the {Wx::EVT_ENTER_WINDOW} and {Wx::EVT_LEAVE_WINDOW} events purposes, the mouse is considered to be inside the window if it is in the window client area and not inside one of its children. In other words, the parent window receives {Wx::EVT_LEAVE_WINDOW} event not only when the mouse leaves the window entirely but also when it enters one of its children.
   # The position associated with a mouse event is expressed in the window coordinates of the window which generated the event, you can use {Wx::Window#client_to_screen} to convert it to screen coordinates and possibly call {Wx::Window#screen_to_client} next to convert it to window coordinates of another window.
   # Note the difference between methods like {Wx::MouseEvent#left_down} and the inherited {Wx::MouseState#left_is_down}: the former returns true when the event corresponds to the left mouse button click while the latter returns true if the left mouse button is currently being pressed. For example, when the user is dragging the mouse you can use {Wx::MouseEvent::LeftIsDown} to test whether the left mouse button is (still) depressed. Also, by convention, if {Wx::MouseEvent#left_down} returns true, {Wx::MouseEvent::LeftIsDown} will also return true in wxWidgets whatever the underlying GUI behaviour is (which is platform-dependent). The same applies, of course, to other mouse buttons as well.
@@ -363,78 +363,78 @@ module Wx
     # - {Wx::EVT_MOUSEWHEEL} 
     # 
     # - {Wx::EVT_MAGNIFY}
-    # @param mouseEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param mouseEventType [Wx::CommandLinkButton::EventType] 
     # @return [Wx::MouseEvent]
     def initialize(mouseEventType=Wx::EVT_NULL) end
     
     # Returns true if the event was a first extra button double click.
-    # @return [true,false]
+    # @return [Boolean]
     def aux1d_click; end
     
     # Returns true if the first extra button mouse button changed to down.
-    # @return [true,false]
+    # @return [Boolean]
     def aux1down; end
     
     # Returns true if the first extra button mouse button changed to up.
-    # @return [true,false]
+    # @return [Boolean]
     def aux1up; end
     
     # Returns true if the event was a second extra button double click.
-    # @return [true,false]
+    # @return [Boolean]
     def aux2d_click; end
     
     # Returns true if the second extra button mouse button changed to down.
-    # @return [true,false]
+    # @return [Boolean]
     def aux2down; end
     
     # Returns true if the second extra button mouse button changed to up.
-    # @return [true,false]
+    # @return [Boolean]
     def aux2up; end
     
     # Returns true if the event was generated by the specified button.
     # 
     # @see wxMouseState::ButtoinIsDown() 
-    # @param but [MouseButton] 
-    # @return [true,false]
+    # @param but [Wx::MouseButton] 
+    # @return [Boolean]
     def button(but) end
     
     # If the argument is omitted, this returns true if the event was a mouse double click event.
     # Otherwise the argument specifies which double click event was generated (see {Wx::MouseEvent#button} for the possible values).
-    # @param but [MouseButton] 
-    # @return [true,false]
-    def button_d_click(but=Wx::MOUSE_BTN_ANY) end
+    # @param but [Wx::MouseButton] 
+    # @return [Boolean]
+    def button_d_click(but=Wx::MouseButton::MOUSE_BTN_ANY) end
     
     # If the argument is omitted, this returns true if the event was a mouse button down event.
     # Otherwise the argument specifies which button-down event was generated (see {Wx::MouseEvent#button} for the possible values).
-    # @param but [MouseButton] 
-    # @return [true,false]
-    def button_down(but=Wx::MOUSE_BTN_ANY) end
+    # @param but [Wx::MouseButton] 
+    # @return [Boolean]
+    def button_down(but=Wx::MouseButton::MOUSE_BTN_ANY) end
     
     # If the argument is omitted, this returns true if the event was a mouse button up event.
     # Otherwise the argument specifies which button-up event was generated (see {Wx::MouseEvent#button} for the possible values).
-    # @param but [MouseButton] 
-    # @return [true,false]
-    def button_up(but=Wx::MOUSE_BTN_ANY) end
+    # @param but [Wx::MouseButton] 
+    # @return [Boolean]
+    def button_up(but=Wx::MouseButton::MOUSE_BTN_ANY) end
     
     # Returns true if this was a dragging event (motion while a button is depressed).
     # 
     # @see Wx::MouseEvent#moving 
-    # @return [true,false]
+    # @return [Boolean]
     def dragging; end
     
     # Returns true if the mouse was entering the window.
     # 
     # @see Wx::MouseEvent#leaving 
-    # @return [true,false]
+    # @return [Boolean]
     def entering; end
     
-    # Returns the mouse button which generated this event or {Wx::MOUSE_BTN_NONE} if no button is involved (for mouse move, enter or leave event, for example).
-    # Otherwise {Wx::MOUSE_BTN_LEFT} is returned for the left button down, up and double click events, {Wx::MOUSE_BTN_MIDDLE} and {Wx::MOUSE_BTN_RIGHT} for the same events for the middle and the right buttons respectively.
+    # Returns the mouse button which generated this event or {Wx::MouseButton::MOUSE_BTN_NONE} if no button is involved (for mouse move, enter or leave event, for example).
+    # Otherwise {Wx::MouseButton::MOUSE_BTN_LEFT} is returned for the left button down, up and double click events, {Wx::MouseButton::MOUSE_BTN_MIDDLE} and {Wx::MouseButton::MOUSE_BTN_RIGHT} for the same events for the middle and the right buttons respectively.
     # @return [Integer]
     def get_button; end
     
     # Returns the number of mouse clicks for this event: 1 for a simple click, 2 for a double-click, 3 for a triple-click and so on.
-    # Currently this function is implemented only in {Wx::Mac} and returns -1 for the other platforms (you can still distinguish simple clicks from double-clicks as they generate different kinds of events however).
+    # Currently this function is implemented only in wxMac and returns -1 for the other platforms (you can still distinguish simple clicks from double-clicks as they generate different kinds of events however).
     # @return [Integer]
     def get_click_count; end
     alias_method :click_count, :get_click_count
@@ -475,7 +475,7 @@ module Wx
     
     # On Mac, has the user selected "Natural" scrolling in their System Preferences? Currently false on all other OS's.
     # "Natural" scrolling means that content scrolling happens in the opposite direction, and if you are indeed scrolling content then you don't need to use this function because macOS has already inverted the scroll direction. But there can be special situations where you want the mouse wheel action to work always in the same direction and in that case you will need this function.
-    # @return [true,false]
+    # @return [Boolean]
     def is_wheel_inverted; end
     alias_method :wheel_inverted?, :is_wheel_inverted
     
@@ -489,75 +489,75 @@ module Wx
     # Gets the axis the wheel operation concerns.
     # Usually the mouse wheel is used to scroll vertically so {Wx::MouseWheelAxis::MOUSE_WHEEL_VERTICAL} is returned but some mice (and most trackpads) also allow to use the wheel to scroll horizontally in which case {Wx::MouseWheelAxis::MOUSE_WHEEL_HORIZONTAL} is returned.
     # Notice that before wxWidgets 2.9.4 this method returned int.
-    # @return [MouseWheelAxis]
+    # @return [Wx::MouseWheelAxis]
     def get_wheel_axis; end
     alias_method :wheel_axis, :get_wheel_axis
     
     # Returns true if the event was a mouse button event (not necessarily a button down event - that may be tested using {Wx::MouseEvent#button_down}).
-    # @return [true,false]
+    # @return [Boolean]
     def is_button; end
     alias_method :button?, :is_button
     
     # Returns true if the system has been setup to do page scrolling with the mouse wheel instead of line scrolling.
-    # @return [true,false]
+    # @return [Boolean]
     def is_page_scroll; end
     alias_method :page_scroll?, :is_page_scroll
     
     # Returns true if the mouse was leaving the window.
     # 
     # @see Wx::MouseEvent#entering. 
-    # @return [true,false]
+    # @return [Boolean]
     def leaving; end
     
     # Returns true if the event was a left double click.
-    # @return [true,false]
+    # @return [Boolean]
     def left_d_click; end
     
     # Returns true if the left mouse button changed to down.
-    # @return [true,false]
+    # @return [Boolean]
     def left_down; end
     
     # Returns true if the left mouse button changed to up.
-    # @return [true,false]
+    # @return [Boolean]
     def left_up; end
     
     # Returns true if the event is a magnify (i.e. pinch to zoom) event.
     # Such events are currently generated only under macOS.
     # @see Wx::MouseEvent#get_magnification
-    # @return [true,false]
+    # @return [Boolean]
     def magnify; end
     
     # Returns true if the Meta key was down at the time of the event.
-    # @return [true,false]
+    # @return [Boolean]
     def meta_down; end
     
     # Returns true if the event was a middle double click.
-    # @return [true,false]
+    # @return [Boolean]
     def middle_d_click; end
     
     # Returns true if the middle mouse button changed to down.
-    # @return [true,false]
+    # @return [Boolean]
     def middle_down; end
     
     # Returns true if the middle mouse button changed to up.
-    # @return [true,false]
+    # @return [Boolean]
     def middle_up; end
     
     # Returns true if this was a motion event and no mouse buttons were pressed.
     # If any mouse button is held pressed, then this method returns false and {Wx::MouseEvent#dragging} returns true.
-    # @return [true,false]
+    # @return [Boolean]
     def moving; end
     
     # Returns true if the event was a right double click.
-    # @return [true,false]
+    # @return [Boolean]
     def right_d_click; end
     
     # Returns true if the right mouse button changed to down.
-    # @return [true,false]
+    # @return [Boolean]
     def right_down; end
     
     # Returns true if the right mouse button changed to up.
-    # @return [true,false]
+    # @return [Boolean]
     def right_up; end
     
     # Returns the physical mouse position.
@@ -576,23 +576,23 @@ module Wx
     alias_method :y, :get_y
     
     # Returns true if the left mouse button is currently down.
-    # @return [true,false]
+    # @return [Boolean]
     def left_is_down; end
     
     # Returns true if the middle mouse button is currently down.
-    # @return [true,false]
+    # @return [Boolean]
     def middle_is_down; end
     
     # Returns true if the right mouse button is currently down.
-    # @return [true,false]
+    # @return [Boolean]
     def right_is_down; end
     
     # Returns true if the first extra button mouse button is currently down.
-    # @return [true,false]
+    # @return [Boolean]
     def aux1is_down; end
     
     # Returns true if the second extra button mouse button is currently down.
-    # @return [true,false]
+    # @return [Boolean]
     def aux2is_down; end
     
     # @param x [Integer] 
@@ -610,27 +610,27 @@ module Wx
     def set_position(pos) end
     alias_method :position=, :set_position
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_left_down(down) end
     alias_method :left_down=, :set_left_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_middle_down(down) end
     alias_method :middle_down=, :set_middle_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_right_down(down) end
     alias_method :right_down=, :set_right_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_aux1down(down) end
     alias_method :aux1down=, :set_aux1down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_aux2down(down) end
     alias_method :aux2down=, :set_aux2down
@@ -664,67 +664,67 @@ module Wx
     # Returns true if any modifiers at all are pressed.
     # This is equivalent to <code>Wx::MouseEvent#get_modifiers</code> <code>!=</code> {Wx::KeyModifier::MOD_NONE}.
     # Notice that this is different from {Wx::MouseEvent#has_modifiers} method which doesn't take e.g. Shift modifier into account. This method is most suitable for mouse events when any modifier, including Shift, can change the interpretation of the event.
-    # @return [true,false]
+    # @return [Boolean]
     def has_any_modifiers; end
     alias_method :has_any_modifiers?, :has_any_modifiers
     
     # Returns true if Control or Alt are pressed.
     # Checks if Control, Alt or, under macOS only, Command key are pressed (notice that the real Control key is still taken into account under OS X too).
     # This method returns false if only Shift is pressed for compatibility reasons and also because pressing Shift usually doesn't change the interpretation of key events, see {Wx::MouseEvent#has_any_modifiers} if you want to take Shift into account as well.
-    # @return [true,false]
+    # @return [Boolean]
     def has_modifiers; end
     alias_method :has_modifiers?, :has_modifiers
     
     # Returns true if the Control key or Apple/Command key under macOS is pressed.
     # This function doesn't distinguish between right and left control keys.
     # Notice that {Wx::MouseEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def control_down; end
     
     # Returns true if the Control key (also under macOS).
     # This function doesn't distinguish between right and left control keys.
     # Notice that {Wx::MouseEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def raw_control_down; end
     
     # Returns true if the Shift key is pressed.
     # This function doesn't distinguish between right and left shift keys.
     # Notice that {Wx::MouseEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def shift_down; end
     
     # Returns true if the Alt key is pressed.
     # Notice that {Wx::MouseEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def alt_down; end
     
     # Returns true if the key used for command accelerators is pressed.
     # Same as {Wx::MouseEvent#control_down}. Deprecated.
     # Notice that {Wx::MouseEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def cmd_down; end
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_control_down(down) end
     alias_method :control_down=, :set_control_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_raw_control_down(down) end
     alias_method :raw_control_down=, :set_raw_control_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_shift_down(down) end
     alias_method :shift_down=, :set_shift_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_alt_down(down) end
     alias_method :alt_down=, :set_alt_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_meta_down(down) end
     alias_method :meta_down=, :set_meta_down
@@ -772,7 +772,7 @@ module Wx
     
     # Returns true if the cursor specified by this event is a valid cursor.
     # You cannot specify {Wx::NULL_CURSOR} with this event, as it is not considered a valid cursor.
-    # @return [true,false]
+    # @return [Boolean]
     def has_cursor; end
     alias_method :has_cursor?, :has_cursor
     
@@ -799,7 +799,7 @@ module Wx
   
     # Constructor.
     # @param winid [Integer] 
-    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param type [Wx::CommandLinkButton::EventType] 
     # @return [Wx::GestureEvent]
     def initialize(winid=0, type=Wx::EVT_NULL) end
     
@@ -809,12 +809,12 @@ module Wx
     alias_method :position, :get_position
     
     # Returns true if the event was the first in a gesture sequence.
-    # @return [true,false]
+    # @return [Boolean]
     def is_gesture_start; end
     alias_method :gesture_start?, :is_gesture_start
     
     # Returns true if the event was the last in a gesture sequence.
-    # @return [true,false]
+    # @return [Boolean]
     def is_gesture_end; end
     alias_method :gesture_end?, :is_gesture_end
     
@@ -825,13 +825,13 @@ module Wx
     alias_method :position=, :set_position
     
     # Sets the event to be the first in a gesture sequence.
-    # @param isStart [true,false] 
+    # @param isStart [Boolean] 
     # @return [void]
     def set_gesture_start(isStart=true) end
     alias_method :gesture_start=, :set_gesture_start
     
     # Sets the event to be the last in a gesture sequence.
-    # @param isEnd [true,false] 
+    # @param isEnd [Boolean] 
     # @return [void]
     def set_gesture_end(isEnd=true) end
     alias_method :gesture_end=, :set_gesture_end
@@ -1006,7 +1006,7 @@ 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 {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.
+  # 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::KeyCode::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::KeyCode::K_NONE} for any non-Latin-1 ones. If both {Wx::KeyEvent#get_unicode_key} and {Wx::KeyEvent#get_key_code} return {Wx::KeyCode::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::KeyCode::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::KeyCode::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:
   # 
@@ -1014,13 +1014,13 @@ module Wx
   # - 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 {Wx::K_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::KeyCode::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 {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.
+  # 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::KeyCode::K_CONTROL}_A - {Wx::KeyCode::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::KeyCode::K_SHIFT}, {Wx::KeyCode::K_CONTROL}, {Wx::KeyCode::K_ALT} and various {Wx::KeyCode::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.
@@ -1059,14 +1059,14 @@ module Wx
     
     # Constructor.
     # Currently, the only valid event types are {Wx::EVT_CHAR} and {Wx::EVT_CHAR_HOOK}.
-    # @param keyEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param keyEventType [Wx::CommandLinkButton::EventType] 
     # @return [Wx::KeyEvent]
     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" ({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: 
+    # ASCII symbols return normal ASCII values, while events from special keys such as "left cursor arrow" ({Wx::KeyCode::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::KeyCode::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 {Wx::KeyCode::K_NONE}). To handle both kinds of keys you might write: 
     # ```ruby
     #   def on_char(event)
     #      uc = event.get_unicode_key
@@ -1098,12 +1098,12 @@ module Wx
     
     # Returns true if the key is in the given key category.
     # @param category [Integer]  A bitwise combination of named {Wx::KeyCategoryFlags} constants.
-    # @return [true,false]
+    # @return [Boolean]
     def is_key_in_category(category) end
     alias_method :key_in_category?, :is_key_in_category
     
     # Returns true if this event is an auto-repeat of the key, false if this is the initial key press.
-    # @return [true,false]
+    # @return [Boolean]
     def is_auto_repeat; end
     alias_method :auto_repeat?, :is_auto_repeat
     
@@ -1112,7 +1112,7 @@ module Wx
     # Under MSW, the raw key code is the value of wParam parameter of the corresponding message.
     # Under GTK, the raw key code is the keyval field of the corresponding GDK event.
     # Under macOS, the raw key code is the keyCode field of the corresponding NSEvent.
-    # Currently the raw key codes are not supported by all ports, use #ifdef {Wx::HAS_RAW_KEY_CODES} to determine if this feature is available.
+    # Currently the raw key codes are not supported by all ports.
     # @return [Integer]
     def get_raw_key_code; end
     alias_method :raw_key_code, :get_raw_key_code
@@ -1122,13 +1122,13 @@ module Wx
     # Under MSW, the raw flags are just the value of lParam parameter of the corresponding message.
     # Under GTK, the raw flags contain the hardware_keycode field of the corresponding GDK event.
     # Under macOS, the raw flags contain the modifiers state.
-    # Currently the raw key flags are not supported by all ports, use #ifdef {Wx::HAS_RAW_KEY_CODES} to determine if this feature is available.
+    # Currently the raw key flags are not supported by all ports.
     # @return [Integer]
     def get_raw_key_flags; end
     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 nil. 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 {Wx::KeyCode::K_NONE}. 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
@@ -1156,7 +1156,7 @@ module Wx
     
     # Returns true if {Wx::KeyEvent#do_allow_next_event} had been called, false by default.
     # This method is used by wxWidgets itself to determine whether the normal key events should be generated after {Wx::EVT_CHAR_HOOK} processing.
-    # @return [true,false]
+    # @return [Boolean]
     def is_next_event_allowed; end
     alias_method :next_event_allowed?, :is_next_event_allowed
     
@@ -1184,73 +1184,73 @@ module Wx
     # Returns true if any modifiers at all are pressed.
     # This is equivalent to <code>Wx::KeyEvent#get_modifiers</code> <code>!=</code> {Wx::KeyModifier::MOD_NONE}.
     # Notice that this is different from {Wx::KeyEvent#has_modifiers} method which doesn't take e.g. Shift modifier into account. This method is most suitable for mouse events when any modifier, including Shift, can change the interpretation of the event.
-    # @return [true,false]
+    # @return [Boolean]
     def has_any_modifiers; end
     alias_method :has_any_modifiers?, :has_any_modifiers
     
     # Returns true if Control or Alt are pressed.
     # Checks if Control, Alt or, under macOS only, Command key are pressed (notice that the real Control key is still taken into account under OS X too).
     # This method returns false if only Shift is pressed for compatibility reasons and also because pressing Shift usually doesn't change the interpretation of key events, see {Wx::KeyEvent#has_any_modifiers} if you want to take Shift into account as well.
-    # @return [true,false]
+    # @return [Boolean]
     def has_modifiers; end
     alias_method :has_modifiers?, :has_modifiers
     
     # Returns true if the Control key or Apple/Command key under macOS is pressed.
     # This function doesn't distinguish between right and left control keys.
     # Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def control_down; end
     
     # Returns true if the Control key (also under macOS).
     # This function doesn't distinguish between right and left control keys.
     # Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def raw_control_down; end
     
     # Returns true if the Shift key is pressed.
     # This function doesn't distinguish between right and left shift keys.
     # Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def shift_down; end
     
     # Returns true if the Meta/Windows/Apple key is pressed.
     # This function tests the state of the key traditionally called Meta under Unix systems, Windows keys under MSW Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
     # @see Wx::KeyEvent#cmd_down 
-    # @return [true,false]
+    # @return [Boolean]
     def meta_down; end
     
     # Returns true if the Alt key is pressed.
     # Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def alt_down; end
     
     # Returns true if the key used for command accelerators is pressed.
     # Same as {Wx::KeyEvent#control_down}. Deprecated.
     # Notice that {Wx::KeyEvent#get_modifiers} should usually be used instead of this one.
-    # @return [true,false]
+    # @return [Boolean]
     def cmd_down; end
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_control_down(down) end
     alias_method :control_down=, :set_control_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_raw_control_down(down) end
     alias_method :raw_control_down=, :set_raw_control_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_shift_down(down) end
     alias_method :shift_down=, :set_shift_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_alt_down(down) end
     alias_method :alt_down=, :set_alt_down
     
-    # @param down [true,false] 
+    # @param down [Boolean] 
     # @return [void]
     def set_meta_down(down) end
     alias_method :meta_down=, :set_meta_down
@@ -1378,10 +1378,6 @@ module Wx
   #       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
   #     
@@ -1473,7 +1469,7 @@ module Wx
   class FocusEvent < Event
   
     # Constructor.
-    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param eventType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @return [Wx::FocusEvent]
     def initialize(eventType=Wx::EVT_NULL, id=0) end
@@ -1531,22 +1527,22 @@ module Wx
     end # Reason
     
     # Constructor.
-    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
-    # @param active [true,false] 
+    # @param eventType [Wx::CommandLinkButton::EventType] 
+    # @param active [Boolean] 
     # @param id [Integer] 
-    # @param activationReason [Reason] 
+    # @param activationReason [Wx::wxActivateEvent::Reason] 
     # @return [Wx::ActivateEvent]
     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]
+    # @return [Boolean]
     def get_active; end
     alias_method :active, :get_active
     
     # Allows checking if the window was activated by clicking it with the mouse or in some other way.
     # This method is currently only implemented in wxMSW and returns Reason_Mouse there if the window was activated by a mouse click and Reason_Unknown if it was activated in any other way (e.g. from keyboard or programmatically).
     # Under all the other platforms, Reason_Unknown is always returned.
-    # @return [Reason]
+    # @return [Wx::wxActivateEvent::Reason]
     def get_activation_reason; end
     alias_method :activation_reason, :get_activation_reason
     
@@ -1611,7 +1607,7 @@ module Wx
   class MenuEvent < Event
   
     # Constructor.
-    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param type [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @param menu [Wx::Menu] 
     # @return [Wx::MenuEvent]
@@ -1632,7 +1628,7 @@ module Wx
     
     # Returns true if the menu which is being opened or closed is a popup menu, false if it is a normal one.
     # This method should only be used with the OPEN and CLOSE events.
-    # @return [true,false]
+    # @return [Boolean]
     def is_popup; end
     alias_method :popup?, :is_popup
     
@@ -1684,43 +1680,43 @@ module Wx
   class CloseEvent < Event
   
     # Constructor.
-    # @param commandEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param commandEventType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @return [Wx::CloseEvent]
     def initialize(commandEventType=Wx::EVT_NULL, id=0) end
     
     # Returns true if you can veto a system shutdown or a window close event.
     # Vetoing a window close event is not possible if the calling code wishes to force the application to exit, and so this function must be called to check this.
-    # @return [true,false]
+    # @return [Boolean]
     def can_veto; end
     alias_method :can_veto?, :can_veto
     
     # Returns true if the user is just logging off or false if the system is shutting down.
     # This method can only be called for end session and query end session events, it doesn't make sense for close window event.
-    # @return [true,false]
+    # @return [Boolean]
     def get_logging_off; end
     alias_method :logging_off, :get_logging_off
     
     # Sets the 'can veto' flag.
-    # @param canVeto [true,false] 
+    # @param canVeto [Boolean] 
     # @return [void]
     def set_can_veto(canVeto) end
     alias_method :can_veto=, :set_can_veto
     
     # Sets the 'logging off' flag.
-    # @param loggingOff [true,false] 
+    # @param loggingOff [Boolean] 
     # @return [void]
     def set_logging_off(loggingOff) end
     alias_method :logging_off=, :set_logging_off
     
     # Call this from your event handler to veto a system shutdown or to signal to the calling application that a window close did not happen.
     # You can only veto a shutdown if {Wx::CloseEvent#can_veto} returns true.
-    # @param veto [true,false] 
+    # @param veto [Boolean] 
     # @return [void]
     def veto(veto=true) end
     
     # Returns whether the Veto flag was set.
-    # @return [true,false]
+    # @return [Boolean]
     def get_veto; end
     
   end # CloseEvent
@@ -1746,18 +1742,18 @@ module Wx
   
     # Constructor.
     # @param winid [Integer] 
-    # @param show [true,false] 
+    # @param show [Boolean] 
     # @return [Wx::ShowEvent]
     def initialize(winid=0, show=false) end
     
     # Set whether the windows was shown or hidden.
-    # @param show [true,false] 
+    # @param show [Boolean] 
     # @return [void]
     def set_show(show) end
     alias_method :show=, :set_show
     
     # Return true if the window has been shown, false if it has been hidden.
-    # @return [true,false]
+    # @return [Boolean]
     def is_shown; end
     alias_method :shown?, :is_shown
     
@@ -1783,12 +1779,12 @@ module Wx
   
     # Constructor.
     # @param id [Integer] 
-    # @param iconized [true,false] 
+    # @param iconized [Boolean] 
     # @return [Wx::IconizeEvent]
     def initialize(id=0, iconized=true) end
     
     # Returns true if the frame has been iconized, false if it has been restored.
-    # @return [true,false]
+    # @return [Boolean]
     def is_iconized; end
     alias_method :iconized?, :is_iconized
     
@@ -1843,12 +1839,12 @@ module Wx
   
     # Constructor.
     # @param id [Integer] 
-    # @param fullscreen [true,false] 
+    # @param fullscreen [Boolean] 
     # @return [Wx::FullScreenEvent]
     def initialize(id=0, fullscreen=true) end
     
     # Returns true if the frame entered full screen, false if exited full screen.
-    # @return [true,false]
+    # @return [Boolean]
     def is_full_screen; end
     alias_method :full_screen?, :is_full_screen
     
@@ -1879,7 +1875,7 @@ module Wx
   class JoystickEvent < Event
   
     # Constructor.
-    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param eventType [Wx::CommandLinkButton::EventType] 
     # @param state [Integer] 
     # @param joystick [Integer] 
     # @param change [Integer] 
@@ -1888,17 +1884,17 @@ module Wx
     
     # Returns true if the event was a down event from the specified button (or any button).
     # @param button [Integer]  Can be {Wx::JOY_BUTTONn} where n is 1, 2, 3 or 4; or {Wx::JOY_BUTTON_ANY} to indicate any button down event.
-    # @return [true,false]
+    # @return [Boolean]
     def button_down(button=Wx::JOY_BUTTON_ANY) end
     
     # Returns true if the specified button (or any button) was in a down state.
     # @param button [Integer]  Can be {Wx::JOY_BUTTONn} where n is 1, 2, 3 or 4; or {Wx::JOY_BUTTON_ANY} to indicate any button down event.
-    # @return [true,false]
+    # @return [Boolean]
     def button_is_down(button=Wx::JOY_BUTTON_ANY) end
     
     # Returns true if the event was an up event from the specified button (or any button).
     # @param button [Integer]  Can be {Wx::JOY_BUTTONn} where n is 1, 2, 3 or 4; or {Wx::JOY_BUTTON_ANY} to indicate any button down event.
-    # @return [true,false]
+    # @return [Boolean]
     def button_up(button=Wx::JOY_BUTTON_ANY) end
     
     # Returns the identifier of the button changing state.
@@ -1943,17 +1939,17 @@ module Wx
     alias_method :z_position, :get_z_position
     
     # Returns true if this was a button up or down event (not 'is any button down?').
-    # @return [true,false]
+    # @return [Boolean]
     def is_button; end
     alias_method :button?, :is_button
     
     # Returns true if this was an x, y move event.
-    # @return [true,false]
+    # @return [Boolean]
     def is_move; end
     alias_method :move?, :is_move
     
     # Returns true if this was a z move event.
-    # @return [true,false]
+    # @return [Boolean]
     def is_z_move; end
     alias_method :z_move?, :is_z_move
     
@@ -1981,7 +1977,7 @@ module Wx
   class DropFilesEvent < Event
   
     # Constructor.
-    # @param id [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param id [Wx::CommandLinkButton::EventType] 
     # @param noFiles [Integer] 
     # @param files [String] 
     # @return [Wx::DropFilesEvent]
@@ -2041,22 +2037,22 @@ module Wx
     def initialize(commandId=0) end
     
     # Check or uncheck the UI element.
-    # @param check [true,false] 
+    # @param check [Boolean] 
     # @return [void]
     def check(check) end
     
     # Enable or disable the UI element.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable(enable) end
     
     # Returns true if the UI element should be checked.
-    # @return [true,false]
+    # @return [Boolean]
     def get_checked; end
     alias_method :checked, :get_checked
     
     # Returns true if the UI element should be enabled.
-    # @return [true,false]
+    # @return [Boolean]
     def get_enabled; end
     alias_method :enabled, :get_enabled
     
@@ -2069,35 +2065,35 @@ module Wx
     #       event.check(...some condition...)
     #   end
     # ```
-    # @return [true,false]
+    # @return [Boolean]
     def is_checkable; end
     alias_method :checkable?, :is_checkable
     
     # Returns true if the application has called {Wx::UpdateUIEvent#check}.
     # For wxWidgets internal use only.
-    # @return [true,false]
+    # @return [Boolean]
     def get_set_checked; end
     alias_method :set_checked, :get_set_checked
     
     # Returns true if the application has called {Wx::UpdateUIEvent#enable}.
     # For wxWidgets internal use only.
-    # @return [true,false]
+    # @return [Boolean]
     def get_set_enabled; end
     alias_method :set_enabled, :get_set_enabled
     
     # Returns true if the application has called {Wx::UpdateUIEvent#show}.
     # For wxWidgets internal use only.
-    # @return [true,false]
+    # @return [Boolean]
     def get_set_shown; end
     alias_method :set_shown, :get_set_shown
     
     # Returns true if the application has called {Wx::UpdateUIEvent#set_text}.
     # For wxWidgets internal use only.
-    # @return [true,false]
+    # @return [Boolean]
     def get_set_text; end
     
     # Returns true if the UI element should be shown.
-    # @return [true,false]
+    # @return [Boolean]
     def get_shown; end
     alias_method :shown, :get_shown
     
@@ -2113,7 +2109,7 @@ module Wx
     alias_method :text=, :set_text
     
     # Show or hide the UI element.
-    # @param show [true,false] 
+    # @param show [Boolean] 
     # @return [void]
     def show(show) end
     
@@ -2123,13 +2119,13 @@ module Wx
     # @see  Wx::UpdateUIEvent.set_update_interval
     # @see  Wx::UpdateUIEvent.set_mode 
     # @param window [Wx::Window] 
-    # @return [true,false]
+    # @return [Boolean]
     def self.can_update(window) end
     
     # Static function returning a value specifying how wxWidgets will send update events: to all windows, or only to those which specify that they will process the events.
     # 
     # @see Wx::UpdateUIEvent.set_mode 
-    # @return [UpdateUIMode]
+    # @return [Wx::UpdateUIMode]
     def self.get_mode; end
     
     # Returns the current interval between updates in milliseconds.
@@ -2147,7 +2143,7 @@ module Wx
     def self.reset_update_time; end
     
     # Specify how wxWidgets will send update events: to all windows, or only to those which specify that they will process the events.
-    # @param mode [UpdateUIMode]  this parameter may be one of the {Wx::UpdateUIMode} enumeration values. The default mode is {Wx::UpdateUIMode::UPDATE_UI_PROCESS_ALL}.
+    # @param mode [Wx::UpdateUIMode]  this parameter may be one of the {Wx::UpdateUIMode} enumeration values. The default mode is {Wx::UpdateUIMode::UPDATE_UI_PROCESS_ALL}.
     # @return [void]
     def self.set_mode(mode) end
     
@@ -2352,12 +2348,12 @@ module Wx
     # @return [Wx::QueryNewPaletteEvent]
     def initialize(winid=0) end
     
-    # @param realized [true,false] 
+    # @param realized [Boolean] 
     # @return [void]
     def set_palette_realized(realized) end
     alias_method :palette_realized=, :set_palette_realized
     
-    # @return [true,false]
+    # @return [Boolean]
     def get_palette_realized; end
     alias_method :palette_realized, :get_palette_realized
     
@@ -2418,18 +2414,18 @@ module Wx
     alias_method :current_focus, :get_current_focus
     
     # Returns true if the navigation was in the forward direction.
-    # @return [true,false]
+    # @return [Boolean]
     def get_direction; end
     alias_method :direction, :get_direction
     
     # Returns true if the navigation event was from a tab key.
     # This is required for proper navigation over radio buttons.
-    # @return [true,false]
+    # @return [Boolean]
     def is_from_tab; end
     alias_method :from_tab?, :is_from_tab
     
     # Returns true if the navigation event represents a window change (for example, from Ctrl-Page Down in a notebook).
-    # @return [true,false]
+    # @return [Boolean]
     def is_window_change; end
     alias_method :window_change?, :is_window_change
     
@@ -2440,7 +2436,7 @@ module Wx
     alias_method :current_focus=, :set_current_focus
     
     # Sets the direction to forward if direction is true, or backward if false.
-    # @param direction [true,false] 
+    # @param direction [Boolean] 
     # @return [void]
     def set_direction(direction) end
     alias_method :direction=, :set_direction
@@ -2453,13 +2449,13 @@ module Wx
     alias_method :flags=, :set_flags
     
     # Marks the navigation event as from a tab key.
-    # @param fromTab [true,false] 
+    # @param fromTab [Boolean] 
     # @return [void]
     def set_from_tab(fromTab) end
     alias_method :from_tab=, :set_from_tab
     
     # Marks the event as a window change event.
-    # @param windowChange [true,false] 
+    # @param windowChange [Boolean] 
     # @return [void]
     def set_window_change(windowChange) end
     alias_method :window_change=, :set_window_change
@@ -2566,17 +2562,17 @@ module Wx
     end # Origin
     
     # Constructor.
-    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param type [Wx::CommandLinkButton::EventType] 
     # @param winid [Integer] 
     # @param pt [Array(Integer, Integer), Wx::Point] 
-    # @param origin [Wx::HelpEvent::Origin] 
+    # @param origin [Wx::wxHelpEvent::Origin] 
     # @return [Wx::HelpEvent]
     def initialize(type=Wx::EVT_NULL, winid=0, pt=Wx::DEFAULT_POSITION, origin=Wx::HelpEvent::Origin::Origin_Unknown) end
     
     # Returns the origin of the help event which is one of the {Wx::HelpEvent::Origin} values.
     # The application may handle events generated using the keyboard or mouse differently, e.g. by using {get_mouse_position} for the mouse events.
     # @see Wx::HelpEvent#set_origin 
-    # @return [Wx::HelpEvent::Origin]
+    # @return [Wx::wxHelpEvent::Origin]
     def get_origin; end
     alias_method :origin, :get_origin
     
@@ -2589,7 +2585,7 @@ module Wx
     # Set the help event origin, only used internally by wxWidgets normally.
     # 
     # @see Wx::HelpEvent#get_origin 
-    # @param origin [Wx::HelpEvent::Origin] 
+    # @param origin [Wx::wxHelpEvent::Origin] 
     # @return [void]
     def set_origin(origin) end
     alias_method :origin=, :set_origin
@@ -2628,7 +2624,7 @@ module Wx
   class ClipboardTextEvent < CommandEvent
   
     # Constructor.
-    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param commandType [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @return [Wx::ClipboardTextEvent]
     def initialize(commandType=Wx::EVT_NULL, id=0) end
@@ -2655,7 +2651,7 @@ module Wx
   class ContextMenuEvent < CommandEvent
   
     # Constructor.
-    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @param type [Wx::CommandLinkButton::EventType] 
     # @param id [Integer] 
     # @param pos [Array(Integer, Integer), Wx::Point] 
     # @return [Wx::ContextMenuEvent]