wxruby3 0.9.2-x64-mingw-ucrt → 0.9.4-x64-mingw-ucrt

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

@@ -14,6 +14,7 @@ module Wx
   NULL_BITMAP = nil
   
   # 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:
   # 
@@ -43,10 +44,12 @@ 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 [Wx::Bitmap]
     # @overload initialize(bitmap)
     #   Copy constructor, uses reference counting.
+    #   
     #   To make a real copy, you can use:
     #   ```ruby
     #     newBitmap = oldBitmap.get_sub_bitmap(
@@ -56,6 +59,7 @@ module Wx
     #   @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.
     #   Some platforms only support 1 for monochrome and {Wx::BITMAP_SCREEN_DEPTH} for the current colour setting.
     #   A depth of 32 including an alpha channel is supported under MSW, Mac and GTK+.
@@ -77,12 +81,14 @@ module Wx
     # @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 [Wx::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 [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.
     #   The resulting bitmap will use the provided colour depth (or that of the current system if depth is {Wx::BITMAP_SCREEN_DEPTH}) which entails that a colour reduction may take place.
     #   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.
@@ -91,24 +97,28 @@ module Wx
     #   @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 [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 [Wx::Bitmap]
     def initialize(*args) end
     
     # Returns disabled (dimmed) version of the bitmap.
+    # 
     # This method is not available when <code>wxUSE_IMAGE == 0</code>.
     # @param brightness [Integer] 
     # @return [Wx::Bitmap]
     def convert_to_disabled(brightness=255) end
     
     # Creates an image from a platform-dependent bitmap.
+    # 
     # This preserves mask information so that bitmaps and images can be converted back and forth without loss in that respect.
     # @return [Wx::Image]
     def convert_to_image; end
@@ -120,6 +130,7 @@ module Wx
     
     # @overload create(width, height, depth=Wx::BITMAP_SCREEN_DEPTH)
     #   Creates a fresh bitmap.
+    #   
     #   If the final argument is omitted, the display depth of the screen is used.
     #   
     #   true if the creation was successful.
@@ -134,6 +145,7 @@ module Wx
     #   @return [Boolean]
     # @overload create(width, height, dc)
     #   Create a bitmap compatible with the given DC, inheriting its magnification factor.
+    #   
     #   true if the creation was successful.
     #   @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.
@@ -143,6 +155,7 @@ module Wx
     
     # @overload create_with_dip_size(size, scale, depth=Wx::BITMAP_SCREEN_DEPTH)
     #   Create a bitmap specifying its size in DPI-independent pixels and the scale factor to use.
+    #   
     #   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:
     #   
@@ -165,6 +178,7 @@ module Wx
     def create_with_dip_size(*args) end
     
     # Create a bitmap with a scale factor.
+    # 
     # This is an older synonym for {Wx::Bitmap#create_with_dip_size}, use the new function in the new code.
     # 
     # true if the creation was successful.
@@ -176,12 +190,14 @@ module Wx
     def create_scaled(width, height, depth, logicalScale) end
     
     # Gets the colour depth of the bitmap.
+    # 
     # A value of 1 indicates a monochrome bitmap.
     # @return [Integer]
     def get_depth; end
     alias_method :depth, :get_depth
     
     # Returns the size of bitmap in DPI-independent units.
+    # 
     # This assumes that the bitmap was created using the value of scale factor corresponding to the current DPI (see {Wx::Bitmap#create_with_dip_size} and {Wx::Bitmap#set_scale_factor}) and returns its physical size divided by this scale factor.
     # Unlike {Wx::Bitmap#get_logical_size}, this function returns the same value under all platforms and so its result should not be used as window or device context coordinates.
     # @return [Wx::Size]
@@ -190,6 +206,7 @@ module Wx
     
     # Returns the height of the bitmap in physical pixels.
     # 
+    # 
     # @see Wx::Bitmap#get_width
     # @see  Wx::Bitmap#get_size
     # @see  Wx::Bitmap#get_logical_height 
