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

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

@@ -15,6 +15,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::IdleEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_idle}(meth = nil, &block): Process a {Wx::EVT_IDLE} event. 
   # 
   # === 
@@ -34,7 +35,7 @@ module Wx
   class IdleEvent < Event
   
     # Constructor.
-    # @return [IdleEvent]
+    # @return [Wx::IdleEvent]
     def initialize; end
     
     # Returns true if the OnIdle function processing this event requested more processing time.
@@ -75,9 +76,9 @@ module Wx
   class NotifyEvent < CommandEvent
   
     # Constructor (used internally by wxWidgets only).
-    # @param eventType [Integer] 
+    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
-    # @return [NotifyEvent]
+    # @return [Wx::NotifyEvent]
     def initialize(eventType=Wx::EVT_NULL, id=0) end
     
     # This is the opposite of {Wx::NotifyEvent#veto}: it explicitly allows the event to be processed.
@@ -111,25 +112,45 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ScrollEvent} events.
   # Event handler methods: except for this, the macros behave exactly the same. 
+  # 
   # - {Wx::EvtHandler#evt_scroll}(meth = nil, &block): Process all scroll events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_top}(meth = nil, &block): Process {Wx::EVT_SCROLL_TOP} scroll-to-top events (minimum position). 
+  # 
   # - {Wx::EvtHandler#evt_scroll_bottom}(meth = nil, &block): Process {Wx::EVT_SCROLL_BOTTOM} scroll-to-bottom events (maximum position). 
+  # 
   # - {Wx::EvtHandler#evt_scroll_lineup}(meth = nil, &block): Process {Wx::EVT_SCROLL_LINEUP} line up events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_linedown}(meth = nil, &block): Process {Wx::EVT_SCROLL_LINEDOWN} line down events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_pageup}(meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEUP} page up events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_pagedown}(meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEDOWN} page down events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_thumbtrack}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBTRACK} thumbtrack events (frequent events sent as the user drags the thumbtrack). 
+  # 
   # - {Wx::EvtHandler#evt_scroll_thumbrelease}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBRELEASE} thumb release events. 
+  # 
   # - {Wx::EvtHandler#evt_scroll_changed}(meth = nil, &block): Process {Wx::EVT_SCROLL_CHANGED} end of scrolling events (MSW only). 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll}(id, meth = nil, &block): Process all scroll events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_top}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_TOP} scroll-to-top events (minimum position). 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_bottom}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_BOTTOM} scroll-to-bottom events (maximum position). 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_lineup}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_LINEUP} line up events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_linedown}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_LINEDOWN} line down events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_pageup}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEUP} page up events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_pagedown}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_PAGEDOWN} page down events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_thumbtrack}(id, meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBTRACK} thumbtrack events (frequent events sent as the user drags the thumbtrack). 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_thumbrelease}(meth = nil, &block): Process {Wx::EVT_SCROLL_THUMBRELEASE} thumb release events. 
+  # 
   # - {Wx::EvtHandler#evt_command_scroll_changed}(meth = nil, &block): Process {Wx::EVT_SCROLL_CHANGED} end of scrolling events (MSW only). 
   # 
   # === 
@@ -145,11 +166,11 @@ module Wx
   class ScrollEvent < CommandEvent
   
     # Constructor.
-    # @param commandType [Integer] 
+    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
     # @param pos [Integer] 
     # @param orientation [Integer] 
-    # @return [ScrollEvent]
+    # @return [Wx::ScrollEvent]
     def initialize(commandType=Wx::EVT_NULL, id=0, pos=0, orientation=0) end
     
     # Returns {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL}, depending on the orientation of the scrollbar.
@@ -180,14 +201,23 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ScrollWinEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_scrollwin}(meth = nil, &block): Process all scroll events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_top}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_TOP} scroll-to-top events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_bottom}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_BOTTOM} scroll-to-bottom events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_lineup}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_LINEUP} line up events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_linedown}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_LINEDOWN} line down events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_pageup}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_PAGEUP} page up events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_pagedown}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_PAGEDOWN} page down events. 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_thumbtrack}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_THUMBTRACK} thumbtrack events (frequent events sent as the user drags the thumbtrack). 
+  # 
   # - {Wx::EvtHandler#evt_scrollwin_thumbrelease}(meth = nil, &block): Process {Wx::EVT_SCROLLWIN_THUMBRELEASE} thumb release events. 
   # 
   # === 
@@ -200,10 +230,10 @@ module Wx
   class ScrollWinEvent < Event
   
     # Constructor.
-    # @param commandType [Integer] 
+    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param pos [Integer] 
     # @param orientation [Integer] 
-    # @return [ScrollWinEvent]
+    # @return [Wx::ScrollWinEvent]
     def initialize(commandType=Wx::EVT_NULL, pos=0, orientation=0) end
     
     # Returns {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL}, depending on the orientation of the scrollbar.
@@ -240,26 +270,47 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MouseEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_left_down}(meth = nil, &block): Process a {Wx::EVT_LEFT_DOWN} event. The handler of this event should normally call event.Skip() to allow the default processing to take place as otherwise the window under mouse wouldn't get the focus. 
+  # 
   # - {Wx::EvtHandler#evt_left_up}(meth = nil, &block): Process a {Wx::EVT_LEFT_UP} event. 
+  # 
   # - {Wx::EvtHandler#evt_left_dclick}(meth = nil, &block): Process a {Wx::EVT_LEFT_DCLICK} event. 
+  # 
   # - {Wx::EvtHandler#evt_middle_down}(meth = nil, &block): Process a {Wx::EVT_MIDDLE_DOWN} event. 
+  # 
   # - {Wx::EvtHandler#evt_middle_up}(meth = nil, &block): Process a {Wx::EVT_MIDDLE_UP} event. 
+  # 
   # - {Wx::EvtHandler#evt_middle_dclick}(meth = nil, &block): Process a {Wx::EVT_MIDDLE_DCLICK} event. 
