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

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

@@ -12,9 +12,13 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SplitterEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_splitter_sash_pos_changing}(id, meth = nil, &block): The sash position is in the process of being changed. May be used to modify the position of the tracking bar to properly reflect the position that would be set if the drag were to be completed at this point. Processes a {Wx::EVT_SPLITTER_SASH_POS_CHANGING} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_sash_pos_changed}(id, meth = nil, &block): The sash position was changed. May be used to modify the sash position before it is set, or to prevent the change from taking place. Processes a {Wx::EVT_SPLITTER_SASH_POS_CHANGED} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_unsplit}(id, meth = nil, &block): The splitter has been just unsplit. Processes a {Wx::EVT_SPLITTER_UNSPLIT} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_dclick}(id, meth = nil, &block): The sash was double clicked. The default behaviour is to unsplit the window when this happens (unless the minimum pane size has been set to a value greater than zero). Processes a {Wx::EVT_SPLITTER_DOUBLECLICKED} event. 
   # 
   # === 
@@ -28,9 +32,9 @@ module Wx
   
     # Constructor.
     # Used internally by wxWidgets only.
-    # @param eventType [Integer] 
+    # @param eventType [Wx::CommandLinkButton::EventType] 
     # @param splitter [Wx::SplitterWindow] 
-    # @return [SplitterEvent]
+    # @return [Wx::SplitterEvent]
     def initialize(eventType=Wx::EVT_NULL, splitter=nil) end
     
     # Returns the new sash position.

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

@@ -89,25 +89,38 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::SP_3D}: Draws a 3D effect border and sash. 
+  # 
   # - {Wx::SP_THIN_SASH}: Draws a thin sash. 
+  # 
   # - {Wx::SP_3DSASH}: Draws a 3D effect sash (part of default style). 
+  # 
   # - {Wx::SP_3DBORDER}: Synonym for {Wx::SP_BORDER}. 
+  # 
   # - {Wx::SP_BORDER}: Draws a standard border. 
+  # 
   # - {Wx::SP_NOBORDER}: No border (default). 
+  # 
   # - {Wx::SP_NO_XP_THEME}: Under Windows, switches off the attempt to draw the splitter using Windows theming, so the borders and sash will take on the pre-XP look. 
+  # 
   # - {Wx::SP_PERMIT_UNSPLIT}: Always allow to unsplit, even with the minimum pane size other than zero. 
+  # 
   # - {Wx::SP_LIVE_UPDATE}: Don't draw XOR line but resize the child windows immediately. 
   # 
   # === Events emitted by this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::SplitterEvent} events.
   # Event handler methods for events emitted by this class:
+  # 
   # - {Wx::EvtHandler#evt_splitter_sash_pos_changing}(id, meth = nil, &block): The sash position is in the process of being changed. May be used to modify the position of the tracking bar to properly reflect the position that would be set if the drag were to be completed at this point. Processes a {Wx::EVT_SPLITTER_SASH_POS_CHANGING} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_sash_pos_resize}(id, meth = nil, &block): The sash position is in the process of being updated. May be used to modify the position of the tracking bar to properly reflect the position that would be set if the update were to be completed. This can happen e.g. when the window is resized and the sash is moved according to the gravity setting. This event is sent when the window is resized and allows the application to select the desired new sash position. If it doesn't process the event, the position is determined by the gravity setting. Processes a {Wx::EVT_SPLITTER_SASH_POS_RESIZE} event and is only available in wxWidgets 3.1.6 or newer. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_sash_pos_changed}(id, meth = nil, &block): The sash position was changed. May be used to modify the sash position before it is set, or to prevent the change from taking place. Processes a {Wx::EVT_SPLITTER_SASH_POS_CHANGED} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_unsplit}(id, meth = nil, &block): The splitter has been just unsplit. Processes a {Wx::EVT_SPLITTER_UNSPLIT} event. 
+  # 
   # - {Wx::EvtHandler#evt_splitter_dclick}(id, meth = nil, &block): The sash was double clicked. The default behaviour is to unsplit the window when this happens (unless the minimum pane size has been set to a value greater than zero). Processes a {Wx::EVT_SPLITTER_DOUBLECLICKED} event. 
   # 
   # === 
