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

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

@@ -84,7 +84,6 @@ module Wx
     # @overload calc_scrolled_position(x, y)
     #   Translates the logical coordinates to the device ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcScrolledPosition(0, 10, xx, yy) will return 0 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_unscrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -97,7 +96,6 @@ module Wx
     # @overload calc_unscrolled_position(x, y)
     #   Translates the device coordinates to the logical ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcUnscrolledPosition(0, 0, xx, yy) will return 10 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_scrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -127,7 +125,7 @@ module Wx
     # Call this function to prepare the device context for drawing a scrolled image.
     # It sets the device origin according to the current scroll position. Wx::Scrolled#do_prepare_dc is called automatically within the default {Wx::EVT_PAINT} event handler, so your Wx::Scrolled#on_draw override will be passed an already 'pre-scrolled' device context. However, if you wish to draw from outside of Wx::Scrolled#on_draw (e.g. from your own {Wx::EVT_PAINT} handler), you must call this function yourself.
     # For example: 
-    # 
+    # ```
     #   void MyWindow::OnEvent(wxMouseEvent& event)
     #   {
     #     wxClientDC dc(this);
@@ -143,6 +141,7 @@ module Wx
     #     xpos = x;
     #     ypos = y;
     #   }
+    # ```
     # 
     # Notice that the function sets the origin by moving it relatively to the current origin position, so you shouldn't change the origin before calling Wx::Scrolled#do_prepare_dc or, if you do, reset it to (0, 0) later. If you call Wx::Scrolled#do_prepare_dc immediately after device context creation, as in the example above, this problem doesn't arise, of course, so it is customary to do it like this.
     # @param dc [Wx::DC] 
@@ -169,8 +168,6 @@ module Wx
     
     # Get the number of pixels per scroll unit (line), in each direction, as set by Wx::Scrolled#set_scrollbars.
     # A value of zero indicates no scrolling in that direction.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_virtual_size 
     # @return [Array(Integer,Integer)]
@@ -184,8 +181,6 @@ module Wx
     
     # Gets the size in device units of the scrollable window area (as opposed to the client size, which is the area of the window currently visible).
     # Use {Wx::DC#device_to_logical_x} and {Wx::DC#device_to_logical_y} to translate these units to logical units.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_scroll_pixels_per_unit 
     # @return [Array(Integer,Integer)]
@@ -228,8 +223,9 @@ module Wx
     # The first pair of parameters give the number of pixels per 'scroll step', i.e. amount moved when the up or down scroll arrows are pressed. The second pair gives the length of scrollbar in scroll steps, which sets the size of the virtual window.
     # xPos and yPos optionally specify a position to scroll to immediately.
     # For example, the following gives a window horizontal and vertical scrollbars with 20 pixels per scroll step, and a size of 50 steps (1000 pixels) in each direction: 
-    # 
+    # ```
     #   window->SetScrollbars(20, 20, 50, 50);
+    # ```
     # 
     # {Wx::Scrolled} manages the page size itself, using the current client window size as the page size.
     # Note that for more sophisticated scrolling applications, for example where scroll steps may be variable according to the position in the document, it will be necessary to derive a new class from {Wx::Window}, overriding OnSize() and adjusting the scrollbars appropriately.

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

@@ -84,7 +84,6 @@ module Wx
     # @overload calc_scrolled_position(x, y)
     #   Translates the logical coordinates to the device ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcScrolledPosition(0, 10, xx, yy) will return 0 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_unscrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -97,7 +96,6 @@ module Wx
     # @overload calc_unscrolled_position(x, y)
     #   Translates the device coordinates to the logical ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcUnscrolledPosition(0, 0, xx, yy) will return 10 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_scrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -127,7 +125,7 @@ module Wx
     # Call this function to prepare the device context for drawing a scrolled image.
     # It sets the device origin according to the current scroll position. Wx::Scrolled#do_prepare_dc is called automatically within the default {Wx::EVT_PAINT} event handler, so your Wx::Scrolled#on_draw override will be passed an already 'pre-scrolled' device context. However, if you wish to draw from outside of Wx::Scrolled#on_draw (e.g. from your own {Wx::EVT_PAINT} handler), you must call this function yourself.
     # For example: 
-    # 
+    # ```
     #   void MyWindow::OnEvent(wxMouseEvent& event)
     #   {
     #     wxClientDC dc(this);