+  # 
   # - {Wx::EvtHandler#evt_right_down}(meth = nil, &block): Process a {Wx::EVT_RIGHT_DOWN} event. 
+  # 
   # - {Wx::EvtHandler#evt_right_up}(meth = nil, &block): Process a {Wx::EVT_RIGHT_UP} event. 
+  # 
   # - {Wx::EvtHandler#evt_right_dclick}(meth = nil, &block): Process a {Wx::EVT_RIGHT_DCLICK} event. 
+  # 
   # - EVT_MOUSE_AUX1_DOWN(func): Process a {Wx::EVT_AUX1_DOWN} event. 
+  # 
   # - EVT_MOUSE_AUX1_UP(func): Process a {Wx::EVT_AUX1_UP} event. 
+  # 
   # - EVT_MOUSE_AUX1_DCLICK(func): Process a {Wx::EVT_AUX1_DCLICK} event. 
+  # 
   # - EVT_MOUSE_AUX2_DOWN(func): Process a {Wx::EVT_AUX2_DOWN} event. 
+  # 
   # - EVT_MOUSE_AUX2_UP(func): Process a {Wx::EVT_AUX2_UP} event. 
+  # 
   # - EVT_MOUSE_AUX2_DCLICK(func): Process a {Wx::EVT_AUX2_DCLICK} event. 
+  # 
   # - {Wx::EvtHandler#evt_motion}(meth = nil, &block): Process a {Wx::EVT_MOTION} event. 
+  # 
   # - {Wx::EvtHandler#evt_enter_window}(meth = nil, &block): Process a {Wx::EVT_ENTER_WINDOW} event. 
+  # 
   # - {Wx::EvtHandler#evt_leave_window}(meth = nil, &block): Process a {Wx::EVT_LEAVE_WINDOW} event. 
+  # 
   # - {Wx::EvtHandler#evt_mousewheel}(meth = nil, &block): Process a {Wx::EVT_MOUSEWHEEL} event. 
+  # 
   # - {Wx::EvtHandler#evt_mouse_events}(meth = nil, &block): Process all mouse events. 
+  # 
   # - {Wx::EvtHandler#evt_magnify}(meth = nil, &block): Process a {Wx::EVT_MAGNIFY} event (new since wxWidgets 3.1.0). 
   # 
   # === 
@@ -274,27 +325,46 @@ module Wx
     # Valid event types are:
     # 
     # - {Wx::EVT_ENTER_WINDOW} 
+    # 
     # - {Wx::EVT_LEAVE_WINDOW} 
+    # 
     # - {Wx::EVT_LEFT_DOWN} 
+    # 
     # - {Wx::EVT_LEFT_UP} 
+    # 
     # - {Wx::EVT_LEFT_DCLICK} 
+    # 
     # - {Wx::EVT_MIDDLE_DOWN} 
+    # 
     # - {Wx::EVT_MIDDLE_UP} 
+    # 
     # - {Wx::EVT_MIDDLE_DCLICK} 
+    # 
     # - {Wx::EVT_RIGHT_DOWN} 
+    # 
     # - {Wx::EVT_RIGHT_UP} 
+    # 
     # - {Wx::EVT_RIGHT_DCLICK} 
+    # 
     # - {Wx::EVT_AUX1_DOWN} 
+    # 
     # - {Wx::EVT_AUX1_UP} 
+    # 
     # - {Wx::EVT_AUX1_DCLICK} 
+    # 
     # - {Wx::EVT_AUX2_DOWN} 
+    # 
     # - {Wx::EVT_AUX2_UP} 
+    # 
     # - {Wx::EVT_AUX2_DCLICK} 
+    # 
     # - {Wx::EVT_MOTION} 
+    # 
     # - {Wx::EVT_MOUSEWHEEL} 
+    # 
     # - {Wx::EVT_MAGNIFY}
-    # @param mouseEventType [Integer] 
-    # @return [MouseEvent]
+    # @param mouseEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @return [Wx::MouseEvent]
     def initialize(mouseEventType=Wx::EVT_NULL) end
     
     # Returns true if the event was a first extra button double click.
@@ -667,6 +737,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SetCursorEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_set_cursor}(meth = nil, &block): Process a {Wx::EVT_SET_CURSOR} event. 
   # 
   # === 
@@ -681,7 +752,7 @@ module Wx
     # Constructor, used by the library itself internally to initialize the event object.
     # @param x [Integer] 
     # @param y [Integer] 
-    # @return [SetCursorEvent]
+    # @return [Wx::SetCursorEvent]
     def initialize(x=0, y=0) end
     
     # Returns a reference to the cursor specified by this event.
@@ -728,8 +799,8 @@ module Wx
   
     # Constructor.
     # @param winid [Integer] 
-    # @param type [Integer] 
-    # @return [GestureEvent]
+    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @return [Wx::GestureEvent]
     def initialize(winid=0, type=Wx::EVT_NULL) end
     
     # Returns the position where the event took effect, in client coordinates: position of Pan event, center of zoom for Zoom event, center of rotation for Rotate event, center of box formed by 2 fingers for Two Finger Tap event and position of the pressed finger for Press and Tap Event.
@@ -768,12 +839,13 @@ module Wx
   end # GestureEvent
   
   # This event is generated when the user moves a finger on the surface.
-  # {Wx::GTK} also generates this event during mouse dragging (mouse motion while a left mouse button is depressed).
+  # wxGTK also generates this event during mouse dragging (mouse motion while a left mouse button is depressed).
   # Note that OSX requires the primary mouse button to be pressed while performing the finger movement.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::PanGestureEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_gesture_pan}(id, meth = nil, &block): Process a {Wx::EVT_GESTURE_PAN}. 
   # 
   # === 
@@ -784,7 +856,7 @@ module Wx
   
     # Constructor.
     # @param winid [Integer] 