@@ -198,6 +215,7 @@ module Wx
     alias_method :height, :get_height
     
     # Returns the height of the bitmap in logical pixels.
+    # 
     # See {Wx::Bitmap#get_logical_size} for more information.
     # @see Wx::Bitmap#get_logical_width
     # @see  Wx::Bitmap#get_width
@@ -206,6 +224,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 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
@@ -216,6 +235,7 @@ module Wx
     alias_method :logical_size, :get_logical_size
     
     # Returns the width of the bitmap in logical pixels.
+    # 
     # See {Wx::Bitmap#get_logical_size} for more information.
     # @see Wx::Bitmap#get_logical_height
     # @see  Wx::Bitmap#get_width
@@ -225,6 +245,7 @@ module Wx
     
     # Gets the associated mask (if any) which may have been loaded from a file or set for the bitmap.
     # 
+    # 
     # @see Wx::Bitmap#set_mask
     # @see  Wx::Mask 
     # @return [Wx::Mask]
@@ -232,6 +253,7 @@ module Wx
     alias_method :mask, :get_mask
     
     # Returns a sub bitmap of the current one as long as the rect belongs entirely to the bitmap.
+    # 
     # This function preserves bit depth and mask information.
     # @param rect [Wx::Rect] 
     # @return [Wx::Bitmap]
@@ -239,6 +261,7 @@ module Wx
     alias_method :sub_bitmap, :get_sub_bitmap
     
     # 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 WXOSX or WXGTK3, and this function always returns 1 under the other platforms.
     # @see Wx::Bitmap#set_scale_factor
@@ -250,24 +273,28 @@ module Wx
     alias_method :scale_factor, :get_scale_factor
     
     # Returns the height of the bitmap in logical pixels.
+    # 
     # This is an older synonym for {Wx::Bitmap#get_logical_height}, use the new function in the new code.
     # @return [Float]
     def get_scaled_height; end
     alias_method :scaled_height, :get_scaled_height
     
     # Returns the size of the bitmap in logical pixels.
+    # 
     # This is an older synonym for {Wx::Bitmap#get_logical_size}, use the new function in the new code.
     # @return [Wx::Size]
     def get_scaled_size; end
     alias_method :scaled_size, :get_scaled_size
     
     # Returns the width of the bitmap in logical pixels.
+    # 
     # This is an older synonym for {Wx::Bitmap#get_logical_width}, use the new function in the new code.
     # @return [Float]
     def get_scaled_width; end
     alias_method :scaled_width, :get_scaled_width
     
     # Returns the size of the bitmap in physical pixels.
+    # 
     # The return value of this function doesn't depend on the scale factor, it is always the physical size of the bitmap, i.e. corresponding to the actual number of pixels in it.
     # @see Wx::Bitmap#get_height
     # @see  Wx::Bitmap#get_width
@@ -278,6 +305,7 @@ module Wx
     
     # Returns the width of the bitmap in physical pixels.
     # 
+    # 
     # @see Wx::Bitmap#get_height
     # @see  Wx::Bitmap#get_size
     # @see  Wx::Bitmap#get_logical_width 
@@ -286,6 +314,7 @@ module Wx
     alias_method :width, :get_width
     
     # Returns true if the bitmap has an alpha channel.
+    # 
     # Note that the fact that a bitmap has an alpha channel doesn't necessarily mean that it has any transparency, as all of its pixels could be using {Wx::ALPHA_OPAQUE} value. To actually examine the alpha values, the bitmap can be converted to {Wx::Image}.
     # @return [Boolean]
     def has_alpha; end
@@ -297,13 +326,14 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Loads a bitmap from a file or resource.
+    # 
     # true if the operation succeeded, false otherwise.
     # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>A palette may be associated with the bitmap if one exists (especially for colour Windows bitmaps), and if the code supports it. You can check if one has been created by using the {Wx::Bitmap#get_palette} member.
     # </p>