@@ -143,6 +141,7 @@ module Wx
     #     xpos = x;
     #     ypos = y;
     #   }
+    # ```
     # 
     # Notice that the function sets the origin by moving it relatively to the current origin position, so you shouldn't change the origin before calling Wx::Scrolled#do_prepare_dc or, if you do, reset it to (0, 0) later. If you call Wx::Scrolled#do_prepare_dc immediately after device context creation, as in the example above, this problem doesn't arise, of course, so it is customary to do it like this.
     # @param dc [Wx::DC] 
@@ -169,8 +168,6 @@ module Wx
     
     # Get the number of pixels per scroll unit (line), in each direction, as set by Wx::Scrolled#set_scrollbars.
     # A value of zero indicates no scrolling in that direction.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_virtual_size 
     # @return [Array(Integer,Integer)]
@@ -184,8 +181,6 @@ module Wx
     
     # Gets the size in device units of the scrollable window area (as opposed to the client size, which is the area of the window currently visible).
     # Use {Wx::DC#device_to_logical_x} and {Wx::DC#device_to_logical_y} to translate these units to logical units.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_scroll_pixels_per_unit 
     # @return [Array(Integer,Integer)]
@@ -228,8 +223,9 @@ module Wx
     # The first pair of parameters give the number of pixels per 'scroll step', i.e. amount moved when the up or down scroll arrows are pressed. The second pair gives the length of scrollbar in scroll steps, which sets the size of the virtual window.
     # xPos and yPos optionally specify a position to scroll to immediately.
     # For example, the following gives a window horizontal and vertical scrollbars with 20 pixels per scroll step, and a size of 50 steps (1000 pixels) in each direction: 
-    # 
+    # ```
     #   window->SetScrollbars(20, 20, 50, 50);
+    # ```
     # 
     # {Wx::Scrolled} manages the page size itself, using the current client window size as the page size.
     # Note that for more sophisticated scrolling applications, for example where scroll steps may be variable according to the position in the document, it will be necessary to derive a new class from {Wx::Window}, overriding OnSize() and adjusting the scrollbars appropriately.

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

@@ -104,7 +104,6 @@ module Wx
     # @overload calc_scrolled_position(x, y)
     #   Translates the logical coordinates to the device ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcScrolledPosition(0, 10, xx, yy) will return 0 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_unscrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -117,7 +116,6 @@ module Wx
     # @overload calc_unscrolled_position(x, y)
     #   Translates the device coordinates to the logical ones.
     #   For example, if a window is scrolled 10 pixels to the bottom, the device coordinates of the origin are (0, 0) (as always), but the logical coordinates are (0, 10) and so the call to CalcUnscrolledPosition(0, 0, xx, yy) will return 10 in yy.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes two parameters and returns a 2-element list (xx, yy).
     #   @see Wx::Scrolled#calc_scrolled_position 
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -147,7 +145,7 @@ module Wx
     # Call this function to prepare the device context for drawing a scrolled image.
     # It sets the device origin according to the current scroll position. Wx::Scrolled#do_prepare_dc is called automatically within the default {Wx::EVT_PAINT} event handler, so your Wx::Scrolled#on_draw override will be passed an already 'pre-scrolled' device context. However, if you wish to draw from outside of Wx::Scrolled#on_draw (e.g. from your own {Wx::EVT_PAINT} handler), you must call this function yourself.
     # For example: 
-    # 
+    # ```
     #   void MyWindow::OnEvent(wxMouseEvent& event)
     #   {
     #     wxClientDC dc(this);
@@ -163,6 +161,7 @@ module Wx
     #     xpos = x;
     #     ypos = y;
     #   }
+    # ```
     # 
     # Notice that the function sets the origin by moving it relatively to the current origin position, so you shouldn't change the origin before calling Wx::Scrolled#do_prepare_dc or, if you do, reset it to (0, 0) later. If you call Wx::Scrolled#do_prepare_dc immediately after device context creation, as in the example above, this problem doesn't arise, of course, so it is customary to do it like this.
     # @param dc [Wx::DC] 
@@ -189,8 +188,6 @@ module Wx
     
     # Get the number of pixels per scroll unit (line), in each direction, as set by Wx::Scrolled#set_scrollbars.
     # A value of zero indicates no scrolling in that direction.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_virtual_size 
     # @return [Array(Integer,Integer)]
