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

data/lib/wx/doc/gen/aui/aui_tool_bar_event.rb

@@ -141,12 +141,12 @@ module Wx::AUI
   class AuiToolBarEvent < NotifyEvent
   
     # @overload initialize(commandType=Wx::EVT_NULL, winId=0)
-    #   @param commandType [Integer] 
+    #   @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     #   @param winId [Integer] 
-    #   @return [AuiToolBarEvent]
+    #   @return [Wx::AUI::AuiToolBarEvent]
     # @overload initialize(c)
-    #   @param c [Wx::AuiToolBarEvent] 
-    #   @return [AuiToolBarEvent]
+    #   @param c [Wx::AUI::AuiToolBarEvent] 
+    #   @return [Wx::AUI::AuiToolBarEvent]
     def initialize(*args) end
     
     # Returns whether the drop down menu has been clicked.

data/lib/wx/doc/gen/aui/aui_tool_bar_item.rb

@@ -17,15 +17,15 @@ module Wx::AUI
   
     # @overload initialize()
     #   Default Constructor.
-    #   @return [AuiToolBarItem]
+    #   @return [Wx::AUI::AuiToolBarItem]
     # @overload initialize(c)
     #   Assigns the properties of the {Wx::AUI::AuiToolBarItem} "c" to this.
-    #   @param c [Wx::AuiToolBarItem] 
-    #   @return [AuiToolBarItem]
+    #   @param c [Wx::AUI::AuiToolBarItem] 
+    #   @return [Wx::AUI::AuiToolBarItem]
     def initialize(*args) end
     
     # Assigns the properties of the {Wx::AUI::AuiToolBarItem} "c" to this.
-    # @param c [Wx::AuiToolBarItem] 
+    # @param c [Wx::AUI::AuiToolBarItem] 
     # @return [void]
     def assign(c) end
     

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

@@ -16,7 +16,11 @@ module Wx
   # This class encapsulates the concept of a platform-dependent bitmap, either monochrome or colour or colour with alpha channel support.
   # If you need direct access the bitmap data instead going through drawing to it using {Wx::MemoryDC} you need to use the {Wx::PixelData} class (either {Wx::NativePixelData} for RGB bitmaps or {Wx::AlphaPixelData} for bitmaps with an additionally alpha channel).
   # Note that many {Wx::Bitmap} functions take a type parameter, which is a value of the {Wx::BitmapType} enumeration. The validity of those values depends however on the platform where your program is running and from the wxWidgets configuration. If all possible wxWidgets settings are used:
-  # - {Wx::MSW} supports BMP and ICO files, BMP and ICO resources;- {Wx::GTK} supports any file supported by gdk-pixbuf;- {Wx::Mac} supports PICT resources;- {Wx::X11} supports XPM files, XPM data, XBM data;
+  # 
+  # - wxMSW supports BMP and ICO files, BMP and ICO resources;
+  # - wxGTK supports any file supported by gdk-pixbuf;
+  # - {Wx::Mac} supports PICT resources;
+  # - wxX11 supports XPM files, XPM data, XBM data;
   # 
   # In addition, {Wx::Bitmap} can load and save all formats that {Wx::Image} can; see {Wx::Image} for more info. Of course, you must have loaded the {Wx::Image} handlers (see {init_all_image_handlers} and {Wx::Image.add_handler}). Note that all available {Wx::BitmapHandlers} for a given wxWidgets port are automatically loaded at startup so you won't need to use {Wx::Bitmap.add_handler}.
   # More on the difference between {Wx::Image} and {Wx::Bitmap}: {Wx::Image} is just a buffer of RGB bytes with an optional buffer for the alpha bytes. It is all generic, platform independent and image file format independent code. It includes generic code for scaling, resizing, clipping, and other manipulations of the image data. OTOH, {Wx::Bitmap} is intended to be a wrapper of whatever is the native image format that is quickest/easiest to draw to a DC or to be the target of the drawing operations performed on a {Wx::MemoryDC}. By splitting the responsibilities between {Wx::Image}/{Wx::Bitmap} like this then it's easier to use generic code shared by all platforms and image types for generic operations and platform specific code where performance or compatibility is needed.