-    # @return [PanGestureEvent]
+    # @return [Wx::PanGestureEvent]
     def initialize(winid=0) end
     
     # Returns the distance covered since the previous panning event.
@@ -805,6 +877,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ZoomGestureEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_gesture_zoom}(id, meth = nil, &block): Process a {Wx::EVT_GESTURE_ZOOM}. 
   # 
   # === 
@@ -815,7 +888,7 @@ module Wx
   
     # Constructor.
     # @param windid [Integer] 
-    # @return [ZoomGestureEvent]
+    # @return [Wx::ZoomGestureEvent]
     def initialize(windid=0) end
     
     # Returns the zoom Factor since the gesture started.
@@ -837,6 +910,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::RotateGestureEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_gesture_rotate}(id, meth = nil, &block): Process a {Wx::EVT_GESTURE_ROTATE}. 
   # 
   # === 
@@ -847,7 +921,7 @@ module Wx
   
     # Constructor.
     # @param windid [Integer] 
-    # @return [RotateGestureEvent]
+    # @return [Wx::RotateGestureEvent]
     def initialize(windid=0) end
     
     # Returns the total angle of rotation in radians in clockwise direction since the gesture was first started i.e.
@@ -870,6 +944,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::TwoFingerTapEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_two_finger_tap}(id, meth = nil, &block): Process a {Wx::EVT_TWO_FINGER_TAP}. 
   # 
   # === 
@@ -880,18 +955,19 @@ module Wx
   
     # Constructor.
     # @param windid [Integer] 
-    # @return [TwoFingerTapEvent]
+    # @return [Wx::TwoFingerTapEvent]
     def initialize(windid=0) end
     
   end # TwoFingerTapEvent
   
   # This event is generated when one finger touches the surface and remains stationary.
-  # Note that currently it is only generated under {Wx::GTK} and {Wx::OSX}.
-  # {Wx::GTK} also generates this event when left mouse button is being pressed for some minimum duration of time.
+  # Note that currently it is only generated under wxGTK and wxOSX.
+  # wxGTK also generates this event when left mouse button is being pressed for some minimum duration of time.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::LongPressEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_long_press}(id, meth = nil, &block): Process a {Wx::EVT_LONG_PRESS}. 
   # 
   # === 
@@ -902,7 +978,7 @@ module Wx
   
     # Constructor.
     # @param windid [Integer] 
-    # @return [LongPressEvent]
+    # @return [Wx::LongPressEvent]
     def initialize(windid=0) end
     
   end # LongPressEvent
@@ -913,6 +989,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::PressAndTapEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_press_and_tap}(id, meth = nil, &block): Process a {Wx::EVT_PRESS_AND_TAP}. 
   # 
   # === 
@@ -923,7 +1000,7 @@ module Wx
   
     # Constructor.
     # @param windid [Integer] 
-    # @return [PressAndTapEvent]
+    # @return [Wx::PressAndTapEvent]
     def initialize(windid=0) end
     
   end # PressAndTapEvent
@@ -932,7 +1009,10 @@ module Wx
   # 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.
+  # 
+  # - 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 {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.
@@ -953,9 +1033,13 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::KeyEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_key_down}(meth = nil, &block): Process a {Wx::EVT_KEY_DOWN} event (any key has been pressed). If this event is handled and not skipped, {Wx::EVT_CHAR} will not be generated at all for this key press (but {Wx::EVT_KEY_UP} will be). 
+  # 
   # - {Wx::EvtHandler#evt_key_up}(meth = nil, &block): Process a {Wx::EVT_KEY_UP} event (any key has been released). 
+  # 
   # - {Wx::EvtHandler#evt_char}(meth = nil, &block): Process a {Wx::EVT_CHAR} event. 
+  # 
   # - {Wx::EvtHandler#evt_char_hook}(meth = nil, &block): Process a {Wx::EVT_CHAR_HOOK} event. Unlike all the other key events, this event is propagated upwards the window hierarchy which allows intercepting it in the parent window of the focused window to which it is sent initially (if there is no focused window, this event is sent to the {Wx::App} global object). It is also generated before any other key events and so gives the parent window an opportunity to modify the keyboard handling of its children, e.g. it is used internally by wxWidgets in some ports to intercept pressing Esc key in any child of a dialog to close the dialog itself when it's pressed. By default, if this event is handled, i.e. the handler doesn't call {Wx::Event#skip}, neither {Wx::EVT_KEY_DOWN} nor {Wx::EVT_CHAR} events will be generated (although {Wx::EVT_KEY_UP} still will be), i.e. it replaces the normal key events. However by calling the special {Wx::KeyEvent#do_allow_next_event} method you can handle {Wx::EVT_CHAR_HOOK} and still allow normal events generation. This is something that is rarely useful but can be required if you need to prevent a parent {Wx::EVT_CHAR_HOOK} handler from running without suppressing the normal key events. Finally notice that this event is not generated when the mouse is captured as it is considered that the window which has the capture should receive all the keyboard events too without allowing its parent {Wx::TopLevelWindow} to interfere with their processing. 
   # 
   # === 
@@ -975,8 +1059,8 @@ module Wx
     
     # Constructor.
     # Currently, the only valid event types are {Wx::EVT_CHAR} and {Wx::EVT_CHAR_HOOK}.
-    # @param keyEventType [Integer] 
-    # @return [KeyEvent]
+    # @param keyEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
+    # @return [Wx::KeyEvent]
     def initialize(keyEventType=Wx::EVT_NULL) end
     
     # Returns the key code of the key that generated this event.
@@ -1183,6 +1267,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SizeEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_size}(meth = nil, &block): Process a {Wx::EVT_SIZE} event. 
   # 
   # === 
@@ -1197,7 +1282,7 @@ module Wx
     # Constructor.
     # @param sz [Array(Integer, Integer), Wx::Size] 
     # @param id [Integer] 