@@ -204,8 +201,6 @@ module Wx
     
     # Gets the size in device units of the scrollable window area (as opposed to the client size, which is the area of the window currently visible).
     # Use {Wx::DC#device_to_logical_x} and {Wx::DC#device_to_logical_y} to translate these units to logical units.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (xUnit, yUnit).
     # @see Wx::Scrolled#set_scrollbars
     # @see  Wx::Scrolled#get_scroll_pixels_per_unit 
     # @return [Array(Integer,Integer)]
@@ -248,8 +243,9 @@ module Wx
     # The first pair of parameters give the number of pixels per 'scroll step', i.e. amount moved when the up or down scroll arrows are pressed. The second pair gives the length of scrollbar in scroll steps, which sets the size of the virtual window.
     # xPos and yPos optionally specify a position to scroll to immediately.
     # For example, the following gives a window horizontal and vertical scrollbars with 20 pixels per scroll step, and a size of 50 steps (1000 pixels) in each direction: 
-    # 
+    # ```
     #   window->SetScrollbars(20, 20, 50, 50);
+    # ```
     # 
     # {Wx::Scrolled} manages the page size itself, using the current client window size as the page size.
     # Note that for more sophisticated scrolling applications, for example where scroll steps may be variable according to the position in the document, it will be necessary to derive a new class from {Wx::Window}, overriding OnSize() and adjusting the scrollbars appropriately.

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