@@ -41,7 +45,7 @@ module Wx
     # @overload initialize()
     #   Default constructor.
     #   Constructs a bitmap object with no data; an assignment or another member function such as {Wx::Bitmap#create} or {Wx::Bitmap#load_file} must be called subsequently.
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(bitmap)
     #   Copy constructor, uses reference counting.
     #   To make a real copy, you can use:
@@ -50,7 +54,7 @@ module Wx
     #                     Wx::Rect.new(0, 0, oldBitmap.width, oldBitmap.height))
     #   ```
     #   @param bitmap [Wx::Bitmap] 
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(width, height, depth=Wx::BITMAP_SCREEN_DEPTH)
     #   Creates a new bitmap.
     #   A depth of {Wx::BITMAP_SCREEN_DEPTH} indicates the depth of the current screen or visual.
@@ -59,25 +63,25 @@ module Wx
     #   @param width [Integer]  The width of the bitmap in pixels, must be strictly positive.
     #   @param height [Integer]  The height of the bitmap in pixels, must be strictly positive.
     #   @param depth [Integer]  The number of bits used to represent each bitmap pixel.
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(sz, depth=Wx::BITMAP_SCREEN_DEPTH)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
     #   @param sz [Array(Integer, Integer), Wx::Size] 
     #   @param depth [Integer] 
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(width, height, dc)
     #   Create a bitmap compatible with the given DC, inheriting its magnification factor.
     #   @param width [Integer]  The width of the bitmap in pixels, must be strictly positive.
     #   @param height [Integer]  The height of the bitmap in pixels, must be strictly positive.
     #   @param dc [Wx::DC]  DC from which the scaling factor is inherited
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(name, type=Wx::BITMAP_DEFAULT_TYPE)
     #   Loads a bitmap from a file or resource.
     #   
     #   @see Wx::Bitmap#load_file 
     #   @param name [String]  This can refer to a resource name or a filename under MS Windows and X. Its meaning is determined by the type parameter.
     #   @param type [BitmapType]  May be one of the {Wx::BitmapType} values and indicates which type of bitmap should be loaded. See the note in the class detailed description. Note that the {Wx::BITMAP_DEFAULT_TYPE} constant has different value under different wxWidgets ports. See the bitmap.h header for the value it takes for a specific port.
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(img, depth=Wx::BITMAP_SCREEN_DEPTH)
     #   Creates this bitmap object from the given image.
     #   This has to be done to actually display an image as you cannot draw an image directly on a window.
@@ -85,18 +89,18 @@ module Wx
     #   On Windows, if there is a palette present (set with SetPalette), it will be used when creating the {Wx::Bitmap} (most useful in 8-bit display mode). On other platforms, the palette is currently ignored.
     #   @param img [Wx::Image]  Platform-independent {Wx::Image} object.
     #   @param depth [Integer]  Specifies the depth of the bitmap. If this is omitted, the display depth of the screen is used.
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(img, dc)
     #   Creates a bitmap compatible with the given DC from the given image.
     #   This constructor initializes the bitmap with the data of the given image, which must be valid, but inherits the scaling factor from the given device context instead of simply using the default factor of 1.
     #   @param img [Wx::Image]  Platform-independent {Wx::Image} object.
     #   @param dc [Wx::DC]  DC from which the scaling factor is inherited
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     # @overload initialize(cursor)
     #   Creates bitmap corresponding to the given cursor.
     #   This can be useful to display a cursor as it cannot be drawn directly on a window.
     #   @param cursor [Wx::Cursor]  A valid {Wx::Cursor}.
-    #   @return [Bitmap]
+    #   @return [Wx::Bitmap]
     def initialize(*args) end
     
     # Returns disabled (dimmed) version of the bitmap.
@@ -143,7 +147,9 @@ module Wx
     #   The physical size of the bitmap is obtained by multiplying the given size by scale and rounding it to the closest integer.
     #   After using this function the following postconditions are true:
     #   