-    # @return [SizeEvent]
+    # @return [Wx::SizeEvent]
     def initialize(sz, id=0) end
     
     # Returns the entire size of the window generating the size change event.
@@ -1223,15 +1308,19 @@ module Wx
   end # SizeEvent
   
   # A move event holds information about window position change.
-  # These events are currently generated for top level (see {Wx::TopLevelWindow}) windows in all ports, but are not generated for the child windows in {Wx::GTK}.
+  # These events are currently generated for top level (see {Wx::TopLevelWindow}) windows in all ports, but are not generated for the child windows in wxGTK.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MoveEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_move}(meth = nil, &block): Process a {Wx::EVT_MOVE} event, which is generated when a window is moved. 
-  # - {Wx::EvtHandler#evt_move_start}(meth = nil, &block): Process a {Wx::EVT_MOVE_START} event, which is generated when the user starts to move or size a window. {Wx::MSW} only. 
-  # - {Wx::EvtHandler#evt_moving}(meth = nil, &block): Process a {Wx::EVT_MOVING} event, which is generated while the user is moving the window. {Wx::MSW} only. 
-  # - {Wx::EvtHandler#evt_move_end}(meth = nil, &block): Process a {Wx::EVT_MOVE_END} event, which is generated when the user stops moving or sizing a window. {Wx::MSW} only. 
+  # 
+  # - {Wx::EvtHandler#evt_move_start}(meth = nil, &block): Process a {Wx::EVT_MOVE_START} event, which is generated when the user starts to move or size a window. wxMSW only. 
+  # 
+  # - {Wx::EvtHandler#evt_moving}(meth = nil, &block): Process a {Wx::EVT_MOVING} event, which is generated while the user is moving the window. wxMSW only. 
+  # 
+  # - {Wx::EvtHandler#evt_move_end}(meth = nil, &block): Process a {Wx::EVT_MOVE_END} event, which is generated when the user stops moving or sizing a window. wxMSW only. 
   # 
   # === 
   # 
@@ -1245,7 +1334,7 @@ module Wx
     # Constructor.
     # @param pt [Array(Integer, Integer), Wx::Point] 
     # @param id [Integer] 
-    # @return [MoveEvent]
+    # @return [Wx::MoveEvent]
     def initialize(pt, id=0) end
     
     # Returns the position of the window generating the move change event.
@@ -1310,6 +1399,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::PaintEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_paint}(meth = nil, &block): Process a {Wx::EVT_PAINT} event. 
   # 
   # === 
@@ -1323,7 +1413,7 @@ module Wx
     # Constructor for exclusive use of wxWidgets itself.
     # Note that the objects of this class can not be created from application code, they're only created by the library itself. If you need a window to be repainted, use {Wx::Window#refresh} instead of trying to manually create an event of this class.
     # @param window [Wx::Window] 
-    # @return [PaintEvent]
+    # @return [Wx::PaintEvent]
     def initialize(window) end
     
   end # PaintEvent
@@ -1336,6 +1426,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::EraseEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_erase_background}(meth = nil, &block): Process a {Wx::EVT_ERASE_BACKGROUND} event. 
   # 
   # === 
@@ -1349,7 +1440,7 @@ module Wx
     # Constructor.
     # @param id [Integer] 
     # @param dc [Wx::DC] 
-    # @return [EraseEvent]
+    # @return [Wx::EraseEvent]
     def initialize(id=0, dc=nil) end
     
     # Returns the device context associated with the erase event to draw on.
@@ -1368,7 +1459,9 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::FocusEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_set_focus}(meth = nil, &block): Process a {Wx::EVT_SET_FOCUS} event. 
+  # 
   # - {Wx::EvtHandler#evt_kill_focus}(meth = nil, &block): Process a {Wx::EVT_KILL_FOCUS} event. 
   # 
   # === 
@@ -1380,9 +1473,9 @@ module Wx
   class FocusEvent < Event
   
     # Constructor.
-    # @param eventType [Integer] 
+    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
-    # @return [FocusEvent]
+    # @return [Wx::FocusEvent]
     def initialize(eventType=Wx::EVT_NULL, id=0) end
     
     # Returns the window associated with this event, that is the window which had the focus before for the {Wx::EVT_SET_FOCUS} event and the window which is going to receive focus for the {Wx::EVT_KILL_FOCUS} one.
@@ -1403,11 +1496,14 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ActivateEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_activate}(meth = nil, &block): Process a {Wx::EVT_ACTIVATE} event. 
+  # 
   # - {Wx::EvtHandler#evt_activate_app}(meth = nil, &block): Process a {Wx::EVT_ACTIVATE_APP} event. This event is received by the {Wx::App}-derived instance only. 
+  # 
   # - {Wx::EvtHandler#evt_hibernate}(meth = nil, &block): Process a hibernate event, supplying the member function. This event applies to {Wx::App} only, and only on Windows SmartPhone and PocketPC. It is generated when the system is low on memory; the application should free up as much memory as possible, and restore full working state when it receives a {Wx::EVT_ACTIVATE} or {Wx::EVT_ACTIVATE_APP} event. 
   # 
-  # Until wxWidgets 3.1.0 activation events could be sent by {Wx::MSW} when the window was minimized. This reflected the native MSW behaviour but was often surprising and unexpected, so starting from 3.1.0 such events are not sent any more when the window is in the minimized state.
+  # Until wxWidgets 3.1.0 activation events could be sent by wxMSW when the window was minimized. This reflected the native MSW behaviour but was often surprising and unexpected, so starting from 3.1.0 such events are not sent any more when the window is in the minimized state.
   # 
   # === 
   # 
@@ -1435,11 +1531,11 @@ module Wx
     end # Reason
     
     # Constructor.
-    # @param eventType [Integer] 
+    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param active [true,false] 
     # @param id [Integer] 
     # @param activationReason [Reason] 