-    # </div>>
+    # </div>
     # @see Wx::Bitmap#save_file 
     # @param name [String]  Either a filename or a Windows resource name. The meaning of name is determined by the type parameter.
     # @param type [Wx::BitmapType]  One of the {Wx::BitmapType} values; 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.
@@ -311,18 +341,20 @@ module Wx
     def load_file(name, type=Wx::BITMAP_DEFAULT_TYPE) end
     
     # Remove alpha channel from the bitmap.
+    # 
     # This is the same as calling {Wx::Bitmap#use_alpha} with false argument.
     # @return [void]
     def reset_alpha; end
     
     # Saves a bitmap in the named file.
+    # 
     # true if the operation succeeded, false otherwise.
     # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>Depending on how wxWidgets has been configured, not all formats may be available.
     # </p>
-    # </div>>
+    # </div>
     # @see Wx::Bitmap#load_file 
     # @param name [String]  A filename. The meaning of name is determined by the type parameter.
     # @param type [Wx::BitmapType]  One of the {Wx::BitmapType} values; see the note in the class detailed description.
@@ -331,6 +363,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. 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] 
@@ -339,11 +372,12 @@ module Wx
     alias_method :scale_factor=, :set_scale_factor
     
     # Sets the mask for this bitmap.
+    # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>The bitmap object owns the mask once this has been called.
     # </p>
-    # </div>>
+    # </div>
     # 
     # <div class="wxrb-note">
     # <b>Note:</b>
@@ -358,6 +392,7 @@ module Wx
     alias_method :mask=, :set_mask
     
     # Rescale the given bitmap to the requested size.
+    # 
     # This function is just a convenient wrapper for {Wx::Image#rescale} used to resize the given bmp to the requested size. If you need more control over resizing, e.g. to specify the quality option different from {Wx::ImageResizeQuality::IMAGE_QUALITY_NEAREST} used by this function, please use the {Wx::Image} function directly instead.
     # Both the bitmap itself and size must be valid.
     # @param bmp [Wx::Bitmap] 
@@ -368,6 +403,7 @@ module Wx
   end # Bitmap
   
   # Contains representations of the same bitmap in different resolutions.
+  # 
   # This class generalizes {Wx::Bitmap} for applications supporting multiple DPIs and allows to operate with multiple versions of the same bitmap, in the sizes appropriate to the currently used display resolution, as a single unit. Notably, an entire {Wx::BitmapBundle} can be passed to functions such as {Wx::ToolBar#add_tool} to allow toolbar to select the best available bitmap to be shown.
   # Objects of this class are typically created by the application and then passed to wxWidgets functions, but not used by the application itself. Currently bitmap bundles can be created from: - A vector of bitmaps, of any provenance.
   # - An SVG (as memory block, file, or resource) which will be rasterized at required resolutions.