@@ -121,7 +134,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [SplitterWindow]
+    #   @return [Wx::SplitterWindow]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=wxSP_3D, name=("splitterWindow"))
     #   Constructor for creating the window.
     #   After using this constructor, you must create either one or two subwindows with the splitter window as parent, and then call one of {Wx::SplitterWindow#initialize}, {Wx::SplitterWindow#split_vertically} and {Wx::SplitterWindow#split_horizontally} in order to set the pane(s). You can create two windows, with one hidden when not being shown; or you can create and delete the second pane on demand.
@@ -135,18 +148,18 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The window size.
     #   @param style [Integer]  The window style. See {Wx::SplitterWindow}.
     #   @param name [String]  The window name.
-    #   @return [SplitterWindow]
+    #   @return [Wx::SplitterWindow]
     def initialize(*args) end
     
     # Creation function, for two-step construction.
-    # See {Wx::SplitterWindow#splitter_window} for details.
+    # See {Wx::SplitterWindow#initialize} for details.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
     # @param point [Array(Integer, Integer), Wx::Point] 
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id=Wx::StandardID::ID_ANY, point=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=wxSP_3D, name=("splitter")) end
     
     # Returns the current minimum pane size (defaults to zero).
@@ -190,7 +203,7 @@ module Wx
     # @see Wx::SplitterWindow#set_split_mode
     # @see  Wx::SplitterWindow#split_vertically
     # @see  Wx::SplitterWindow#split_horizontally. 
-    # @return [SplitMode]
+    # @return [Wx::SplitMode]
     def get_split_mode; end
     alias_method :split_mode, :get_split_mode
     
@@ -217,12 +230,12 @@ module Wx
     # Returns true if the sash is invisible even when the window is split, false otherwise.
     # This is a shortcut for HasFlag({Wx::SP_NOSASH})
     # @see Wx::SplitterWindow#set_sash_invisible
-    # @return [true,false]
+    # @return [Boolean]
     def is_sash_invisible; end
     alias_method :sash_invisible?, :is_sash_invisible
     
     # Returns true if the window is split, false otherwise.
-    # @return [true,false]
+    # @return [Boolean]
     def is_split; end
     alias_method :split?, :is_split
     
@@ -239,7 +252,7 @@ module Wx
     # 
     # The default implementation of this function verifies that the sizes of both panes of the splitter are greater than minimum pane size.
     # @param newSashPosition [Integer]  The new sash position (always positive or zero)
-    # @return [true,false]
+    # @return [Boolean]
     def on_sash_position_change(newSashPosition) end
     
     # Application-overridable function called when the window is unsplit, either programmatically or using the {Wx::SplitterWindow} user interface.
@@ -254,7 +267,7 @@ module Wx
     # @see Wx::SplitterWindow#get_minimum_pane_size 
     # @param winOld [Wx::Window] 
     # @param winNew [Wx::Window] 
-    # @return [true,false]
+    # @return [Boolean]
     def replace_window(winOld, winNew) end
     
     # Sets the minimum pane size.
@@ -267,7 +280,10 @@ module Wx
     
     # Sets the sash gravity.
     # Gravity is real factor which controls position of sash while resizing {Wx::SplitterWindow}. Gravity tells {Wx::SplitterWindow} how much will left/top window grow while resizing. Example values:
-    # - 0.0: only the bottom/right window is automatically resized- 0.5: both windows grow by equal size- 1.0: only left/top window grows Gravity should be a real value between 0.0 and 1.0. Default value of sash gravity is 0.0. That value is compatible with previous (before gravity was introduced) behaviour of {Wx::SplitterWindow}.
+    # 
+    # - 0.0: only the bottom/right window is automatically resized
+    # - 0.5: both windows grow by equal size
+    # - 1.0: only left/top window grows Gravity should be a real value between 0.0 and 1.0. Default value of sash gravity is 0.0. That value is compatible with previous (before gravity was introduced) behaviour of {Wx::SplitterWindow}.
     # 
     # Notice that when sash gravity for a newly created splitter window, it is often necessary to explicitly set the splitter size using {Wx::SplitterWindow#set_size} to ensure that is big enough for its initial sash position. Otherwise, i.e. if the window is created with the default tiny size and only resized to its correct size later, the initial sash position will be affected by the gravity and typically result in sash being at the rightmost position for the gravity of 1. See the example code creating {Wx::SplitterWindow} in the splitter sample for more details.
     # @see Wx::SplitterWindow#get_sash_gravity 
@@ -280,7 +296,11 @@ module Wx
     # Does not currently check for an out-of-range value.
     # @see Wx::SplitterWindow#get_sash_position 
     # @param position [Integer]  The sash position in pixels.