-    #   - {Wx::Bitmap#get_size} returns size multiplied by scale - {Wx::Bitmap#get_dip_size} returns size - {Wx::Bitmap#get_scale_factor} returns scale 
+    #   - {Wx::Bitmap#get_size} returns size multiplied by scale 
+    #   - {Wx::Bitmap#get_dip_size} returns size 
+    #   - {Wx::Bitmap#get_scale_factor} returns scale 
     #   
     #   true if the creation was successful.
     #   @param size [Array(Integer, Integer), Wx::Size]  The size of the bitmap in DPI-independent pixels. Both width and height must be strictly positive.
@@ -201,7 +207,7 @@ module Wx
     alias_method :logical_height, :get_logical_height
     
     # Returns the size of the bitmap in logical pixels.
-    # For the platforms using DPI-independent pixels, i.e. those where {Wx::HAS_DPI_INDEPENDENT_PIXELS} is defined, such as {Wx::OSX} or {Wx::GTK} 3, this function returns the physical size of the bitmap, as returned by {Wx::Bitmap#get_size}, divided by its scale factor, as returned by {Wx::Bitmap#get_scale_factor}, while for the other platforms, it simply returns the same thing as {Wx::Bitmap#get_size}.
+    # For the platforms using DPI-independent pixels, i.e. those where {Wx::HAS_DPI_INDEPENDENT_PIXELS} is defined, such as wxOSX or wxGTK 3, this function returns the physical size of the bitmap, as returned by {Wx::Bitmap#get_size}, divided by its scale factor, as returned by {Wx::Bitmap#get_scale_factor}, while for the other platforms, it simply returns the same thing as {Wx::Bitmap#get_size}.
     # This ensures that the result of this function is always expressed in the pixel coordinates appropriate for the current platform, i.e. its return value is always in logical pixels, used for window and {Wx::DC} coordinates, whether these pixels are the same as physical pixels, which are returned by {Wx::Bitmap#get_size}, or not.
     # @see Wx::Bitmap#get_logical_width
     # @see  Wx::Bitmap#get_logical_height
@@ -235,7 +241,7 @@ module Wx
     
     # Returns the scale factor of this bitmap.
     # Scale factor is 1 by default, but can be greater to indicate that the size of bitmap in logical, DPI-independent pixels is smaller than its actual size in physical pixels. Bitmaps with scale factor greater than 1 must be used in high DPI to appear sharp on the screen.
-    # Note that the scale factor is only used in the ports where logical pixels are not the same as physical ones, such as {Wx::OSX} or {Wx::GTK3}, and this function always returns 1 under the other platforms.
+    # Note that the scale factor is only used in the ports where logical pixels are not the same as physical ones, such as wxOSX or wxGTK3, and this function always returns 1 under the other platforms.
     # @see Wx::Bitmap#set_scale_factor
     # @see  Wx::Bitmap#get_logical_width
     # @see  Wx::Bitmap#get_logical_height
@@ -318,7 +324,7 @@ module Wx
     def save_file(name, type, palette=nil) end
     
     # Sets the bitmap scale factor.
-    # This doesn't change the bitmap actual size or its contents, but changes its scale factor, so that it appears in a smaller size when it is drawn on screen: e.g. setting scale to 2 means that the bitmap will be twice smaller (in each direction) when drawn on screen in the ports in which logical and physical pixels differ (i.e. {Wx::OSX} and {Wx::GTK3}, but not {Wx::MSW}).
+    # This doesn't change the bitmap actual size or its contents, but changes its scale factor, so that it appears in a smaller size when it is drawn on screen: e.g. setting scale to 2 means that the bitmap will be twice smaller (in each direction) when drawn on screen in the ports in which logical and physical pixels differ (i.e. wxOSX and wxGTK3, but not wxMSW).
     # When creating a new bitmap, {Wx::Bitmap#create_with_dip_size} can be used to specify the correct scale factor from the beginning.
     # @param scale [Float] 
     # @return [void]