@@ -405,20 +441,24 @@ 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 [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 [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 [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 [Wx::BitmapBundle]
@@ -429,18 +469,21 @@ module Wx
     def initialize(*args) end
     
     # Clear the existing bundle contents.
+    # 
     # After calling this function {Wx::BitmapBundle#is_ok} returns false.
     # This is the same as assigning a default-constructed bitmap bundle to this object but slightly more explicit.
     # @return [void]
     def clear; end
     
     # Check if bitmap bundle is non-empty.
+    # 
     # Return true if the bundle contains any bitmaps or false if it is empty.
     # @return [Boolean]
     def is_ok; end
     alias_method :ok?, :is_ok
     
     # Get the size of the bitmap represented by this bundle in default resolution or, equivalently, at 100% scaling.
+    # 
     # When creating the bundle from a number of bitmaps, this will be just the size of the smallest bitmap in it.
     # Note that this function is mostly used by wxWidgets itself and not the application.
     # @return [Wx::Size]
@@ -448,6 +491,7 @@ module Wx
     alias_method :default_size, :get_default_size
     
     # Get the size that would be best to use for this bundle at the given DPI scaling factor.
+    # 
     # For bundles containing some number of the fixed-size bitmaps, this function returns the size of an existing bitmap closest to the ideal size at the given scale, i.e. {Wx::BitmapBundle#get_default_size} multiplied by scale.
     # Passing a size returned by this function to {Wx::BitmapBundle#get_bitmap} ensures that bitmap doesn't need to be rescaled, which typically significantly lowers its quality.
     # @param scale [Float] 
@@ -456,6 +500,7 @@ module Wx
     alias_method :preferred_bitmap_size_at_scale, :get_preferred_bitmap_size_at_scale
     
     # Get the size that would be best to use for this bundle at the DPI scaling factor used by the given window.
+    # 
     # This is just a convenient wrapper for {Wx::BitmapBundle#get_preferred_bitmap_size_at_scale} calling that function with the result of {Wx::Window#get_dpi_scale_factor}.
     # @param window [Wx::Window]  Non-null and fully created window.
     # @return [Wx::Size]
@@ -463,6 +508,7 @@ module Wx
     alias_method :preferred_bitmap_size_for, :get_preferred_bitmap_size_for
     
     # Get the size that would be best to use for this bundle at the DPI scaling factor used by the given window in logical size.
+    # 
     # This is just call {Wx::BitmapBundle#get_preferred_bitmap_size_at_scale} with the result of {Wx::Window#get_dpi_scale_factor} and convert returned value with {Wx::Window#from_phys}.
     # @param window [Wx::Window]  Non-null and fully created window.
     # @return [Wx::Size]
@@ -470,6 +516,7 @@ module Wx
     alias_method :preferred_logical_size_for, :get_preferred_logical_size_for
     
     # Get bitmap of the specified size, creating a new bitmap from the closest available size by rescaling it if necessary.
+    # 
     # This function is mostly used by wxWidgets itself and not the application. As all bitmaps created by it dynamically are currently cached, avoid calling it for many different sizes if you do use it, as this will create many bitmaps that will never be deleted and will consume resources until the application termination.
     # @param size [Array(Integer, Integer), Wx::Size]  The size of the bitmap to return, in physical pixels. If this parameter is {Wx::DEFAULT_SIZE}, default bundle size is used.
     # @return [Wx::Bitmap]
@@ -477,6 +524,7 @@ module Wx
     alias_method :bitmap, :get_bitmap
     
     # Get bitmap of the size appropriate for the DPI scaling used by the given window.
+    # 
     # This helper function simply combines {Wx::BitmapBundle#get_preferred_bitmap_size_for} and {Wx::BitmapBundle#get_bitmap}, i.e. it returns a (normally unscaled) bitmap from the bundle of the closest size to the size that should be used at the DPI scaling of the provided window.
     # @param window [Wx::Window]  Non-null and fully created window.
     # @return [Wx::Bitmap]
@@ -484,6 +532,7 @@ module Wx
     alias_method :bitmap_for, :get_bitmap_for
     
     # Get icon of the specified size.
+    # 
     # This is just a convenient wrapper for {Wx::BitmapBundle#get_bitmap} and simply converts the returned bitmap to {Wx::Icon}.
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @return [Wx::Icon]
@@ -491,6 +540,7 @@ module Wx
     alias_method :icon, :get_icon
     
     # Get icon of the size appropriate for the DPI scaling used by the given window.
+    # 
     # This is similar to {Wx::BitmapBundle#get_bitmap_for}, but returns a {Wx::Icon}, as {Wx::BitmapBundle#get_icon} does.
     # @param window [Wx::Window]  Non-null and fully created window.
     # @return [Wx::Icon]
@@ -498,6 +548,7 @@ module Wx
     alias_method :icon_for, :get_icon_for
     
     # Check if the two bundles refer to the same object.
+    # 
     # Bundles are considered to be same only if they actually use the same underlying object, i.e. are copies of each other. If the two bundles were independently constructed, they're not considered to be the same, even if they were created from the same bitmap.
     # @param other [Wx::BitmapBundle] 
     # @return [Boolean]
@@ -506,6 +557,7 @@ module Wx
     
     # @overload self.from_bitmaps(bitmaps)
     #   Create a bundle from the given collection of bitmaps.
+    #   
     #   If the bitmaps vector is empty, an invalid, empty bundle is returned, otherwise initialize the bundle with all the bitmaps in this vector which must be themselves valid.
     #   @param bitmaps [Array<Wx::Bitmap>] 
     #   @return [Wx::BitmapBundle]
@@ -517,6 +569,7 @@ module Wx
     def self.from_bitmaps(*args) end
     
     # Create a bundle from a single bitmap.
+    # 
     # This is only useful for compatibility with the existing code using {Wx::Bitmap}.
     # If bitmap is invalid, empty bundle is returned.
     # @param bitmap [Wx::Bitmap] 
@@ -524,12 +577,14 @@ module Wx
     def self.from_bitmap(bitmap) end
     
     # Create a bundle from an icon bundle.
+    # 
     # If iconBundle is invalid or empty, empty bundle is returned.
     # @param iconBundle [Wx::IconBundle] 
     # @return [Wx::BitmapBundle]
     def self.from_icon_bundle(iconBundle) end
     
     # Create a bundle from a single image.
+    # 
     # This is only useful for compatibility with the existing code using {Wx::Image}.
     # If image is invalid, empty bundle is returned.
     # @param image [Wx::Image] 
@@ -538,6 +593,7 @@ module Wx
     
     # @overload self.from_files(path, filename, extension=("PNG"))
     #   Create a bundle from bitmaps stored as files.
+    #   
     #   Looking in path for files using filename as prefix and potentionally a suffix with scale, e.g. "_2x" or "@2x"
     #   @param path [String]  Path of the directory containing the files
     #   @param filename [String]  Bitmap's filename without any scale suffix
@@ -556,6 +612,7 @@ module Wx
     def self.from_svg(data, sizeDef) end
     
     # Create a bundle from the SVG image loaded from the given file.
+    # 
     # This function loads the SVG data from the given path and calls {Wx::BitmapBundle.from_svg} with it. As it is just a wrapper for {Wx::BitmapBundle.from_svg}, please see that function documentation for more information about SVG support.
     # @param path [String]  Path to the SVG file. Notice that it should a local file, not an URL.
     # @param sizeDef [Array(Integer, Integer), Wx::Size]  The default size to return from {Wx::BitmapBundle#get_default_size} for this bundle.
@@ -565,6 +622,7 @@ module Wx
   end # BitmapBundle
   
   # 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.
   # 
   # <div class="wxrb-note">
@@ -586,6 +644,7 @@ module Wx
     #   @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.
@@ -603,6 +662,7 @@ module Wx
     
     # @overload create(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.
@@ -619,6 +679,7 @@ module Wx
     def create(*args) end
     
     # Returns the mask as a monochrome bitmap.
+    # 
     # Currently this method is implemented in WXMSW, WXGTK and WXOSX.
     # @return [Wx::Bitmap]
     def get_bitmap; end

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

@@ -7,6 +7,7 @@
 module Wx
 
   # A bitmap button is a control that contains a bitmap.
+  # 
   # Notice that since wxWidgets 2.9.1 bitmap display is supported by the base {Wx::Button} class itself and the only tiny advantage of using this class is that it allows specifying the bitmap in its constructor, unlike {Wx::Button}. Please see the base class documentation for more information about images support in {Wx::Button}.
   # ### Styles
   # 
@@ -43,11 +44,12 @@ module Wx
     #   @return [Wx::BitmapButton]
     # @overload initialize(parent, id, bitmap, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR)
     #   Constructor, creating and showing a button.
+    #   
     #   <div class="wxrb-remark">
     #   <b>Remark:</b>
     #   <p>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}.
     #   </p>
-    #   </div>>
+    #   </div>
     #   @see Wx::BitmapButton#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -62,6 +64,7 @@ module Wx
     def initialize(*args) end
     
     # Button creation function for two-step creation.
+    # 
     # For more details, see {Wx::BitmapButton#initialize}.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -75,6 +78,7 @@ module Wx
     def create(parent, id, bitmap, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR) end
     
     # Creation function for two-step creation of "Close" button.
+    # 
     # It is usually not necessary to use this function directly as {Wx::BitmapButton.new_close_button} is more convenient, but, if required, it can be called on a default-constructed {Wx::BitmapButton} object to achieve the same effect.
     # @param parent [Wx::Window]  The button parent window, must be non-NULL.
     # @param winid [Integer]  The identifier for the new button.
@@ -83,6 +87,7 @@ module Wx
     def create_close_button(parent, winid, name=(())) end
     
     # Helper function creating a standard-looking "Close" button.
+    # 
     # To get the best results, platform-specific code may need to be used to create a small, title bar-like "Close" button. This function is provided to avoid the need to test for the current platform and creates the button with as native look as possible.
     # 
     # The new button.

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

@@ -7,13 +7,14 @@
 module Wx
 
   # A combobox that displays bitmap in front of the list items.
+  # 
   # It currently only allows using bitmaps of one size, and resizes itself so that a bitmap can be shown next to the text field.
   # 
   # <div class="wxrb-remark">
   # <b>Remark:</b>
   # <p>While {Wx::BitmapComboBox} contains the {Wx::ComboBox} API, but it might not actually be derived from that class. In fact, if the platform does not have a native implementation, {Wx::BitmapComboBox} will inherit from {Wx::OwnerDrawnComboBox}. You can determine if the implementation is generic by checking whether {Wx::GENERIC_BITMAPCOMBOBOX} is defined. Currently {Wx::BitmapComboBox} is implemented natively for MSW and GTK+.
   # </p>
-  # </div>>
+  # </div>
   # 
   # ### Styles
   # 
@@ -57,6 +58,7 @@ module Wx
     # @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::BITMAP_COMBO_BOX_NAME_STR)
     #   Constructor, creating and showing a combobox.
     #   
+    #   
     #   @see Wx::BitmapComboBox#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -72,6 +74,7 @@ module Wx
     # @overload initialize(parent, id, value, pos, size, choices, style, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BITMAP_COMBO_BOX_NAME_STR)
     #   Constructor, creating and showing a combobox.
     #   
+    #   
     #   @see Wx::BitmapComboBox#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -92,7 +95,7 @@ module Wx
     #   @param bitmap [Wx::Bitmap] 
     #   @return [Integer]
     # @overload append(item, bitmap, clientData)
-    #   Adds the item to the end of the combo box, associating the given untyped, client data pointer clientData with the item.
+    #   Adds the item to the end of the combo box, associating the given typed client data pointer clientData with the item.
     #   @param item [String] 
     #   @param bitmap [Wx::Bitmap] 
     #   @param clientData [Object] 
@@ -126,6 +129,7 @@ module Wx
     def create(*args) end
     
     # Returns the size of the bitmaps used in the combo box.
+    # 
     # If the combo box is empty, then {Wx::DEFAULT_SIZE} is returned.
     # @return [Wx::Size]
     def get_bitmap_size; end
@@ -139,13 +143,15 @@ module Wx
     
     # @overload insert(item, bitmap, pos)
     #   Inserts the item into the list before pos.
+    #   
     #   Not valid for {Wx::CB_SORT} style, use {Wx::BitmapComboBox#append} instead.
     #   @param item [String] 
     #   @param bitmap [Wx::Bitmap] 
     #   @param pos [Integer] 
     #   @return [Integer]
     # @overload insert(item, bitmap, pos, clientData)
-    #   Inserts the item into the list before pos, associating the given untyped, client data pointer with the item.
+    #   Inserts the item into the list before pos, associating the given typed client data pointer with the item.
+    #   
     #   Not valid for {Wx::CB_SORT} style, use {Wx::BitmapComboBox#append} instead.
     #   @param item [String] 
     #   @param bitmap [Wx::Bitmap]