-    # @param redraw [true,false]  If true, resizes the panes and redraws the sash and border.
+    #   
+    #    Note that a position of 0 will set the sash to the middle of the window.
+    #   
+    #    A negative value will "wrap around" the sash's position. For example, <code>-10</code> will place the sash at 10 units from right of the splitter window.
+    # @param redraw [Boolean]  If true, resizes the panes and redraws the sash and border.
     # @return [void]
     def set_sash_position(position, redraw=true) end
     alias_method :sash_position=, :set_sash_position
@@ -299,7 +319,7 @@ module Wx
     # When the sash is invisible, it doesn't appear on the screen at all and, in particular, doesn't allow the user to resize the windows.
     # Only sets the internal variable; does not update the display.
     # @see Wx::SplitterWindow#is_sash_invisible
-    # @param invisible [true,false]  If true, the sash is always invisible, else it is shown when the window is split.
+    # @param invisible [Boolean]  If true, the sash is always invisible, else it is shown when the window is split.
     # @return [void]
     def set_sash_invisible(invisible=true) end
     alias_method :sash_invisible=, :set_sash_invisible
@@ -316,7 +336,7 @@ module Wx
     # @param window1 [Wx::Window]  The top pane.
     # @param window2 [Wx::Window]  The bottom pane.
     # @param sashPosition [Integer]  The initial position of the sash. If this value is positive, it specifies the size of the upper pane. If it is negative, its absolute value gives the size of the lower pane. Finally, specify 0 (default) to choose the default position (half of the total window height).
-    # @return [true,false]
+    # @return [Boolean]
     def split_horizontally(window1, window2, sashPosition=0) end
     
     # Initializes the left and right panes of the splitter window.
@@ -331,7 +351,7 @@ module Wx
     # @param window1 [Wx::Window]  The left pane.
     # @param window2 [Wx::Window]  The right pane.
     # @param sashPosition [Integer]  The initial position of the sash. If this value is positive, it specifies the size of the left pane. If it is negative, it is absolute value gives the size of the right pane. Finally, specify 0 (default) to choose the default position (half of the total window width).
-    # @return [true,false]
+    # @return [Boolean]
     def split_vertically(window1, window2, sashPosition=0) end
     
     # Unsplits the window.
@@ -343,7 +363,7 @@ module Wx
     # @see  Wx::SplitterWindow#is_split
     # @see  Wx::SplitterWindow#on_unsplit 
     # @param toRemove [Wx::Window]  The pane to remove, or NULL to remove the right or bottom pane.
-    # @return [true,false]
+    # @return [Boolean]
     def unsplit(toRemove=nil) end
     
     # Causes any pending sizing of the sash and child panes to take place immediately.

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

@@ -12,9 +12,9 @@ module Wx
   # Notice that for the best results, the size of the control should be the same as the size of the image displayed in it, as happens by default if it's not resized explicitly. Otherwise, behaviour depends on the platform: under MSW, the bitmap is drawn centred inside the control, while elsewhere it is drawn at the origin of the control. You can use {Wx::StaticBitmap#set_scale_mode} to control how the image is scaled inside the control.
   # === 
   # 
-  # 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
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
+  #   </td><td> wxGTK Appearance
+  #   </td><td> wxOSX Appearance
   #   </td></tr></table></div>
   # @see Wx::Bitmap 
   # 
@@ -50,7 +50,7 @@ module Wx
     
     # @overload initialize()
     #   Default constructor.
-    #   @return [StaticBitmap]
+    #   @return [Wx::StaticBitmap]
     # @overload initialize(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBitmapNameStr)
     #   Constructor, creating and showing a static bitmap control.
     #   
@@ -62,11 +62,11 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  Window size.
     #   @param style [Integer]  Window style. See {Wx::StaticBitmap}.
     #   @param name [String]  Window name.
-    #   @return [StaticBitmap]
+    #   @return [Wx::StaticBitmap]
     def initialize(*args) end
     
     # Creation function, for two-step construction.
-    # For details see {Wx::StaticBitmap#static_bitmap}.
+    # For details see {Wx::StaticBitmap#initialize}.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
     # @param label [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
@@ -74,7 +74,7 @@ module Wx
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBitmapNameStr) end
     
     # Returns the bitmap currently used in the control.
@@ -108,7 +108,7 @@ module Wx
     # Sets the scale mode.
     # Currently only the generic implementation supports all scaling modes. You may use generic implementation {Wx::GenericStaticBitmap} declared in <wx/generic/statbmpg.h> in all ports.
     # @see Wx::StaticBitmap#get_scale_mode