@@ -328,7 +334,7 @@ module Wx
     # Sets the mask for this bitmap.
     # The bitmap object owns the mask once this has been called.
     # 
-    # A mask can be set also for bitmap with an alpha channel but doing so under {Wx::MSW} is not recommended because performance of drawing such bitmap is not very good.
+    # A mask can be set also for bitmap with an alpha channel but doing so under wxMSW is not recommended because performance of drawing such bitmap is not very good.
     # @see Wx::Bitmap#get_mask
     # @see  Wx::Mask 
     # @param mask [Wx::Mask] 
@@ -386,26 +392,26 @@ module Wx
     # @overload initialize()
     #   Default constructor constructs an empty bundle.
     #   An empty bundle can't be used for anything, but can be assigned something else later.
-    #   @return [BitmapBundle]
+    #   @return [Wx::BitmapBundle]
     # @overload initialize(bitmap)
     #   Conversion constructor from a single bitmap.
     #   This constructor does the same thing as {Wx::BitmapBundle.from_bitmap} and only exists for interoperability with the existing code using {Wx::Bitmap}.
     #   @param bitmap [Wx::Bitmap] 
-    #   @return [BitmapBundle]
+    #   @return [Wx::BitmapBundle]
     # @overload initialize(icon)
     #   Conversion constructor from a single icon.
     #   This constructor does the same thing as {Wx::BitmapBundle.from_bitmap} and only exists for interoperability with the existing code using {Wx::Icon}.
     #   @param icon [Wx::Icon] 
-    #   @return [BitmapBundle]
+    #   @return [Wx::BitmapBundle]
     # @overload initialize(image)
     #   Conversion constructor from a single image.
     #   Similarly to the constructor from {Wx::Bitmap}, this constructor only exists for interoperability with the existing code using {Wx::Image} and can be replaced with more readable {Wx::BitmapBundle.from_image} in the new code.
     #   @param image [Wx::Image] 
-    #   @return [BitmapBundle]
+    #   @return [Wx::BitmapBundle]
     # @overload initialize(other)
     #   Copy constructor creates a copy of another bundle.
     #   @param other [Wx::BitmapBundle] 
-    #   @return [BitmapBundle]
+    #   @return [Wx::BitmapBundle]
     def initialize(*args) end
     
     # Clear the existing bundle contents.
@@ -577,7 +583,7 @@ module Wx
   
   # This class encapsulates a monochrome mask bitmap, where the masked area is black and the unmasked area is white.
   # When associated with a bitmap and drawn in a device context, the unmasked area of the bitmap will be drawn, and the masked area will not be drawn.
-  # A mask can be associated also with a bitmap with an alpha channel but drawing such bitmaps under {Wx::MSW} may be slow so using them should be avoided if drawing performance is an important factor.
+  # A mask can be associated also with a bitmap with an alpha channel but drawing such bitmaps under wxMSW may be slow so using them should be avoided if drawing performance is an important factor.
   # 
   # === 
   # 
@@ -591,22 +597,22 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [Mask]
+    #   @return [Wx::Mask]
     # @overload initialize(bitmap, index)
     #   Constructs a mask from a bitmap and a palette index that indicates the background.
     #   Not implemented for GTK.
     #   @param bitmap [Wx::Bitmap]  A valid bitmap.
     #   @param index [Integer]  Index into a palette, specifying the transparency colour.
-    #   @return [Mask]
+    #   @return [Wx::Mask]
     # @overload initialize(bitmap)
     #   Constructs a mask from a monochrome bitmap.
     #   @param bitmap [Wx::Bitmap] 
-    #   @return [Mask]
+    #   @return [Wx::Mask]
     # @overload initialize(bitmap, colour)
     #   Constructs a mask from a bitmap and a colour that indicates the background.
     #   @param bitmap [Wx::Bitmap] 
     #   @param colour [Wx::Colour,String,Symbol] 
-    #   @return [Mask]
+    #   @return [Wx::Mask]
     def initialize(*args) end
     
     # @overload create(bitmap, index)