-    # @return [ActivateEvent]
+    # @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.
@@ -1448,7 +1544,7 @@ module Wx
     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 {Wx::MSW} 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).
+    # 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]
     def get_activation_reason; end
@@ -1463,6 +1559,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::InitDialogEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_init_dialog}(meth = nil, &block): Process a {Wx::EVT_INIT_DIALOG} event. 
   # 
   # === 
@@ -1475,7 +1572,7 @@ module Wx
   
     # Constructor.
     # @param id [Integer] 
-    # @return [InitDialogEvent]
+    # @return [Wx::InitDialogEvent]
     def initialize(id=0) end
     
   end # InitDialogEvent
@@ -1483,7 +1580,11 @@ module Wx
   # This class is used for a variety of menu-related events.
   # Note that these do not include menu command events, which are handled using {Wx::CommandEvent} objects.
   # Events of this class are generated by both menus that are part of a {Wx::MenuBar}, attached to {Wx::Frame}, and popup menus shown by {Wx::Window#popup_menu}. They are sent to the following objects until one of them handles the event:
-  # - The menu object itself, as returned by {Wx::MenuEvent#get_menu}, if any.- The {Wx::MenuBar} to which this menu is attached, if any.- The window associated with the menu, e.g. the one calling PopupMenu() for the popup menus.- The top level parent of that window if it's different from the window itself.
+  # 
+  # - The menu object itself, as returned by {Wx::MenuEvent#get_menu}, if any.
+  # - The {Wx::MenuBar} to which this menu is attached, if any.
+  # - The window associated with the menu, e.g. the one calling PopupMenu() for the popup menus.
+  # - The top level parent of that window if it's different from the window itself.
   # 
   # This is similar to command events generated by the menu items, but, unlike them, {Wx::MenuEvent} are only sent to the window itself and its top level parent but not any intermediate windows in the hierarchy.
   # The default handler for {Wx::EVT_MENU_HIGHLIGHT} in {Wx::Frame} displays help text in the status bar, see {Wx::Frame#set_status_bar_pane}.
@@ -1491,9 +1592,13 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MenuEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_menu_open}(meth = nil, &block): A menu is about to be opened. On Windows, this is only sent once for each navigation of the menubar (up until all menus have closed). 
+  # 
   # - {Wx::EvtHandler#evt_menu_close}(meth = nil, &block): A menu has been just closed. Notice that this event is currently being sent before the menu selection ({Wx::EVT_MENU}) event, if any. 
+  # 
   # - {Wx::EvtHandler#evt_menu_highlight}(id, meth = nil, &block): The menu item with the specified id has been highlighted: used to show help prompts in the status bar by {Wx::Frame} 
+  # 
   # - {Wx::EvtHandler#evt_menu_highlight_all}(meth = nil, &block): A menu item has been highlighted, i.e. the currently selected menu item has changed. 
   # 
   # === 
@@ -1506,14 +1611,14 @@ module Wx
   class MenuEvent < Event
   
     # Constructor.
-    # @param type [Integer] 
+    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
     # @param menu [Wx::Menu] 
-    # @return [MenuEvent]
+    # @return [Wx::MenuEvent]
     def initialize(type=Wx::EVT_NULL, id=0, menu=nil) end
     
     # Returns the menu which is being opened or closed, or the menu containing the highlighted item.
-    # Note that the returned value can be NULL if the menu being opened doesn't have a corresponding {Wx::Menu}, e.g. this happens when opening the system menu in {Wx::MSW} port.
+    # Note that the returned value can be NULL if the menu being opened doesn't have a corresponding {Wx::Menu}, e.g. this happens when opening the system menu in wxMSW port.
     # Since 3.1.3 this function can be used with OPEN, CLOSE and HIGHLIGHT events. Before 3.1.3, this method can only be used with the OPEN and CLOSE events.
     # @return [Wx::Menu]
     def get_menu; end
@@ -1562,8 +1667,11 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CloseEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_close}(meth = nil, &block): Process a {Wx::EVT_CLOSE_WINDOW} command event, supplying the member function. This event applies to {Wx::Frame} and {Wx::Dialog} classes. 
+  # 
   # - {Wx::EvtHandler#evt_query_end_session}(meth = nil, &block): Process a {Wx::EVT_QUERY_END_SESSION} session event, supplying the member function. This event can be handled in {Wx::App}-derived class only. 
+  # 
   # - {Wx::EvtHandler#evt_end_session}(meth = nil, &block): Process a {Wx::EVT_END_SESSION} session event, supplying the member function. This event can be handled in {Wx::App}-derived class only. 
   # 
   # === 
@@ -1576,9 +1684,9 @@ module Wx
   class CloseEvent < Event
   
     # Constructor.
-    # @param commandEventType [Integer] 
+    # @param commandEventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
-    # @return [CloseEvent]
+    # @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.
@@ -1618,11 +1726,12 @@ module Wx
   end # CloseEvent
   
   # An event being sent when the window is shown or hidden.
-  # The event is triggered by calls to {Wx::Window#show}, and any user action showing a previously hidden window or vice versa (if allowed by the current platform and/or window manager). Notice that the event is not triggered when the application is iconized (minimized) or restored under {Wx::MSW}.
+  # The event is triggered by calls to {Wx::Window#show}, and any user action showing a previously hidden window or vice versa (if allowed by the current platform and/or window manager). Notice that the event is not triggered when the application is iconized (minimized) or restored under wxMSW.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ShowEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_show}(meth = nil, &block): Process a {Wx::EVT_SHOW} event. 
   # 
   # === 
@@ -1638,7 +1747,7 @@ module Wx
     # Constructor.
     # @param winid [Integer] 
     # @param show [true,false] 
-    # @return [ShowEvent]
+    # @return [Wx::ShowEvent]
     def initialize(winid=0, show=false) end
     
     # Set whether the windows was shown or hidden.