-    # @param scaleMode [ScaleMode]  Controls how the bitmap is scaled inside the control.
+    # @param scaleMode [Wx::wxStaticBitmap::ScaleMode]  Controls how the bitmap is scaled inside the control.
     # @return [void]
     def set_scale_mode(scaleMode) end
     alias_method :scale_mode=, :set_scale_mode
@@ -116,7 +116,7 @@ module Wx
     # Returns the scale mode currently used in the control.
     # 
     # @see Wx::StaticBitmap#set_scale_mode
-    # @return [ScaleMode]
+    # @return [Wx::wxStaticBitmap::ScaleMode]
     def get_scale_mode; end
     alias_method :scale_mode, :get_scale_mode
     

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

@@ -9,24 +9,27 @@ 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);
-  #       wxStaticBox *box = new wxStaticBox(panel, wxID_ANY, "StaticBox");
-  #   
-  #       new wxStaticText(box, wxID_ANY, "This window is a child of the staticbox");
+  # ```ruby
+  #   class MyFrame < Wx::Frame
+  # 
+  #     def create_controls
+  #       panel = Wx::Panel.new(self)
+  #       box = Wx::StaticBox.new(panel, Wx::ID_ANY, 'StaticBox')
+  # 
+  #       Wx::StaticText.new(box, Wx::ID_ANY, "This window is a child of the staticbox")
   #       ...
-  #   }
+  #     end
+  # 
+  #   end
   # ```
   # 
   # 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.
   # === 
   # 
-  # 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
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
+  #   </td><td> wxGTK Appearance
+  #   </td><td> wxOSX Appearance
   #   </td></tr></table></div>
   # @see Wx::StaticText
   # @see  Wx::StaticBoxSizer 
@@ -36,7 +39,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [StaticBox]
+    #   @return [Wx::StaticBox]
     # @overload initialize(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBoxNameStr)
     #   Constructor, creating and showing a static box.
     #   
@@ -46,25 +49,28 @@ module Wx
     #   @param label [String]  Text to be displayed in the static box, the empty string for no label.
     #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
     #   @param size [Array(Integer, Integer), Wx::Size]  Checkbox size. If {Wx::DEFAULT_SIZE} is specified then a default size is chosen.
-    #   @param style [Integer]  Window style. There are no {Wx::StaticBox}-specific styles, but generic {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE_HORIZONTAL} and {Wx::Alignment::ALIGN_RIGHT} can be used here to change the position of the static box label when using {Wx::GTK} (these styles are ignored under the other platforms currently).
+    #   @param style [Integer]  Window style. There are no {Wx::StaticBox}-specific styles, but generic {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE_HORIZONTAL} and {Wx::Alignment::ALIGN_RIGHT} can be used here to change the position of the static box label when using wxGTK (these styles are ignored under the other platforms currently).
     #   @param name [String]  Window name.
-    #   @return [StaticBox]
+    #   @return [Wx::StaticBox]
     # @overload initialize(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBoxNameStr)
     #   Constructor for a static box using the given window as label.
     #   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);
-    #         wxCheckBox* checkbox = new wxCheckBox(panel, wxID_ANY, "Box checkbox");
-    #         wxStaticBox* box = new wxStaticBox(panel, wxID_ANY, checkbox);
+    #   ```ruby
+    #     class MyFrame < Wx::Frame
+    #       
+    #       def create_controls
+    #         panel = Wx::Panel.new(self)
+    #         checkbox = Wx::CheckBox.new(panel, Wx::ID_ANY, "Box checkbox")
+    #         box = Wx::StaticBox.new(panel, Wx::ID_ANY, checkbox)
     #         ...
-    #     }
+    #       end
+    #   
+    #     end
     #   ```
     #   
-    #   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.
+    #   Currently this constructor is only available in wxGTK and wxMSW, use {Wx::HAS_WINDOW_LABEL_IN_STATIC_BOX} to check whether it can be used at compile-time.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
     #   @param label [Wx::Window] 
@@ -72,12 +78,12 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [StaticBox]
+    #   @return [Wx::StaticBox]
     def initialize(*args) end
     
     # @overload create(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBoxNameStr)
     #   Creates the static box for two-step construction.
-    #   See {Wx::StaticBox#static_box} for further details.
+    #   See {Wx::StaticBox#initialize} for further details.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
     #   @param label [String] 