@@ -627,7 +633,7 @@ module Wx
     def create(*args) end
     
     # Returns the mask as a monochrome bitmap.
-    # Currently this method is implemented in {Wx::MSW}, {Wx::GTK} and {Wx::OSX}.
+    # Currently this method is implemented in wxMSW, wxGTK and wxOSX.
     # @return [Wx::Bitmap]
     def get_bitmap; end
     alias_method :bitmap, :get_bitmap

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

@@ -11,10 +11,13 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::BU_LEFT}: Left-justifies the bitmap label. 
+  # 
   # - {Wx::BU_TOP}: Aligns the bitmap label to the top of the button. 
+  # 
   # - {Wx::BU_RIGHT}: Right-justifies the bitmap label. 
+  # 
   # - {Wx::BU_BOTTOM}: Aligns the bitmap label to the bottom of the button. 
   # 
   # Note that the {Wx::BU_EXACTFIT} style supported by {Wx::Button} is not used by this class as bitmap buttons don't have any minimal standard size by default.
@@ -22,13 +25,14 @@ module Wx
   # 
   # 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::EvtHandler#evt_button}(id, meth = nil, &block): Process a {Wx::EVT_BUTTON} event, when the 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
+  # 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::Button 
   # 
@@ -37,7 +41,7 @@ module Wx
   
     # @overload initialize()
     #   Default ctor.
-    #   @return [BitmapButton]
+    #   @return [Wx::BitmapButton]
     # @overload initialize(parent, id, bitmap, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ButtonNameStr)
     #   Constructor, creating and showing a button.
     #   The bitmap parameter is normally the only bitmap you need to provide, and wxWidgets will draw the button correctly in its different states. If you want more control, call any of the functions {Wx::BitmapButton#set_bitmap_pressed}, {Wx::BitmapButton#set_bitmap_focus}, {Wx::BitmapButton#set_bitmap_disabled}.
@@ -51,7 +55,7 @@ module Wx
     #   @param style [Integer]  Window style. See {Wx::BitmapButton}.
     #   @param validator [Wx::Validator]  Window validator.
     #   @param name [String]  Window name.
-    #   @return [BitmapButton]
+    #   @return [Wx::BitmapButton]
     def initialize(*args) end
     
     # Button creation function for two-step creation.

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

@@ -13,9 +13,11 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::CB_READONLY}: Creates a combobox without a text editor. On some platforms the control may appear very different when this style is used. 
+  # 
   # - {Wx::CB_SORT}: Sorts the entries in the list alphabetically. 
+  # 
   # - {Wx::TE_PROCESS_ENTER}: The control will generate the event {Wx::EVT_TEXT_ENTER} (otherwise pressing Enter key is either processed internally by the control or used for navigation between dialog controls). Windows only. 
   # 
   # Todocreate {Wx::CB_PROCESS_ENTER} rather than reusing {Wx::TE_PROCESS_ENTER}!
@@ -24,15 +26,18 @@ module Wx
   # 
   # 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::EvtHandler#evt_combobox}(id, meth = nil, &block): Process a {Wx::EVT_COMBOBOX} event, when an item on the list is selected. 
+  # 
   # - {Wx::EvtHandler#evt_text}(id, meth = nil, &block): Process a {Wx::EVT_TEXT} event, when the combobox text changes. 
+  # 
   # - {Wx::EvtHandler#evt_text_enter}(id, meth = nil, &block): Process a {Wx::EVT_TEXT_ENTER} event, when RETURN is pressed in the combobox. 
   # 
   # === 
   # 
-  # 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::ComboBox
   # @see  Wx::Choice
@@ -44,7 +49,7 @@ module Wx
   
     # @overload initialize()
     #   Default ctor.
-    #   @return [BitmapComboBox]
+    #   @return [Wx::BitmapComboBox]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
     #   Constructor, creating and showing a combobox.
     #   
@@ -59,7 +64,7 @@ module Wx
     #   @param style [Integer]  The window style, see {Wx::CB_}* flags.
     #   @param validator [Wx::Validator]  Validator which can be used for additional data checks.
     #   @param name [String]  Control name.