@@ -0,0 +1,131 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  EVT_SEARCH_CANCEL = 10129
+  
+  # 
+  # 
+  EVT_SEARCH = 10130
+  
+  # A search control is a composite control with a search button, a text control, and a cancel button.
+  # This control is implemented natively under macOS and GTK 3.6 or later and generically for all the other platforms.
+  # Please note that this class provides many {Wx::TextCtrl}-like methods, but does not necessarily derive from {Wx::TextCtrl} in all ports (although it does in the generic version). Only the methods defined in {Wx::TextEntry} interface class are guaranteed to be available under all platforms.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::TE_PROCESS_TAB}: The control will receive {Wx::EVT_CHAR} events for TAB pressed - normally, TAB is used for passing to the next control in a dialog instead. For the control created with this style, you can still use Ctrl-Enter to pass to the next control from the keyboard. 
+  # - {Wx::TE_NOHIDESEL}: By default, the Windows text control doesn't show the selection when it doesn't have focus - use this style to force it to always show it. It doesn't do anything under other platforms. 
+  # - {Wx::TE_LEFT}: The text in the control will be left-justified (default). 
+  # - {Wx::TE_CENTRE}: The text in the control will be centered (currently {Wx::MSW} and {Wx::GTK2} only). 
+  # - {Wx::TE_RIGHT}: The text in the control will be right-justified (currently {Wx::MSW} and {Wx::GTK2} only). 
+  # - {Wx::TE_CAPITALIZE}: On PocketPC and Smartphone, causes the first letter to be capitalized. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CommandEvent} events.
+  # Event handler methods for events emitted by this class:{Wx::TextCtrl}. However it is recommended to use {Wx::EVT_SEARCH} to actually start searching to avoid doing it too soon, while the user is still typing (note that {Wx::EVT_SEARCH} is also triggered by pressing Enter in the control). 
+  # - {Wx::EvtHandler#evt_search}(id, meth = nil, &block): Respond to a {Wx::EVT_SEARCH} event, generated when the search button is clicked. Note that this does not initiate a search on its own, you need to perform the appropriate action in your event handler. You may use 
+  # - {Wx::EvtHandler#evt_search_cancel}(id, meth = nil, &block): Respond to a {Wx::EVT_SEARCH_CANCEL} event, generated when the cancel button is clicked. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> {Wx::MSW} Appearance
+  #   </td><td> {Wx::GTK} Appearance
+  #   </td><td> {Wx::OSX} Appearance
+  #   </td></tr></table></div>
+  # @see Wx::TextCtrl 
+  # 
+  # 
+  class SearchCtrl < Control
+  
+    include Wx::TextEntry
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [SearchCtrl]
+    # @overload initialize(parent, id, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SearchCtrlNameStr)
+    #   Constructor, creating and showing a text control.
+    #   
+    #   @see Wx::TextCtrl#create
+    #   @see  Wx::Validator 
+    #   @param parent [Wx::Window]  Parent window. Should not be NULL.
+    #   @param id [Integer]  Control identifier. A value of -1 denotes a default value.
+    #   @param value [String]  Default text value.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Text control position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Text control size.
+    #   @param style [Integer]  Window style. See {Wx::SearchCtrl}.
+    #   @param validator [Wx::Validator]  Window validator.
+    #   @param name [String]  Window name.
+    #   @return [SearchCtrl]
+    def initialize(*args) end
+    
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param value [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param validator [Wx::Validator] 
+    # @param name [String] 
+    # @return [true,false]
+    def create(parent, id, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SearchCtrlNameStr) end
+    
+    # Returns a pointer to the search control's menu object or NULL if there is no menu attached.
+    # @return [Wx::Menu]
+    def get_menu; end
+    alias_method :menu, :get_menu
+    
+    # Returns the search button visibility value.
+    # If there is a menu attached, the search button will be visible regardless of the search button visibility value.
+    # @return [true,false]
+    def is_search_button_visible; end
+    alias_method :search_button_visible?, :is_search_button_visible
+    
+    # Returns the cancel button's visibility state.
+    # @return [true,false]
+    def is_cancel_button_visible; end
+    alias_method :cancel_button_visible?, :is_cancel_button_visible
+    
+    # Sets the search control's menu object.
+    # If there is already a menu associated with the search control it is deleted.
+    # @param menu [Wx::Menu]  Menu to attach to the search control.
+    # @return [void]
+    def set_menu(menu) end
+    alias_method :menu=, :set_menu
+    
+    # Shows or hides the cancel button.
+    # Note that this function does nothing in the native GTK version of the control: "Cancel" button is always shown automatically if the control is not empty and hidden if it is empty.
+    # @param show [true,false] 
+    # @return [void]
+    def show_cancel_button(show) end
+    
+    # Sets the search button visibility value on the search control.
+    # If there is a menu attached, the search button will be visible regardless of the search button visibility value.
+    # Note that this function does nothing in the native GTK version of the control: "Search" button is always shown there.
+    # @param show [true,false] 
+    # @return [void]
+    def show_search_button(show) end
+    
+    # Set the text to be displayed in the search control when the user has not yet typed anything in it.
+    # @param text [String] 
+    # @return [void]
+    def set_descriptive_text(text) end
+    alias_method :descriptive_text=, :set_descriptive_text
+    
+    # Return the text displayed when there is not yet any user input.
+    # @return [String]
+    def get_descriptive_text; end
+    alias_method :descriptive_text, :get_descriptive_text
+    
+  end # SearchCtrl
+  
+
+end

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

@@ -36,8 +36,6 @@ module Wx
   
     # Constructor, taking an array of {Wx::String} choices and optional client data.
     # Use {Wx::SingleChoiceDialog#show_modal} to show the dialog.
-    # 
-    # <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
     # @param parent [Wx::Window]  Parent window.
     # @param message [String]  Message to show on the dialog.
     # @param caption [String]  The dialog caption.

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

@@ -222,8 +222,9 @@ module Wx
     
     # This base function adds non-stretchable space to both the horizontal and vertical orientation of the sizer.
     # More readable way of calling: 
-    # 
+    # ```
     #   wxSizer::Add(size, size, 0).
+    # ```
     # @see Wx::BoxSizer#add_spacer 
     # @param size [Integer] 
     # @return [Wx::SizerItem]
@@ -231,8 +232,9 @@ module Wx
     
     # Adds stretchable space to the sizer.
     # More readable way of calling: 
-    # 
+    # ```
     #   wxSizer::Add(0, 0, prop).
+    # ```
     # @param prop [Integer] 
     # @return [Wx::SizerItem]
     def add_stretch_spacer(prop=1) end
@@ -623,7 +625,7 @@ module Wx
     # This method first calls {Wx::Sizer#fit} and then {Wx::TopLevelWindow#set_size_hints} on the window passed to it.
     # This function is only when window is actually a {Wx::TopLevelWindow} such as a {Wx::Frame} or a {Wx::Dialog}, since SetSizeHints only has any effect in these classes. It does nothing in normal windows or controls.
     # Note that window does not need to be the window using this sizer and it is, in fact, common to call this function on the sizer associated with the panel covering the client area of a frame passing it the frame pointer, as this has the desired effect of adjusting the frame size to the size fitting the panel, e.g.: 
-    # 
+    # ```
     #   MyFrame::MyFrame(...) : wxFrame(...)
     #   {
     #       wxPanel* panel = new wxPanel(this);
@@ -636,6 +638,7 @@ module Wx
     #       // frame to fit its contents.
     #       sizer->SetSizeHints(this);
     #   }
+    # ```
     # 
     # This function is also used by {Wx::Window#set_sizer_and_fit} which is commonly invoked in the constructor of {Wx::Dialog}-derived classes, which don't need to use an intermediate panel, see the example in wxBoxSizer overview.
     # @param window [Wx::Window] 
@@ -686,19 +689,25 @@ module Wx
   # Container for sizer items flags providing readable names for them.
   # Normally, when you add an item to a sizer via {Wx::Sizer#add}, you have to specify a lot of flags and parameters which can be unwieldy. This is where {Wx::SizerFlags} comes in: it allows you to specify all parameters using the named methods instead. For example, instead of
   # 
+  # ```
   #   sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
+  # ```
   # 
   # you can now write
   # 
+  # ```
   #   sizer->Add(ctrl, wxSizerFlags().Expand().Border(wxALL, 10));
+  # ```
   # 
   # This is more readable and also allows you to create {Wx::SizerFlags} objects which can be reused for several sizer items.
   # 
+  # ```
   #   wxSizerFlags flagsExpand(1);
   #       flagsExpand.Expand().Border(wxALL, 10);
   #   
   #       sizer->Add(ctrl1, flagsExpand);
   #       sizer->Add(ctrl2, flagsExpand);
+  # ```
   # 
   # Note that by specification, all methods of {Wx::SizerFlags} return the {Wx::SizerFlags} object itself to allowing chaining multiple methods calls like in the examples above.
   # === 
@@ -707,6 +716,8 @@ module Wx
   # @see Wx::Sizer 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SizerFlags < ::Object
   
     # Creates the {Wx::Sizer} with the proportion specified by proportion.

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

@@ -25,6 +25,7 @@ module Wx
   # Show it in application initialisation, and then either explicitly destroy it or let it time-out.
   # Example usage:
   # 
+  # ```
   #   wxBitmap bitmap;
   #   if (bitmap.LoadFile("splash16.png", wxBITMAP_TYPE_PNG))
   #   {
@@ -34,6 +35,7 @@ module Wx
   #           wxBORDER_SIMPLE|wxSTAY_ON_TOP);
   #   }
   #   wxYield();
+  # ```
   # 
   # === 
   # 

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

@@ -9,7 +9,7 @@ module Wx
   # A static box is a rectangle drawn around other windows to denote a logical grouping of items.
   # Note that while the previous versions required that windows appearing inside a static box be created as its siblings (i.e. use the same parent as the static box itself), since wxWidgets 2.9.1 it is possible to create them as children of {Wx::StaticBox} itself and doing this is strongly recommended and avoids several different repainting problems that could happen when creating the other windows as siblings of the box.
   # So the recommended way to create static box and the controls inside it is: 
-  # 
+  # ```
   #   void MyFrame::CreateControls()
   #   {
   #       wxPanel *panel = new wxPanel(this);
@@ -18,6 +18,7 @@ module Wx
   #       new wxStaticText(box, wxID_ANY, "This window is a child of the staticbox");
   #       ...
   #   }
+  # ```
   # 
   # Creating the windows with the static box parent (i.e. panel in the example above) as parent still works but can result in refresh and repaint problems.
   # Also note that there is a specialized {Wx::Sizer} class ({Wx::StaticBoxSizer}) which can be used as an easier way to pack items into a static box.
@@ -53,7 +54,7 @@ module Wx
     #   This constructor takes a pointer to an arbitrary window (although usually a {Wx::CheckBox} or a {Wx::RadioButton}) instead of just the usual text label and puts this window at the top of the box at the place where the label would be shown.
     #   The label window must be a non-null, fully created window and will become a child of this {Wx::StaticBox}, i.e. it will be owned by this control and will be deleted when the {Wx::StaticBox} itself is deleted.
     #   An example of creating a {Wx::StaticBox} with window as a label: 
-    #   
+    #   ```
     #     void MyFrame::CreateControls()
     #     {
     #         wxPanel* panel = new wxPanel(this);
@@ -61,6 +62,7 @@ module Wx
     #         wxStaticBox* box = new wxStaticBox(panel, wxID_ANY, checkbox);
     #         ...
     #     }
+    #   ```
     #   
     #   Currently this constructor is only available in {Wx::GTK} and {Wx::MSW}, use {Wx::HAS_WINDOW_LABEL_IN_STATIC_BOX} to check whether it can be used at compile-time.
     #   @param parent [Wx::Window] 
@@ -102,13 +104,14 @@ module Wx
     # Enables or disables the box without affecting its label window, if any.
     # {Wx::StaticBox} overrides {Wx::Window#enable} in order to avoid disabling the control used as a label, if this box is using one. This is done in order to allow using a {Wx::CheckBox}, for example, label and enable or disable the box according to the state of the checkbox: if disabling the box also disabled the checkbox in this situation, it would make it impossible for the user to re-enable the box after disabling it, so the checkbox stays enabled even if <code>box->Enable(false)</code> is called.
     # However with the actual behaviour, implemented in this overridden method, the following code (shown using C++11 only for convenience, this behaviour is not C++11-specific): 
-    # 
+    # ```
     #   auto check = new wxCheckBox(parent, wxID_ANY, "Use the box");
     #   auto box = new wxStaticBox(parent, wxID_ANY, check);
     #   check->Bind(wxEVT_CHECKBOX,
     #               [box](wxCommandEvent& event) {
     #                   box->Enable(event.IsChecked());
     #               });
+    # ```
     #  does work as expected.
     # Please note that overriding {Wx::StaticBox#enable} to not actually disable this window itself has two possibly unexpected consequences:
     # 

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

@@ -10,7 +10,7 @@ module Wx
   # The static box may be either created independently or the sizer may create it itself as a convenience. In any case, the sizer owns the {Wx::StaticBox} control and will delete it in the {Wx::StaticBoxSizer} destructor.
   # Note that since wxWidgets 2.9.1 you are strongly encouraged to create the windows which are added to {Wx::StaticBoxSizer} as children of {Wx::StaticBox} itself, see this class documentation for more details.
   # Example of use of this class: 
-  # 
+  # ```
   #   void MyFrame::CreateControls()
   #   {
   #       wxPanel *panel = new wxPanel(this);
@@ -20,6 +20,7 @@ module Wx
   #                                "This window is a child of the staticbox"));
   #       ...
   #   }
+  # ```
   # 
   # === 
   # 

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

@@ -90,8 +90,6 @@ module Wx
     
     # Returns the size and position of a field's internal bounding rectangle.
     # true if the field index is valid, false otherwise.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function returns a Wx::Rect if the field index is valid, undef otherwise.
     # @see Wx::Rect 
     # @param i [Integer]  The field in question.
     # @return [Array(true,false,Wx::Rect)]
@@ -153,7 +151,6 @@ module Wx
     def push_status_text(string, field=0) end
     
     # Sets the number of fields, and optionally the field widths.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function accepts only the number parameter. Use SetStatusWidths to set the field widths.
     # @param number [Integer]  The number of fields. If this is greater than the previous number, then new fields with empty strings will be added to the status bar.
     # @param widths [Array<Integer>]  An array of n integers interpreted in the same way as in {Wx::StatusBar#set_status_widths}.
     # @return [void]
@@ -189,8 +186,6 @@ module Wx
     # For example, to create one fixed width field of width 100 in the right part of the status bar and two more fields which get 66% and 33% of the remaining space correspondingly, you should use an array containing -2, -1 and 100.
     # 
     # The widths of the variable fields are calculated from the total width of all fields, minus the sum of widths of the non-variable fields, divided by the number of variable fields.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes as parameters the field widths.
     # @see Wx::StatusBar#set_fields_count
     # @see  Wx::Frame#set_status_widths 
     # @param widths_field [Array<Integer>]  Contains an array of n integers, each of which is either an absolute status field width in pixels if positive or indicates a variable width field if negative. The special value NULL means that all fields should get the same width.

data/lib/wx/doc/gen/stc/styled_text_ctrl.rb

@@ -25,6 +25,8 @@ module Wx::STC
   # 
   class StyledTextCtrl < Control
   
+    include Wx::TextEntry
+  
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::STCNameStr)
     #   Ctor.
     #   @param parent [Wx::Window] 
