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

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

@@ -0,0 +1,100 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::UIActionSimulator} is a class used to simulate user interface actions such as a mouse click or a key press.
+  # Common usage for this class would be to provide playback and record (aka macro recording) functionality for users, or to drive unit tests by simulating user sessions.
+  # See the wxUIActionSimulator Sample for an example of using this class.
+  # 
+  # ===
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class UIActionSimulator < ::Object
+  
+    # Default constructor.
+    # @return [UIActionSimulator]
+    def initialize; end
+    
+    # @overload mouse_move(x, y)
+    #   Move the mouse to the specified coordinates.
+    #   @param x [Integer]  x coordinate to move to, in screen coordinates.
+    #   @param y [Integer]  y coordinate to move to, in screen coordinates.
+    #   @return [true,false]
+    # @overload mouse_move(point)
+    #   Move the mouse to the specified coordinates.
+    #   @param point [Array(Integer, Integer), Wx::Point]  Point to move to, in screen coordinates.
+    #   @return [true,false]
+    def mouse_move(*args) end
+    
+    # Press a mouse button.
+    # @param button [Integer]  Button to press. Valid constants are {Wx::MOUSE_BTN_LEFT}, {Wx::MOUSE_BTN_MIDDLE}, and {Wx::MOUSE_BTN_RIGHT}.
+    # @return [true,false]
+    def mouse_down(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Release a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_up(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Click a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_click(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Double-click a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_dbl_click(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Perform a drag and drop operation.
+    # @param x1 [Integer]  x start coordinate, in screen coordinates.
+    # @param y1 [Integer]  y start coordinate, in screen coordinates.
+    # @param x2 [Integer]  x destination coordinate, in screen coordinates.
+    # @param y2 [Integer]  y destination coordinate, in screen coordinates.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_drag_drop(x1, y1, x2, y2, button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Press a key.
+    # If you are using modifiers then it needs to be paired with an identical KeyUp or the modifiers will not be released (MSW and macOS).
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def key_down(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Release a key.
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def key_up(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Press and release a key.
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def char(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Simulate selection of an item with the given text.
+    # This method selects an item in the currently focused {Wx::Choice}, {Wx::ComboBox}, {Wx::ListBox} and similar controls. It does it by simulating keyboard events, so the behaviour should be the same as if the item was really selected by the user.
+    # Notice that the implementation of this method uses {yield} and so events can be dispatched from it.
+    # 
+    # true if the item text was successfully selected or false if the currently focused window is not one of the controls allowing item selection or if the item with the given text was not found in it.
+    # @param text [String]  The text of the item to select.
+    # @return [true,false]
+    def select(text) end
+    
+    # Emulate typing in the keys representing the given string.
+    # Currently only the ASCII letters are universally supported. Digits and punctuation characters can be used with the standard QWERTY (US) keyboard layout but may not work with other layouts.
+    # @param text [String]  The string, containing only US ASCII characters, to type.
+    # @return [true,false]
+    def text(text) end
+    
+  end # UIActionSimulator
+  
+
+end

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

@@ -50,7 +50,7 @@ module Wx
   # For normal keys, returns true if the specified key is currently down.
   # For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns true if the key is toggled such that its LED indicator is lit. There is currently no way to test whether togglable keys are up or down.
   # Even though there are virtual key codes defined for mouse buttons, they cannot be used with this function currently.
-  # In {Wx::GTK}, this function can be only used with modifier keys (WXK_ALT, WXK_CONTROL and WXK_SHIFT) when not using X11 backend currently.
+  # In {Wx::GTK}, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
   # @param key [KeyCode] 
   # @return [true,false]
   def self.get_key_state(key) end

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

@@ -71,24 +71,6 @@ module Wx
     # @return [true,false]
     def deselect_all; end
     
-    # Returns the index of the first selected item in the listbox or {Wx::NOT_FOUND} if no items are currently selected.
-    # cookie is an opaque parameter which should be passed to the subsequent calls to {Wx::VListBox#get_next_selected}. It is needed in order to allow parallel iterations over the selected items.
-    # Here is a typical example of using these functions:
-    # 
-    #   unsigned long cookie;
-    #   int item = hlbox->GetFirstSelected(cookie);
-    #   while ( item != wxNOT_FOUND )
-    #   {
-    #       // ... process item ...
-    #       item = hlbox->GetNextSelected(cookie);
-    #   }
-    # 
-    # This method is only valid for multi selection listboxes.
-    # @param cookie [unsigned long] 
-    # @return [Integer]
-    def get_first_selected(cookie) end
-    alias_method :first_selected, :get_first_selected
-    
     # Get the number of items in the control.
     # 
     # @see Wx::VListBox#set_item_count 
@@ -110,14 +92,6 @@ module Wx
     def get_item_rect(item) end
     alias_method :item_rect, :get_item_rect
     
-    # Returns the index of the next selected item or {Wx::NOT_FOUND} if there are no more.
-    # This method is only valid for multi selection listboxes.
-    # @see Wx::VListBox#get_first_selected 
-    # @param cookie [unsigned long] 
-    # @return [Integer]
-    def get_next_selected(cookie) end
-    alias_method :next_selected, :get_next_selected
-    
     # Returns the number of the items currently selected.
     # It is valid for both single and multi selection controls. In the former case it may only return 0 or 1 however.
     # @see Wx::VListBox#is_selected
@@ -218,6 +192,42 @@ module Wx
     # @return [void]
     def toggle(item) end
     
+    
+    protected
+    
+    # The derived class must implement this function to actually draw the item with the given index on the provided DC.
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC]  The device context to use for drawing.
+    # @param rect [Wx::Rect]  The bounding rectangle for the item being drawn (DC clipping region is set to this rectangle before calling this function).
+    # @param n [Integer]  The index of the item to be drawn.
+    # @return [void]
+    def on_draw_item(dc, rect, n) end
+    
+    # This method is used to draw the item's background and, maybe, a border around it.
+    # The base class version implements a reasonable default behaviour which consists in drawing the selected item with the standard background colour and drawing a border around the item if it is either selected or current.
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC] 
+    # @param rect [Wx::Rect] 
+    # @param n [Integer] 
+    # @return [void]
+    def on_draw_background(dc, rect, n) end
+    
+    # This method may be used to draw separators between the lines.
+    # The rectangle passed to it may be modified, typically to deflate it a bit before passing to {Wx::VListBox#on_draw_item}.
+    # The base class version of this method doesn't do anything.
+    # 
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC]  The device context to use for drawing.
+    # @param rect [Wx::Rect]  The bounding rectangle for the item.
+    # @param n [Integer]  The index of the item.
+    # @return [void]
+    def on_draw_separator(dc, rect, n) end
+    
+    # The derived class must implement this method to return the height of the specified item (in pixels).
+    # @param n [Integer] 
+    # @return [Integer]
+    def on_measure_item(n) end
+    
   end # VListBox
   
 

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

@@ -43,9 +43,10 @@ module Wx
     # Associates a window with the validator.
     # This function is automatically called by wxWidgets when creating a {Wx::Window}-derived class instance which takes a {Wx::Validator} reference. Since wxWidgets 3.1.1, it can be overridden in custom validators in order to perform any one-time initialization or checks of the window when the validator is associated with it.
     # E.g. 
-    # 
+    # ```
     #   new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
     #                  wxTextValidator(wxFILTER_ALPHA, &g_data.m_string));
+    # ```
     #  will automatically link the {Wx::TextValidator} instance with the {Wx::TextCtrl} instance and call {Wx::Validator#set_window} method on the {Wx::TextValidator} object.
     # @param window [Wx::Window] 
     # @return [void]

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

@@ -17,6 +17,7 @@ module Wx
   # An optional name member is associated with a {Wx::Variant}. This might be used, for example, in CORBA or OLE automation classes, where named parameters are required.
   # Note that as of wxWidgets 2.7.1, {Wx::Variant} is reference counted. Additionally, the convenience macros DECLARE_VARIANT_OBJECT() and IMPLEMENT_VARIANT_OBJECT() were added so that adding (limited) support for conversion to and from {Wx::Variant} can be very easily implemented without modifying either {Wx::Variant} or the class to be stored by {Wx::Variant}. Since assignment operators cannot be declared outside the class, the shift left operators are used like this:
   # 
+  # ```
   #   // in the header file
   #   DECLARE_VARIANT_OBJECT(MyClass)
   #   
@@ -30,13 +31,16 @@ module Wx
   #   
   #   // or
   #   value << variant;
+  # ```
   # 
   # For this to work, MyClass must derive from {Wx::Object}, implement the wxWidgets RTTI system and support the assignment operator and equality operator for itself. Ideally, it should also be reference counted to make copying operations cheap and fast. This can be most easily implemented using the reference counting support offered by {Wx::Object} itself. By default, wxWidgets already implements the shift operator conversion for a few of its drawing related classes:
   # 
+  # ```
   #   IMPLEMENT_VARIANT_OBJECT(wxColour)
   #   IMPLEMENT_VARIANT_OBJECT(wxImage)
   #   IMPLEMENT_VARIANT_OBJECT(wxIcon)
   #   IMPLEMENT_VARIANT_OBJECT(wxBitmap)
+  # ```
   # 
   # Note that as of wxWidgets 2.9.0, {Wx::VariantData} no longer inherits from {Wx::Object} and {Wx::Variant} no longer uses the type-unsafe {Wx::List} class for list operations but the type-safe {Wx::VariantList} class. Also, {Wx::VariantData} now supports the Wx::VariantData#clone function for implementing the {Wx::Variant#unshare} function. Wx::VariantData#clone is implemented automatically by IMPLEMENT_VARIANT_OBJECT().
   # Since {Wx::VariantData} no longer derives from {Wx::Object}, any code that tests the type of the data using {dynamic_cast} will require adjustment. You can use the macro {dynamic_cast_variant_data} with the same arguments as {dynamic_cast}, to use C++ RTTI type information instead of wxWidgets RTTI.
@@ -46,6 +50,7 @@ module Wx
   # {Wx::GRID::GridCellAttr::AttrKind::Any} is a more modern, template-based variant class. It is not directly compatible with {Wx::Variant}, but there is a transparent conversion layer.
   # Following is an example how to use these conversions with {Wx::PG::PropertyGrid}'s property class {Wx::PG::PGProperty} (which currently uses {Wx::Variants} both internally and in the public API):
   # 
+  # ```
   #   // Get property value as wxAny instead of wxVariant
   #   wxAny value = property->GetValue();
   #   
@@ -55,6 +60,7 @@ module Wx
   #   // Write back new value to property
   #   value = "New Value";
   #   property->SetValue(value);
+  # ```
   # 
   # Some caveats: 
   # - In {Wx::GRID::GridCellAttr::AttrKind::Any}, there are no separate types for handling integers of different sizes, so converting {Wx::GRID::GridCellAttr::AttrKind::Any} with 'long long' value will yield {Wx::Variant} of "long" type when the value is small enough to fit in without overflow. Otherwise, variant type "longlong" is used. Also note that {Wx::GRID::GridCellAttr::AttrKind::Any} holding unsigned integer will always be converted to "ulonglong" {Wx::Variant} type.
@@ -65,6 +71,7 @@ module Wx
   # 
   # Supplied conversion functions will automatically work with all built-in {Wx::Variant} types, and also with all user-specified types generated using IMPLEMENT_VARIANT_OBJECT(). For hand-built {Wx::VariantData} classes, you will need to use supplied macros in a following manner:
   # 
+  # ```
   #   // Declare wxVariantData for data type Foo
   #   class wxVariantDataFoo: public wxVariantData
   #   {
@@ -79,6 +86,7 @@ module Wx
   #   };
   #   
   #   IMPLEMENT_TRIVIAL_WXANY_CONVERSION(Foo, wxVariantDataFoo)
+  # ```
   # 
   # === 
   # 
@@ -87,6 +95,8 @@ module Wx
   # @see  Wx::GRID::GridCellAttr::AttrKind::Any 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Variant < Object
   
     # Appends a value to the list.

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

@@ -471,8 +471,9 @@ module Wx
     
     # Sets the scrollbar properties of a built-in scrollbar.
     # Let's say you wish to display 50 lines of text, using the same font. The window is sized so that you can only see 16 lines at a time. You would use: 
-    # 
+    # ```
     #   SetScrollbar(wxVERTICAL, 0, 16, 50);
+    # ```
     #  Note that with the window at this size, the thumb position can never go above 50 minus 16, or 34. You can determine how many lines are currently visible by dividing the current view size by the character height in pixels. When defining your own scrollbar behaviour, you will always need to recalculate the scrollbar settings when the window size changes. You could therefore put your scrollbar calculations and SetScrollbar call into a function named AdjustScrollbars, which can be called initially and also from your {Wx::SizeEvent} handler function.
     # @see Scrolled Windows
     # @see  Wx::ScrollBar
@@ -534,8 +535,9 @@ module Wx
     # @overload from_dip(sz)
     #   Convert DPI-independent pixel values to the value in pixels appropriate for the current toolkit.
     #   A DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To keep the same physical size at higher resolution, the physical pixel value must be scaled by {Wx::Window#get_dpi_scale_factor} but this scaling may be already done by the underlying toolkit (GTK+, Cocoa, ...) automatically. This method performs the conversion only if it is not already done by the lower level toolkit and so by using it with pixel values you can guarantee that the physical size of the corresponding elements will remain the same in all resolutions under all platforms. For example, instead of creating a bitmap of the hard coded size of 32 pixels you should use 
-    #   
+    #   ```
     #     wxBitmap bmp(FromDIP(32, 32));
+    #   ```
     #    to avoid using tiny bitmaps on high DPI screens.
     #   Notice that this function is only needed when using hard coded pixel values. It is not necessary if the sizes are already based on the DPI-independent units such as dialog units or if you are relying on the controls automatic best size determination and using sizers to lay out them.
     #   Also note that if either component of sz has the special value of -1, it is returned unchanged independently of the current DPI, to preserve the special value of -1 in wxWidgets API (it is often used to mean "unspecified").
@@ -575,9 +577,10 @@ module Wx
     # @overload to_dip(sz)
     #   Convert pixel values of the current toolkit to DPI-independent pixel values.
     #   A DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To keep the same physical size at higher resolution, the physical pixel value must be scaled by {Wx::Window#get_dpi_scale_factor} but this scaling may be already done by the underlying toolkit (GTK+, Cocoa, ...) automatically. This method performs the conversion only if it is not already done by the lower level toolkit, For example, you may want to use this to store window sizes and positions so that they can be re-used regardless of the display DPI: 
-    #   
+    #   ```
     #     wxPoint pt(ToDIP(GetPosition()));
     #     wxSize size(ToDIP(GetSize()));
+    #   ```
     #   
     #   Also note that if either component of sz has the special value of -1, it is returned unchanged independently of the current DPI, to preserve the special value of -1 in wxWidgets API (it is often used to mean "unspecified").
     #   @param sz [Array(Integer, Integer), Wx::Size] 
@@ -904,8 +907,9 @@ module Wx
     
     # Sets the maximum client size of the window, to indicate to the sizer layout mechanism that this is the maximum possible size of its client area.
     # Note that this method is just a shortcut for: 
-    # 
+    # ```
     #   SetMaxSize(ClientToWindowSize(size));
+    # ```
     # @see Wx::Window#set_max_size
     # @see  Window Sizing Overview 
     # @param size [Array(Integer, Integer), Wx::Size] 
@@ -926,8 +930,9 @@ module Wx
     # You may need to call this if you change the window size after construction and before adding to its parent sizer.
     # Note, that just as with {Wx::Window#set_min_size}, calling this method doesn't prevent the program from explicitly making the window smaller than the specified size.
     # Note that this method is just a shortcut for: 
-    # 
+    # ```
     #   SetMinSize(ClientToWindowSize(size));
+    # ```
     # @see Wx::Window#set_min_size
     # @see  Window Sizing Overview 
     # @param size [Array(Integer, Integer), Wx::Size] 
@@ -1074,8 +1079,9 @@ module Wx
     # @overload move(x, y, flags=Wx::SIZE_USE_EXISTING)
     #   Moves the window to the given position.
     #   Implementations of SetSize can also implicitly implement the {Wx::Window#move} function, which is defined in the base {Wx::Window} class as the call: 
-    #   
+    #   ```
     #     SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
+    #   ```
     #   @see Wx::Window#set_size 
     #   @param x [Integer]  Required x position.
     #   @param y [Integer]  Required y position.
@@ -1084,8 +1090,9 @@ module Wx
     # @overload move(pt, flags=Wx::SIZE_USE_EXISTING)
     #   Moves the window to the given position.
     #   Implementations of {Wx::Window#set_size} can also implicitly implement the {Wx::Window#move} function, which is defined in the base {Wx::Window} class as the call: 
-    #   
+    #   ```
     #     SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
+    #   ```
     #   @see Wx::Window#set_size 
     #   @param pt [Array(Integer, Integer), Wx::Point]  {Wx::Point} object representing the position.
     #   @param flags [Integer]  See {Wx::Window#set_size} for more info about this parameter.
@@ -1108,8 +1115,9 @@ module Wx
     #   Converts a point or size from dialog units to pixels.
     #   For the x dimension, the dialog units are multiplied by the average character width and then divided by 4. For the y dimension, the dialog units are multiplied by the average character height and then divided by 8.
     #   Dialog units are used for maintaining a dialog's proportions even if the font changes. You can also use these functions programmatically. A convenience macro is defined: 
-    #   
+    #   ```
     #     #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
+    #   ```
     #   @see Wx::Window#convert_pixels_to_dialog 
     #   @param pt [Array(Integer, Integer), Wx::Point] 
     #   @return [Wx::Point]
@@ -1300,7 +1308,7 @@ module Wx
     # Notice that in previous versions of wxWidgets a common way to work around the above mentioned flickering problem was to define an empty EVT_ERASE_BACKGROUND handler. Setting background style to {Wx::BackgroundStyle::BG_STYLE_PAINT} is a simpler and more efficient solution to the same problem.
     # Under {Wx::GTK} and {Wx::OSX}, you can use {Wx::BackgroundStyle::BG_STYLE_TRANSPARENT} to obtain full transparency of the window background. Note that {Wx::GTK} supports this only since GTK 2.12 with a compositing manager enabled, call {Wx::Window#is_transparent_background_supported} to check whether this is the case, see the example of doing it in the shapedsample".
     # Also, in order for <code>SetBackgroundStyle(wxBG_STYLE_TRANSPARENT)</code> to work, it must be called before {Wx::Window#create}. If you're using your own {Wx::Window}-derived class you should write your code in the following way: 
-    # 
+    # ```
     #   class MyWidget : public wxWindow
     #   {
     #   public:
@@ -1314,6 +1322,7 @@ module Wx
     #           Create(parent, ...);
     #       }
     #   };
+    # ```
     # @see Wx::Window#set_background_colour
     # @see  Wx::Window#get_foreground_colour
     # @see  Wx::Window#set_transparent
@@ -1468,7 +1477,9 @@ module Wx
     def handle_as_navigation_key(event) end
     
     # Shorthand for:
-    # GetEventHandler()->SafelyProcessEvent(event);
+    # ```
+    #   GetEventHandler()->SafelyProcessEvent(event);
+    # ```
     # @see Wx::Window#process_window_event 
     # @param event [Wx::Event] 
     # @return [true,false]
@@ -1476,8 +1487,9 @@ module Wx
     
     # Convenient wrapper for {Wx::Window#process_event}.
     # This is the same as writing 
-    # 
+    # ```
     #   GetEventHandler()->ProcessEvent(event);
+    # ```
     #  but more convenient. Notice that {Wx::Window#process_event} itself can't be called for {Wx::Window} objects as it ignores the event handlers associated with the window; use this function instead.
     # @param event [Wx::Event] 
     # @return [true,false]
@@ -1493,9 +1505,10 @@ module Wx
     # An event handler is an object that is capable of processing the events sent to a window. By default, the window is its own event handler, but an application may wish to substitute another, for example to allow central implementation of event-handling for a variety of different window classes.
     # {Wx::Window#push_event_handler} allows an application to set up a stack of event handlers, where an event not handled by one event handler is handed to the next one in the chain.
     # E.g. if you have two event handlers A and B and a {Wx::Window} instance W and you call: 
-    # 
+    # ```
     #   W->PushEventHandler(A);
     #   W->PushEventHandler(B);
+    # ```
     #  you will end up with the following situation: 
     # 
     # Note that you can use {Wx::Window#pop_event_handler} to remove the event handler.
@@ -1704,10 +1717,11 @@ module Wx
     # Enable or disable the window for user input.
     # Note that when a parent window is disabled, all of its children are disabled as well and they are re-enabled again when the parent is.
     # A window can be created initially disabled by calling this method on it before calling {Wx::Window#create} to create the actual underlying window, e.g. 
-    # 
+    # ```
     #   wxWindow* w = new MyWindow(); // Note: default ctor is used here.
     #   w->Enable(false);
     #   w->Create(parent, ... all the usual non-default ctor arguments ...);
+    # ```
     # 
     # Returns true if the window has been enabled or disabled, false if nothing was done, i.e. if the window had already been in the specified state.
     # @see Wx::Window#is_enabled
@@ -2074,7 +2088,7 @@ module Wx
     # Return the cursor associated with this window.
     # 
     # @see Wx::Window#set_cursor 
-    # @return [void]
+    # @return [Wx::Cursor]
     def get_cursor; end
     alias_method :cursor, :get_cursor
     
@@ -2123,8 +2137,9 @@ module Wx
     
     # Request generation of touch events for this window.
     # Each call to this function supersedes the previous ones, i.e. if you want to receive events for both zoom and rotate gestures, you need to call 
-    # 
+    # ```
     #   EnableTouchEvents(wxTOUCH_ZOOM_GESTURE | wxTOUCH_ROTATE_GESTURE);
+    # ```
     #  instead of calling it twice in a row as the second call would disable the first gesture.
     # 
     # true if the specified events were enabled or false if the current platform doesn't support touch events.
@@ -2158,6 +2173,7 @@ module Wx
     # Does the window-specific updating after processing the update event.
     # This function is called by {Wx::Window#update_window_ui} in order to check return values in the {Wx::UpdateUIEvent} and act appropriately. For example, to allow frame and dialog title updating, wxWidgets implements this function as follows:
     # 
+    # ```
     #   // do the window-specific processing after processing the update event
     #   void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
     #   {
@@ -2170,6 +2186,7 @@ module Wx
     #               SetTitle(event.GetText());
     #       }
     #   }
+    # ```
     # @param event [Wx::UpdateUIEvent] 
     # @return [void]
     def do_update_window_ui(event) end
@@ -2254,11 +2271,13 @@ module Wx
     # You can call this function from your application to ensure that your UI is up-to-date at this point (as far as your {Wx::UpdateUIEvent} handlers are concerned). This may be necessary if you have called {Wx::UpdateUIEvent.set_mode} or {Wx::UpdateUIEvent.set_update_interval} to limit the overhead that wxWidgets incurs by sending update UI events in idle time. flags should be a bitlist of one or more of the {Wx::UpdateUI} enumeration.
     # If you are calling this function from an OnInternalIdle or OnIdle function, make sure you pass the {Wx::UpdateUI::UPDATE_UI_FROMIDLE} flag, since this tells the window to only update the UI elements that need to be updated in idle time. Some windows update their elements only when necessary, for example when a menu is about to be shown. The following is an example of how to call UpdateWindowUI from an idle function.
     # 
+    # ```
     #   void MyWindow::OnInternalIdle()
     #   {
     #       if (wxUpdateUIEvent::CanUpdate(this))
     #           UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
     #   }
+    # ```
     # @see Wx::UpdateUIEvent
     # @see  Wx::Window#do_update_window_ui
     # @see  Wx::Window#on_internal_idle 
@@ -2364,15 +2383,16 @@ module Wx
     # The non-default constructor of {Wx::Window} class does two things: it initializes the C++ object and it also creates the window object in the underlying graphical toolkit. The {Wx::Window#create} method can be used to perform the second part later, while the default constructor can be used to perform the first part only.
     # Please note that the underlying window must be created exactly once, i.e. if you use the default constructor, which doesn't do this, you must call {Wx::Window#create} before using the window and if you use the non-default constructor, you can not call {Wx::Window#create}, as the underlying window is already created.
     # Note that it is possible and, in fact, useful, to call some methods on the object between creating the C++ object itself and calling {Wx::Window#create} on it, e.g. a common pattern to avoid showing the contents of a window before it is fully initialized is: 
-    # 
+    # ```
     #   wxPanel* panel = new wxPanel(); // Note: default constructor used.
     #   panel->Hide(); // Can be called before actually creating it.
     #   panel->Create(parent, wxID_ANY, ...); // Won't be shown yet.
     #   ... create all the panel children ...
     #   panel->Show(); // Now everything will be shown at once.
+    # ```
     # 
     # Also note that it is possible to create an object of a derived type and then call {Wx::Window#create} on it: 
-    # 
+    # ```
     #   // Suppose we have this function (which would typically be in a
     #   // different translation unit (file) from the rest of the code).
     #   wxWindow* MyCreateWindowObjectFunction() {
@@ -2391,6 +2411,7 @@ module Wx
     #   // This calls the base wxWindow::Create() as it is not virtual, so
     #   // the derived class can't customize this part.
     #   window->Create(parent, wxID_ANY, ...);
+    # ```
     #  This is notably used by XML Based Resource System (XRC).
     # The parameters of this method have exactly the same meaning as the non-default constructor parameters, please refer to them for their description.
     # true if window creation succeeded or false if it failed

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

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

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

@@ -16,6 +16,8 @@ module Wx
   # @see Wx::BusyCursor 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class WindowDisabler < ::Object
   
   end # WindowDisabler

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

@@ -42,10 +42,12 @@ module Wx
     # A helper chaining this page with the next one.
     # Notice that this method returns a reference to the next page, so the calls to it can, in turn, be chained:
     # 
+    # ```
     #   wxWizardPageSimple* firstPage = new FirstPage;
     #   (*firstPage).Chain(new SecondPage)
     #               .Chain(new ThirdPage)
     #               .Chain(new LastPage);
+    # ```
     # 
     # This makes this method the simplest way to define the order of changes in fully static wizards, i.e. in those where the order doesn't depend on the choices made by the user in the wizard pages during run-time.
     # 

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

@@ -104,6 +104,8 @@ module Wx
   # @see  Wx::XmlAttribute 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class XmlNode < ::Object
   
     # @overload initialize(type, name, content=(''), lineNo=-1)
@@ -193,13 +195,17 @@ module Wx
     # Returns the content of the first child node of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
     # This function is very useful since the XML snippet <code>"tagnametagcontent/tagname"</code> is represented by expat with the following tag tree:
     # 
+    # ```
     #   wxXML_ELEMENT_NODE name="tagname", content=""
     #   |-- wxXML_TEXT_NODE name="", content="tagcontent"
+    # ```
     # 
     # or eventually:
     # 
+    # ```
     #   wxXML_ELEMENT_NODE name="tagname", content=""
     #   |-- wxXML_CDATA_SECTION_NODE name="", content="tagcontent"
+    # ```
     # 
     # An empty string is returned if the node has no children of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}, or if the content of the first child of such types is empty.
     # @return [String]

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

@@ -104,9 +104,10 @@ module Wx
     
     # Loads resources from XML files that match given filemask.
     # Example: 
-    # 
+    # ```
     #   if (!wxXmlResource::Get()->Load("rc/*.xrc"))
     #       wxLogError("Couldn't load resources!");
+    # ```
     # 
     # If {Wx::USE_FILESYS} is enabled, this method understands {Wx::FileSystem} URLs (see Wx::FileSystem#find_first).
     # 
@@ -150,9 +151,11 @@ module Wx
     # parent points to parent window (if any).
     # This form is used to finish creation of an already existing instance (the main reason for this is that you may want to use derived class with a new event table). Example:
     # 
+    # ```
     #   MyDialog dlg;
     #   wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
     #   dlg.ShowModal();
+    # ```
     # @param dlg [Wx::Dialog] 
     # @param parent [Wx::Window] 
     # @param name [String]