-    #   @return [BitmapComboBox]
+    #   @return [Wx::BitmapComboBox]
     # @overload initialize(parent, id, value, pos, size, choices, style, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
     #   Constructor, creating and showing a combobox.
     #   
@@ -74,7 +79,7 @@ module Wx
     #   @param style [Integer]  The window style, see {Wx::CB_}* flags.
     #   @param validator [Wx::Validator]  Validator which can be used for additional data checks.
     #   @param name [String]  Control name.
-    #   @return [BitmapComboBox]
+    #   @return [Wx::BitmapComboBox]
     def initialize(*args) end
     
     # @overload append(item, bitmap=Wx::NULL_BITMAP)

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

@@ -48,9 +48,13 @@ module Wx
   # wxWidgets has five variants of this control:
   # 
   # - {Wx::Choicebook}: controlled by a {Wx::Choice} 
+  # 
   # - {Wx::Listbook}: controlled by a {Wx::ListCtrl} 
+  # 
   # - {Wx::Notebook}: uses a row of tabs 
+  # 
   # - {Wx::Treebook}: controlled by a {Wx::TreeCtrl} 
+  # 
   # - {Wx::Toolbook}: controlled by a {Wx::ToolBar}
   # 
   # This abstract class is the parent of all these book controls, and provides their basic interface. This is a pure virtual class so you cannot allocate it directly.
@@ -196,7 +200,7 @@ module Wx
     
     # @overload initialize()
     #   Default ctor.
-    #   @return [BookCtrlBase]
+    #   @return [Wx::BookCtrlBase]
     # @overload initialize(parent, winid, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=(''))
     #   Constructs the book control with the given parameters.
     #   See {Wx::BookCtrlBase#create} for two-step construction.
@@ -206,7 +210,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [BookCtrlBase]
+    #   @return [Wx::BookCtrlBase]
     def initialize(*args) end
     
     # Constructs the book control with the given parameters.
@@ -220,7 +224,7 @@ module Wx
     def create(parent, winid, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=('')) end
     
     # Sets the width and height of the pages.
-    # This method is currently not implemented for {Wx::GTK}.
+    # This method is currently not implemented for wxGTK.
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @return [void]
     def set_page_size(size) end

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

@@ -24,11 +24,11 @@ module Wx
   class BookCtrlEvent < NotifyEvent
   
     # Constructor (used internally by wxWidgets only).
-    # @param eventType [Integer] 
+    # @param eventType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param id [Integer] 
     # @param sel [Integer] 
     # @param oldSel [Integer] 
-    # @return [BookCtrlEvent]
+    # @return [Wx::BookCtrlEvent]
     def initialize(eventType=Wx::EVT_NULL, id=0, sel=Wx::NOT_FOUND, oldSel=Wx::NOT_FOUND) end
     
     # Returns the page that was selected before the change, {Wx::NOT_FOUND} if none was selected.

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

@@ -20,7 +20,7 @@ module Wx
     # Constructor for a {Wx::BoxSizer}.
     # orient may be either of {Wx::Orientation::VERTICAL} or {Wx::Orientation::HORIZONTAL} for creating either a column sizer or a row sizer.
     # @param orient [Integer] 
-    # @return [BoxSizer]
+    # @return [Wx::BoxSizer]
     def initialize(orient) end
     
     # Adds non-stretchable space to the main orientation of the sizer only.

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

@@ -84,17 +84,29 @@ module Wx
   # 
   # Category:  Graphics Device Interface (GDI)
   # Predefined objects/pointers: 
+  # 
   # - {Wx::NULL_BRUSH} 
+  # 
   # - {Wx::BLACK_BRUSH} 
+  # 
   # - {Wx::BLUE_BRUSH} 
+  # 
   # - {Wx::CYAN_BRUSH} 
+  # 
   # - {Wx::GREEN_BRUSH} 
+  # 
   # - {Wx::YELLOW_BRUSH} 