@@ -3850,6 +3852,7 @@ module Wx::STC
     # Notice that insertion position is, in general, different from the index of the character the cursor position at in the string returned by {Wx::STC::StyledTextCtrl#get_value}. While this is always the case for the single line controls, multi-line controls can use two characters <code>"\\r\\n"</code> as line separator (this is notably the case under MSW) meaning that indices in the control and its string value are offset by 1 for every line.
     # Hence to correctly get the character at the current cursor position, taking into account that there can be none if the cursor is at the end of the string, you could do the following:
     # 
+    # ```
     #   wxString GetCurrentChar(wxTextCtrl *tc)
     #   {
     #       long pos = tc->GetInsertionPoint();
@@ -3858,6 +3861,7 @@ module Wx::STC
     #   
     #       return tc->GetRange(pos, pos + 1);
     #   }
+    # ```
     # @return [Integer]
     def get_insertion_point; end
     alias_method :insertion_point, :get_insertion_point
@@ -3882,8 +3886,6 @@ module Wx::STC
     
     # Gets the current selection span.
     # If the returned values are equal, there was no selection. Please note that the indices returned may be used with the other {Wx::TextCtrl} methods but don't necessarily represent the correct indices into the string returned by {Wx::STC::StyledTextCtrl#get_value} for multiline controls under Windows (at least,) you should use {Wx::STC::StyledTextCtrl#get_string_selection} to get the selected text.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (from, to).
     # @return [Array(Integer, Integer)]
     def get_selection; end
     alias_method :selection, :get_selection