@@ -1659,6 +1768,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::IconizeEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_iconize}(meth = nil, &block): Process a {Wx::EVT_ICONIZE} event. 
   # 
   # === 
@@ -1674,7 +1784,7 @@ module Wx
     # Constructor.
     # @param id [Integer] 
     # @param iconized [true,false] 
-    # @return [IconizeEvent]
+    # @return [Wx::IconizeEvent]
     def initialize(id=0, iconized=true) end
     
     # Returns true if the frame has been iconized, false if it has been restored.
@@ -1686,11 +1796,12 @@ module Wx
   
   # An event being sent when a top level window is maximized.
   # Notice that it is not sent when the window is restored to its original size after it had been maximized, only a normal {Wx::SizeEvent} is generated in this case.
-  # Currently this event is only generated in {Wx::MSW}, {Wx::GTK} and {Wx::OSX}/Cocoa ports so portable programs should only rely on receiving {Wx::EVT_SIZE} and not necessarily this event when the window is maximized.
+  # Currently this event is only generated in wxMSW, wxGTK and wxOSX/Cocoa ports so portable programs should only rely on receiving {Wx::EVT_SIZE} and not necessarily this event when the window is maximized.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MaximizeEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_maximize}(meth = nil, &block): Process a {Wx::EVT_MAXIMIZE} event. 
   # 
   # === 
@@ -1706,17 +1817,18 @@ module Wx
     # Constructor.
     # Only used by wxWidgets internally.
     # @param id [Integer] 
-    # @return [MaximizeEvent]
+    # @return [Wx::MaximizeEvent]
     def initialize(id=0) end
     
   end # MaximizeEvent
   
   # An event being sent when the user enters or exits full screen mode.
-  # Currently this event is only generated in the {Wx::OSX}/Cocoa port when {Wx::TopLevelWindow#enable_full_screen_view} is enabled and the user the user enters or exits full screen. Note that this event is not generated when {Wx::TopLevelWindow#show_full_screen}.
+  # Currently this event is only generated in the wxOSX/Cocoa port when {Wx::TopLevelWindow#enable_full_screen_view} is enabled and the user the user enters or exits full screen. Note that this event is not generated when {Wx::TopLevelWindow#show_full_screen}.
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::FullScreenEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_fullscreen}(meth = nil, &block): Process a {Wx::EVT_FULLSCREEN} event. 
   # 
   # === 
@@ -1732,7 +1844,7 @@ module Wx
     # Constructor.
     # @param id [Integer] 
     # @param fullscreen [true,false] 
-    # @return [FullScreenEvent]
+    # @return [Wx::FullScreenEvent]
     def initialize(id=0, fullscreen=true) end
     
     # Returns true if the frame entered full screen, false if exited full screen.
@@ -1747,10 +1859,15 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::JoystickEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_joy_button_down}(meth = nil, &block): Process a {Wx::EVT_JOY_BUTTON_DOWN} event. 
+  # 
   # - {Wx::EvtHandler#evt_joy_button_up}(meth = nil, &block): Process a {Wx::EVT_JOY_BUTTON_UP} event. 
+  # 
   # - {Wx::EvtHandler#evt_joy_move}(meth = nil, &block): Process a {Wx::EVT_JOY_MOVE} event. 
+  # 
   # - {Wx::EvtHandler#evt_joy_zmove}(meth = nil, &block): Process a {Wx::EVT_JOY_ZMOVE} event. 
+  # 
   # - {Wx::EvtHandler#evt_joystick_events}(meth = nil, &block): Processes all joystick events. 
   # 
   # === 
@@ -1762,11 +1879,11 @@ module Wx
   class JoystickEvent < Event
   
     # Constructor.
-    # @param eventType [Integer] 
+    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param state [Integer] 
     # @param joystick [Integer] 
     # @param change [Integer] 
-    # @return [JoystickEvent]
+    # @return [Wx::JoystickEvent]
     def initialize(eventType=Wx::EVT_NULL, state=0, joystick=wxJOYSTICK1, change=0) end
     
     # Returns true if the event was a down event from the specified button (or any button).
@@ -1849,6 +1966,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::DropFilesEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_drop_files}(meth = nil, &block): Process a {Wx::EVT_DROP_FILES} event. 
   # 
   # Windows only until version 2.8.9, available on all platforms since 2.8.10.
@@ -1863,10 +1981,10 @@ module Wx
   class DropFilesEvent < Event
   
     # Constructor.
-    # @param id [Integer] 
+    # @param id [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param noFiles [Integer] 
     # @param files [String] 
-    # @return [DropFilesEvent]
+    # @return [Wx::DropFilesEvent]
     def initialize(id=0, noFiles=0, files=nil) end
     
     # Returns an array of filenames.
@@ -1893,7 +2011,9 @@ module Wx
   # In addition to being a clearer and more declarative method, it also means you don't have to worry whether you're updating a toolbar or menubar identifier. The same handler can update a menu item and toolbar button, if the identifier is the same. Instead of directly manipulating the menu or button, you call functions in the event object, such as {Wx::UpdateUIEvent#check}. wxWidgets will determine whether such a call has been made, and which UI element to update.
   # These events will work for popup menus as well as menubars. Just before a menu is popped up, {Wx::Menu::UpdateUI} is called to process any UI events for the window that owns the menu.
   # If you find that the overhead of UI update processing is affecting your application, you can do one or both of the following: 
+  # 
   # - Call {Wx::UpdateUIEvent.set_mode} with a value of {Wx::UpdateUIMode::UPDATE_UI_PROCESS_SPECIFIED}, and set the extra style {Wx::WS_EX_PROCESS_UI_UPDATES} for every window that should receive update events. No other windows will receive update events. 