+  # 
   # - {Wx::GREY_BRUSH} 
+  # 
   # - {Wx::LIGHT_GREY_BRUSH} 
+  # 
   # - {Wx::MEDIUM_GREY_BRUSH} 
+  # 
   # - {Wx::RED_BRUSH} 
+  # 
   # - {Wx::TRANSPARENT_BRUSH} 
+  # 
   # - {Wx::WHITE_BRUSH}
   # @see Wx::BrushList
   # @see  Wx::DC
@@ -125,21 +137,21 @@ module Wx
     # @overload initialize()
     #   Default constructor.
     #   The brush will be uninitialised, and {Wx::Brush}:{Wx::Brush#is_ok} will return false.
-    #   @return [Brush]
+    #   @return [Wx::Brush]
     # @overload initialize(colour, style=Wx::BrushStyle::BRUSHSTYLE_SOLID)
     #   Constructs a brush from a colour object and style.
     #   @param colour [Wx::Colour,String,Symbol]  Colour object.
     #   @param style [BrushStyle]  One of the {Wx::BrushStyle} enumeration values.
-    #   @return [Brush]
+    #   @return [Wx::Brush]
     # @overload initialize(stippleBitmap)
     #   Constructs a stippled brush using a bitmap.
     #   The brush style will be set to {Wx::BrushStyle::BRUSHSTYLE_STIPPLE}.
     #   @param stippleBitmap [Wx::Bitmap] 
-    #   @return [Brush]
+    #   @return [Wx::Brush]
     # @overload initialize(brush)
     #   Copy constructor, uses reference counting.
     #   @param brush [Wx::Brush] 
-    #   @return [Brush]
+    #   @return [Wx::Brush]
     def initialize(*args) end
     
     # Returns a reference to the brush colour.

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

@@ -93,7 +93,7 @@ module Wx
   
     # Default constructor initializes all attributes to default values.
     # Call the other methods to really fill in the object.
-    # @return [BusyInfoFlags]
+    # @return [Wx::BusyInfoFlags]
     def initialize; end
     
     # Sets the parent for {Wx::BusyInfo}.

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

@@ -9,12 +9,17 @@ module Wx
   # A button is a control that contains a text string, and is one of the most common elements of a GUI.
   # It may be placed on a dialog box or on a {Wx::Panel} panel, or indeed on almost any other window.
   # By default, i.e. if none of the alignment styles are specified, the label is centered both horizontally and vertically. If the button has both a label and a bitmap, the alignment styles above specify the location of the rectangle combining both the label and the bitmap and the bitmap position set with {Wx::Button#set_bitmap_position} defines the relative position of the bitmap with respect to the label (however currently non-default alignment combinations are not implemented on all platforms).
-  # Since version 2.9.1 {Wx::Button} supports showing both text and an image (currently only when using {Wx::MSW}, {Wx::GTK} or {Wx::OSX}/Cocoa ports), see {Wx::Button#set_bitmap} and {Wx::Button#set_bitmap_label}, {Wx::Button#set_bitmap_disabled} &c methods. In the previous wxWidgets versions this functionality was only available in (the now trivial) {Wx::BitmapButton} class which was only capable of showing an image without text.
+  # Since version 2.9.1 {Wx::Button} supports showing both text and an image (currently only when using wxMSW, wxGTK or wxOSX/Cocoa ports), see {Wx::Button#set_bitmap} and {Wx::Button#set_bitmap_label}, {Wx::Button#set_bitmap_disabled} &c methods. In the previous wxWidgets versions this functionality was only available in (the now trivial) {Wx::BitmapButton} class which was only capable of showing an image without text.
   # A button may have either a single image for all states or different images for the following states (different images are not currently supported under macOS where the normal image is used for all states): 
+  # 
   # - <b>normal:</b> the default state 
+  # 
   # - <b>disabled:</b> bitmap shown when the button is disabled. 
+  # 
   # - <b>pressed:</b> bitmap shown when the button is pushed (e.g. while the user keeps the mouse button pressed on it) 