@@ -3968,8 +3970,6 @@ module Wx::STC
     
     # Converts given position to a zero-based column, line number pair.
     # true on success, false on failure (most likely due to a too large position parameter).
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pos argument and returns a 2-element list (x, y).
     # @see Wx::STC::StyledTextCtrl#xy_to_position 
     # @param pos [Integer]  Position.
     # @return [Array(true,false,Array(Integer, Integer))]
@@ -3983,7 +3983,6 @@ module Wx::STC
     # Finds the row and column of the character at the specified point.
     # If the return code is not {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} the row and column of the character closest to this position are returned, otherwise the output parameters are not modified.
     # Please note that this function is currently only implemented in {Wx::Univ}, {Wx::MSW} and {Wx::GTK2} ports and always returns {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} in the other ports.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pt argument and returns a 3-element list (result, col, row).
     # @see Wx::STC::StyledTextCtrl#position_to_xy
     # @see  Wx::STC::StyledTextCtrl#xy_to_position 
     # @param pt [Array(Integer, Integer), Wx::Point]  The position of the point to check, in window device coordinates.

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

@@ -43,26 +43,19 @@ module Wx
   # 
   # Category:  Device Contexts
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGFileDC < DC
   
-    # Initializes a {Wx::SVGFileDC} with the given filename, width and height at dpi resolution, and an optional title.
-    # The title provides a readable name for the SVG document.
-    # @param filename [String] 
-    # @param width [Integer] 
-    # @param height [Integer] 
-    # @param dpi [Float] 
-    # @param title [String] 
-    # @return [SVGFileDC]
-    def initialize(filename, width=320, height=240, dpi=72, title=(())) end
-    
     # Draws a rectangle the size of the SVG using the {Wx::DC#set_background} brush.
     # @return [void]
     def clear; end
     
     # Replaces the default bitmap handler with handler.
     # By default, an object of {Wx::SVGBitmapFileHandler} class is used as bitmap handler. You may want to replace it with an object of predefined {Wx::SVGBitmapEmbedHandler} class to embed the bitmaps in the generated SVG instead of storing them in separate files like this: 
-    # 
+    # ```
     #   mySVGFileDC->SetBitmapHandler(new wxSVGBitmapEmbedHandler());
+    # ```
     # 
     # or derive your own bitmap handler class and use it if you need to customize the bitmap handling further.
     # @param handler [Wx::SVGBitmapHandler]  The new bitmap handler. If non-NULL, this object takes ownership of this handler and will delete it when it is not needed any more.
@@ -88,6 +81,8 @@ module Wx
   # 
   # Category:  Device Contexts
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapHandler < ::Object
   
     # Writes the bitmap representation as SVG to the given stream.
@@ -111,6 +106,8 @@ module Wx
   # @see Wx::SVGFileDC#set_bitmap_handler.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapFileHandler < SVGBitmapHandler
   
     # Create a {Wx::SVGBitmapFileHandler} and specify the location where the file will be saved.
@@ -136,6 +133,8 @@ module Wx
   # @see Wx::SVGFileDC#set_bitmap_handler.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class SVGBitmapEmbedHandler < SVGBitmapHandler
   
     # Writes the bitmap representation as SVG to the given stream.