@@ -85,12 +91,12 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload create(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticBoxNameStr)
     #   Creates the static box with the window as a label.
     #   This method can only be called for an object created using its default constructor.
     #   See the constructor documentation for more details.
-    #   Currently this overload 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.
+    #   Currently this overload is only available in wxGTK and wxMSW, use {Wx::HAS_WINDOW_LABEL_IN_STATIC_BOX} to check whether it can be used at compile-time.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
     #   @param label [Wx::Window] 
@@ -98,26 +104,24 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [true,false]
+    #   @return [Boolean]
     def create(*args) end
     
     # 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());
-    #               });
+    # ```ruby
+    #   check = Wx::CheckBox.new(parent, Wx::ID_ANY, "Use the box")
+    #   box = Wx::StaticBox.new(parent, Wx::ID_ANY, check)
+    #   check.evt_checkbox { |event| box.enable(event.checked? }
     # ```
     #  does work as expected.
     # Please note that overriding {Wx::StaticBox#enable} to not actually disable this window itself has two possibly unexpected consequences:
     # 
-    # - The box retains its enabled status, i.e. {Wx::StaticBox#is_enabled} still returns true, after calling <code>Enable(false)</code>.- The box children are enabled or disabled when the box is, which can result in the loss of their original state. E.g. if a box child is initially disabled, then the box itself is disabled and, finally, the box is enabled again, this child will end up being enabled too (this wouldn't happen with any other parent window as its children would inherit the disabled state from the parent instead of being really disabled themselves when it is disabled). To avoid this problem, consider using {Wx::EVT_UPDATE_UI} to ensure that the child state is always correct or restoring it manually after re-enabling the box.
-    # @param enable [true,false] 
-    # @return [true,false]
+    # - The box retains its enabled status, i.e. {Wx::StaticBox#is_enabled} still returns true, after calling <code>Enable(false)</code>.
+    # - The box children are enabled or disabled when the box is, which can result in the loss of their original state. E.g. if a box child is initially disabled, then the box itself is disabled and, finally, the box is enabled again, this child will end up being enabled too (this wouldn't happen with any other parent window as its children would inherit the disabled state from the parent instead of being really disabled themselves when it is disabled). To avoid this problem, consider using {Wx::EVT_UPDATE_UI} to ensure that the child state is always correct or restoring it manually after re-enabling the box.
+    # @param enable [Boolean] 
+    # @return [Boolean]
     def enable(enable=true) end
     
   end # StaticBox

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

@@ -10,16 +10,19 @@ 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);
+  # ```ruby
+  #   class MyFrame < Wx::Frame
+  #   
+  #     def create_controls
+  #       panel = Wx::Panel.new(self)
   #       ...
-  #       wxStaticBoxSizer *sz = new wxStaticBoxSizer(wxVERTICAL, panel, "Box");
-  #       sz->Add(new wxStaticText(sz->GetStaticBox(), wxID_ANY,
-  #                                "This window is a child of the staticbox"));
+  #       sz = Wx::StaticBoxSizer.new(Wx::VERTICAL, panel, "Box")
+  #       sz.add(Wx::StaticText.new(sz.get_static_box, Wx::ID_ANY,
+  #                                 "This window is a child of the staticbox"))
   #       ...
-  #   }
+  #     end
+  # 
+  #   end
   # ```
   # 
   # === 
@@ -37,13 +40,13 @@ module Wx
     #   This constructor uses an already existing static box.
     #   @param box [Wx::StaticBox]  The static box to associate with the sizer (which will take its ownership).
     #   @param orient [Integer]  Can be either {Wx::Orientation::VERTICAL} or {Wx::Orientation::HORIZONTAL}.
-    #   @return [StaticBoxSizer]
+    #   @return [Wx::StaticBoxSizer]
     # @overload initialize(orient, parent, label=(''))
     #   This constructor creates a new static box with the given label and parent window.
     #   @param orient [Integer] 
     #   @param parent [Wx::Window] 
     #   @param label [String] 
-    #   @return [StaticBoxSizer]
+    #   @return [Wx::StaticBoxSizer]
     def initialize(*args) end
     
     # Returns the static box associated with the sizer.

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

@@ -7,12 +7,13 @@
 module Wx
 
   # A static line is just a line which may be used in a dialog to separate the groups of controls.