+  # 
   # - <b>focus:</b> bitmap shown when the button has keyboard focus (but is not pressed as in this case the button is in the pressed state) 
+  # 
   # - <b>current:</b> bitmap shown when the mouse is over the button (but it is not pressed although it may have focus). Notice that if current bitmap is not specified but the current platform UI uses hover images for the buttons (such as Windows or GTK+), then the focus bitmap is used for hover state as well. This makes it possible to set focus bitmap only to get reasonably good behaviour on all platforms.
   # 
   # All of the bitmaps must be of the same size and the normal bitmap must be set first (to a valid bitmap), before setting any other ones. Also, if the size of the bitmaps is changed later, you need to change the size of the normal bitmap before setting any other bitmaps with the new size (and you do need to reset all of them as their original values can be lost when the normal bitmap size changes).
@@ -23,26 +28,33 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::BU_LEFT}: Left-justifies the label. Windows and GTK+ only. 
+  # 
   # - {Wx::BU_TOP}: Aligns the label to the top of the button. Windows and GTK+ only. 
+  # 
   # - {Wx::BU_RIGHT}: Right-justifies the bitmap label. Windows and GTK+ only. 
+  # 
   # - {Wx::BU_BOTTOM}: Aligns the label to the bottom of the button. Windows and GTK+ only. 
+  # 
   # - {Wx::BU_EXACTFIT}: By default, all buttons are made of at least the standard button size, even if their contents is small enough to fit into a smaller size. This is done for consistency as most platforms use buttons of the same size in the native dialogs, but can be overridden by specifying this flag. If it is given, the button will be made just big enough for its contents. Notice that under MSW the button will still have at least the standard height, even with this style, if it has a non-empty label. 
+  # 
   # - {Wx::BU_NOTEXT}: Disables the display of the text label in the button even if it has one or its id is one of the standard stock ids with an associated label: without using this style a button which is only supposed to show a bitmap but uses a standard id would display a label too. 
+  # 
   # - {Wx::Border::BORDER_NONE}: Creates a button without border. This is currently implemented in MSW, GTK2 and OSX/Cocoa. 
   # 
   # === 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::EvtHandler#evt_button}(id, meth = nil, &block): Process a {Wx::EVT_BUTTON} event, when the 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
+  # 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::BitmapButton 
   # 
@@ -51,7 +63,7 @@ module Wx
   
     # @overload initialize()
     #   Default ctor.
-    #   @return [Button]
+    #   @return [Wx::Button]
     # @overload initialize(parent, id, label=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ButtonNameStr)
     #   Constructor, creating and showing a button.
     #   The preferred way to create standard buttons is to use default value of label. If no label is supplied and id is one of standard IDs from this list, a standard label will be used. In other words, if you use a predefined {Wx::ID_XXX} constant, just omit the label completely rather than specifying it. In particular, help buttons (the ones with id of {Wx::StandardID::ID_HELP}) under macOS can't display any label at all and while {Wx::Button} will detect if the standard "Help" label is used and ignore it, using any other label will prevent the button from correctly appearing as a help button and so should be avoided.
@@ -66,7 +78,7 @@ module Wx
     #   @param style [Integer]  Window style. See {Wx::Button} class description.
     #   @param validator [Wx::Validator]  Window validator.
     #   @param name [String]  Window name.
-    #   @return [Button]
+    #   @return [Wx::Button]
     def initialize(*args) end
     
     # Button creation function for two-step creation.

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

@@ -11,6 +11,7 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CalculateLayoutEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_calculate_layout}(meth = nil, &block): Process a {Wx::EVT_CALCULATE_LAYOUT} event, which asks the window to take a 'bite' out of a rectangle provided by the algorithm. 
   # 
   # === 
@@ -25,7 +26,7 @@ module Wx
   
     # Constructor.
     # @param id [Integer] 
-    # @return [CalculateLayoutEvent]
+    # @return [Wx::CalculateLayoutEvent]
     def initialize(id=0) end
     
     # Returns the flags associated with this event.