+  # 
   # - Call {Wx::UpdateUIEvent.set_update_interval} with a millisecond value to set the delay between updates. You may need to call {Wx::Window#update_window_ui} at critical points, for example when a dialog is about to be shown, in case the user sees a slight delay before windows are updated.
   # 
   # Note that although events are sent in idle time, defining a {Wx::IdleEvent} handler for a window does not affect this because the events are sent from {Wx::Window#on_internal_idle} which is always called in idle time.
@@ -1902,7 +2022,9 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::UpdateUIEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_update_ui}(id, meth = nil, &block): Process a {Wx::EVT_UPDATE_UI} event for the command with the given id. 
+  # 
   # - {Wx::EvtHandler#evt_update_ui_range}(id1,  id2, meth = nil, &block): Process a {Wx::EVT_UPDATE_UI} event for any command with id included in the given range. 
   # 
   # === 
@@ -1915,7 +2037,7 @@ module Wx
   
     # Constructor.
     # @param commandId [Integer] 
-    # @return [UpdateUIEvent]
+    # @return [Wx::UpdateUIEvent]
     def initialize(commandId=0) end
     
     # Check or uncheck the UI element.
@@ -2046,6 +2168,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SysColourChangedEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_sys_colour_changed}(meth = nil, &block): Process a {Wx::EVT_SYS_COLOUR_CHANGED} event. 
   # 
   # === 
@@ -2057,18 +2180,19 @@ module Wx
   class SysColourChangedEvent < Event
   
     # Constructor.
-    # @return [SysColourChangedEvent]
+    # @return [Wx::SysColourChangedEvent]
     def initialize; end
     
   end # SysColourChangedEvent
   
   # A mouse capture changed event is sent to a window that loses its mouse capture.
   # This is called even if {Wx::Window#release_mouse} was called by the application code. Handling this event allows an application to cater for unexpected capture releases which might otherwise confuse mouse handling code.
-  # Availability:  only available for the {Wx::MSW} port.  {Wx::msw} 
+  # Availability:  only available for the wxMSW port.  {Wx::msw} 
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MouseCaptureChangedEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_mouse_capture_changed}(meth = nil, &block): Process a {Wx::EVT_MOUSE_CAPTURE_CHANGED} event. 
   # 
   # === 
@@ -2086,7 +2210,7 @@ module Wx
     # Constructor.
     # @param windowId [Integer] 
     # @param gainedCapture [Wx::Window] 
-    # @return [MouseCaptureChangedEvent]
+    # @return [Wx::MouseCaptureChangedEvent]
     def initialize(windowId=0, gainedCapture=nil) end
     
     # Returns the window that gained the capture, or NULL if it was a non-wxWidgets window.
@@ -2103,9 +2227,10 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MouseCaptureLostEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_mouse_capture_lost}(meth = nil, &block): Process a {Wx::EVT_MOUSE_CAPTURE_LOST} event. 
   # 
-  # Availability:  only available for the {Wx::MSW} port.  {Wx::msw} 
+  # Availability:  only available for the wxMSW port.  {Wx::msw} 
   # === 
   # 
   # Category:  {Wx::Events}
@@ -2120,7 +2245,7 @@ module Wx
   
     # Constructor.
     # @param windowId [Integer] 
-    # @return [MouseCaptureLostEvent]
+    # @return [Wx::MouseCaptureLostEvent]
     def initialize(windowId=0) end
     
   end # MouseCaptureLostEvent
@@ -2131,9 +2256,10 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::DisplayChangedEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_display_changed}(meth = nil, &block): Process a {Wx::EVT_DISPLAY_CHANGED} event. 
   # 
-  # Availability:  only available for the {Wx::MSW} port.  {Wx::msw} 
+  # Availability:  only available for the wxMSW port.  {Wx::msw} 
   # === 
   # 
   # Category:  {Wx::Events}
@@ -2142,7 +2268,7 @@ module Wx
   # 
   class DisplayChangedEvent < Event
   
-    # @return [DisplayChangedEvent]
+    # @return [Wx::DisplayChangedEvent]
     def initialize; end
     
   end # DisplayChangedEvent
@@ -2150,11 +2276,12 @@ module Wx
   # Event sent when the display scale factor or pixel density (measured in dots-per-inch, or DPI) of the monitor a window is on changes.
   # The event is sent to each {Wx::TopLevelWindow} affected by the change, and all its children recursively (post-order traversal). For example, this event is sent to the window when it is moved, by the user, from a display using some DPI value to another display using a different DPI value. It also sent to all program windows on the given display if its DPI changes due to a change in the system settings.
   # If you define an event handler for this event, you should almost always call <code>event.Skip()</code> in it in order to allow the base class handler to execute, as many controls rely on processing this event in order to update their appearance when the DPI changes. However the default handler for the top level window itself only sets the new window size, by scaling the current size by the DPI ratio  e.g. doubling it if the DPI has changed from normal to "high", i.e. 200%, one  and also ensuring that the window is still bigger than its best size, as returned by {Wx::Window#get_best_size}. Note that in some cases this may cause the window size to grow unexpectedly and you may prefer to call {Wx::Window#set_size} in your handler of this event for the top level window and not call <code>event.Skip()</code> to prevent the default handler from resizing the window.
-  # Currently this event is generated by {Wx::MSW} port if only and only if the MSW application runs under Windows 10 Creators Update (v1703) or later and is marked as being "per-monitor DPI aware", i.e. contains a dpiAwareness tag with the value "PerMonitorV2" in its manifest (see Microsoft "Application Manifests" documentation for more details).
+  # Currently this event is generated by wxMSW port if only and only if the MSW application runs under Windows 10 Creators Update (v1703) or later and is marked as being "per-monitor DPI aware", i.e. contains a dpiAwareness tag with the value "PerMonitorV2" in its manifest (see Microsoft "Application Manifests" documentation for more details).
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::DPIChangedEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_dpi_changed}(meth = nil, &block): Process a {Wx::EVT_DPI_CHANGED} event. 
   # 
   # === 