-  # The line may be only vertical or horizontal. Moreover, not all ports (notably not {Wx::GTK}) support specifying the transversal direction of the line (e.g. height for a horizontal line) so for maximal portability you should specify it as {Wx::DEFAULT_COORD}.
+  # The line may be only vertical or horizontal. Moreover, not all ports (notably not wxGTK) support specifying the transversal direction of the line (e.g. height for a horizontal line) so for maximal portability you should specify it as {Wx::DEFAULT_COORD}.
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::LI_HORIZONTAL}: Creates a horizontal line. 
+  # 
   # - {Wx::LI_VERTICAL}: Creates a vertical line. 
   # 
   # === 
@@ -25,7 +26,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [StaticLine]
+    #   @return [Wx::StaticLine]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::LI_HORIZONTAL, name=Wx::StaticLineNameStr)
     #   Constructor, creating and showing a static line.
     #   
@@ -36,22 +37,22 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  Size. Note that either the height or the width (depending on whether the line if horizontal or vertical) is ignored.
     #   @param style [Integer]  Window style (either {Wx::LI_HORIZONTAL} or {Wx::LI_VERTICAL}).
     #   @param name [String]  Window name.
-    #   @return [StaticLine]
+    #   @return [Wx::StaticLine]
     def initialize(*args) end
     
     # Creates the static line for two-step construction.
-    # See {Wx::StaticLine#static_line} for further details.
+    # See {Wx::StaticLine#initialize} for further details.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
     # @param pos [Array(Integer, Integer), Wx::Point] 
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::LI_HORIZONTAL, name=Wx::StaticLineNameStr) end
     
     # Returns true if the line is vertical, false if horizontal.
-    # @return [true,false]
+    # @return [Boolean]
     def is_vertical; end
     alias_method :vertical?, :is_vertical
     

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

@@ -23,20 +23,26 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::Alignment::ALIGN_LEFT}: Align the text to the left. 
+  # 
   # - {Wx::Alignment::ALIGN_RIGHT}: Align the text to the right. 
+  # 
   # - {Wx::Alignment::ALIGN_CENTRE_HORIZONTAL}: Center the text (horizontally). 
+  # 
   # - {Wx::ST_NO_AUTORESIZE}: By default, the control will adjust its size to exactly fit to the size of the text when {Wx::StaticText#set_label} is called. If this style flag is given, the control will not change its size (this style is especially useful with controls which also have the {Wx::Alignment::ALIGN_RIGHT} or the {Wx::Alignment::ALIGN_CENTRE_HORIZONTAL} style because otherwise they won't make sense any longer after a call to {Wx::StaticText#set_label}). 
+  # 
   # - {Wx::ST_ELLIPSIZE_START}: If the labeltext width exceeds the control width, replace the beginning of the label with an ellipsis; uses {Wx::Control.ellipsize}. 
+  # 
   # - {Wx::ST_ELLIPSIZE_MIDDLE}: If the label text width exceeds the control width, replace the middle of the label with an ellipsis; uses {Wx::Control.ellipsize}. 
+  # 
   # - {Wx::ST_ELLIPSIZE_END}: If the label text width exceeds the control width, replace the end of the label with an ellipsis; uses {Wx::Control.ellipsize}. 
   # 
   # === 
   # 
-  # 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
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
+  #   </td><td> wxGTK Appearance
+  #   </td><td> wxOSX Appearance
   #   </td></tr></table></div>
   # @see Wx::StaticBitmap
   # @see  Wx::StaticBox 
@@ -46,7 +52,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [StaticText]
+    #   @return [Wx::StaticText]
     # @overload initialize(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticTextNameStr)
     #   Constructor, creating and showing a text control.
     #   
@@ -58,11 +64,11 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  Window size.
     #   @param style [Integer]  Window style. See {Wx::StaticText}.
     #   @param name [String]  Window name.
-    #   @return [StaticText]
+    #   @return [Wx::StaticText]
     def initialize(*args) end
     
     # Creation function, for two-step construction.
-    # For details see {Wx::StaticText#static_text}.
+    # For details see {Wx::StaticText#initialize}.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
     # @param label [String] 
@@ -70,11 +76,11 @@ module Wx
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id, label, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::StaticTextNameStr) end
     
     # Returns true if the window styles for this control contains one of the {Wx::ST_ELLIPSIZE_START}, {Wx::ST_ELLIPSIZE_MIDDLE} or {Wx::ST_ELLIPSIZE_END} styles.
-    # @return [true,false]
+    # @return [Boolean]
     def is_ellipsized; end
     alias_method :ellipsized?, :is_ellipsized