@@ -2202,7 +2329,7 @@ module Wx
   class PaletteChangedEvent < Event
   
     # @param winid [Integer] 
-    # @return [PaletteChangedEvent]
+    # @return [Wx::PaletteChangedEvent]
     def initialize(winid=0) end
     
     # @param win [Wx::Window] 
@@ -2222,7 +2349,7 @@ module Wx
   class QueryNewPaletteEvent < Event
   
     # @param winid [Integer] 
-    # @return [QueryNewPaletteEvent]
+    # @return [Wx::QueryNewPaletteEvent]
     def initialize(winid=0) end
     
     # @param realized [true,false] 
@@ -2242,6 +2369,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::NavigationKeyEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_navigation_key}(meth = nil, &block): Process a navigation key event. 
   # 
   # === 
@@ -2278,10 +2406,10 @@ module Wx
     end # NavigationKeyEventFlags
     
     # @overload initialize()
-    #   @return [NavigationKeyEvent]
+    #   @return [Wx::NavigationKeyEvent]
     # @overload initialize(event)
     #   @param event [Wx::NavigationKeyEvent] 
-    #   @return [NavigationKeyEvent]
+    #   @return [Wx::NavigationKeyEvent]
     def initialize(*args) end
     
     # Returns the child that has the focus, or NULL.
@@ -2344,6 +2472,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::WindowCreateEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_window_create}(meth = nil, &block): Process a {Wx::EVT_CREATE} event. 
   # 
   # === 
@@ -2357,7 +2486,7 @@ module Wx
   
     # Constructor.
     # @param win [Wx::Window] 
-    # @return [WindowCreateEvent]
+    # @return [Wx::WindowCreateEvent]
     def initialize(win=nil) end
     
     # Return the window being created.
@@ -2382,7 +2511,7 @@ module Wx
   
     # Constructor.
     # @param win [Wx::Window] 
-    # @return [WindowDestroyEvent]
+    # @return [Wx::WindowDestroyEvent]
     def initialize(win=nil) end
     
     # Return the window being destroyed.
@@ -2401,7 +2530,9 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::HelpEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_help}(id, meth = nil, &block): Process a {Wx::EVT_HELP} event. 
+  # 
   # - {Wx::EvtHandler#evt_help_range}(id1,  id2, meth = nil, &block): Process a {Wx::EVT_HELP} event for a range of ids. 
   # 
   # === 
@@ -2435,11 +2566,11 @@ module Wx
     end # Origin
     
     # Constructor.
-    # @param type [Integer] 
+    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param winid [Integer] 
     # @param pt [Array(Integer, Integer), Wx::Point] 
     # @param origin [Wx::HelpEvent::Origin] 
-    # @return [HelpEvent]
+    # @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.
@@ -2475,14 +2606,17 @@ module Wx
   # There are three types of corresponding events {Wx::EVT_TEXT_COPY}, {Wx::EVT_TEXT_CUT} and {Wx::EVT_TEXT_PASTE}.
   # If any of these events is processed (without being skipped) by an event handler, the corresponding operation doesn't take place which allows preventing the text from being copied from or pasted to a control. It is also possible to examine the clipboard contents in the PASTE event handler and transform it in some way before inserting in a control  for example, changing its case or removing invalid characters.
   # Finally notice that a CUT event is always preceded by the COPY event which makes it possible to only process the latter if it doesn't matter if the text was copied or cut.
-  # These events are currently only generated by {Wx::TextCtrl} in {Wx::GTK} and {Wx::OSX} but are also generated by {Wx::ComboBox} without {Wx::CB_READONLY} style in {Wx::MSW}.
+  # These events are currently only generated by {Wx::TextCtrl} in wxGTK and wxOSX but are also generated by {Wx::ComboBox} without {Wx::CB_READONLY} style in wxMSW.
   # 
   # === Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ClipboardTextEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_text_copy}(id, meth = nil, &block): Some or all of the controls content was copied to the clipboard. 
+  # 
   # - {Wx::EvtHandler#evt_text_cut}(id, meth = nil, &block): Some or all of the controls content was cut (i.e. copied and deleted). 
+  # 
   # - {Wx::EvtHandler#evt_text_paste}(id, meth = nil, &block): Clipboard content was pasted into the control. 
   # 
   # === 
@@ -2494,9 +2628,9 @@ module Wx
   class ClipboardTextEvent < CommandEvent
   
     # Constructor.
-    # @param commandType [Integer] 
+    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
-    # @return [ClipboardTextEvent]
+    # @return [Wx::ClipboardTextEvent]
     def initialize(commandType=Wx::EVT_NULL, id=0) end
     
   end # ClipboardTextEvent
@@ -2508,6 +2642,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ContextMenuEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_context_menu}(meth = nil, &block): A right click (or other context menu command depending on platform) has been detected. 
   # 
   # === 
@@ -2520,10 +2655,10 @@ module Wx
   class ContextMenuEvent < CommandEvent
   
     # Constructor.
-    # @param type [Integer] 
+    # @param type [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
     # @param pos [Array(Integer, Integer), Wx::Point] 
-    # @return [ContextMenuEvent]
+    # @return [Wx::ContextMenuEvent]
     def initialize(type=Wx::EVT_NULL, id=0, pos=Wx::DEFAULT_POSITION) end
     
     # Returns the position in screen coordinates at which the menu should be shown.
@@ -2548,6 +2683,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ChildFocusEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_child_focus}(meth = nil, &block): Process a {Wx::EVT_CHILD_FOCUS} event. 
   # 
   # === 
@@ -2560,7 +2696,7 @@ module Wx
   
     # Constructor.
     # @param win [Wx::Window]  The direct child which is (or which contains the window which is) receiving the focus.
-    # @return [ChildFocusEvent]
+    # @return [Wx::ChildFocusEvent]
     def initialize(win=nil) end
     
     # Returns the direct child which receives the focus, or a (grand-)parent of the control receiving the focus.