wxruby3 0.9.1-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

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

@@ -14,17 +14,17 @@ 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:
   # 
-  # - wxMSW supports BMP and ICO files, BMP and ICO resources;
-  # - wxGTK supports any file supported by gdk-pixbuf;
-  # - wxMac supports PICT resources;
-  # - wxX11 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;
+  # - WXOSX 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.
-  # === 
   # 
   # Category:  Graphics Device Interface (GDI)
   # Predefined objects/pointers: {Wx::NULL_BITMAP}
@@ -44,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(
@@ -57,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+.
@@ -78,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.
@@ -92,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
@@ -121,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.
@@ -135,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.
@@ -144,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:
     #   
@@ -166,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.
@@ -177,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]
@@ -191,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 
@@ -199,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
@@ -207,7 +224,8 @@ 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}.
+    # 
+    # 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
@@ -217,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
@@ -226,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]
@@ -233,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]
@@ -240,8 +261,9 @@ 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.
+    # 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
@@ -251,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
@@ -279,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 
@@ -287,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
@@ -298,9 +326,14 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Loads a bitmap from a file or resource.
+    # 
     # true if the operation succeeded, false otherwise.
     # 
-    # 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.
+    # <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>
     # @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.
@@ -308,14 +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.
     # 
-    # Depending on how wxWidgets has been configured, not all formats may be available.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Depending on how wxWidgets has been configured, not all formats may be available.
+    # </p>
+    # </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.
@@ -324,7 +363,8 @@ 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).
+    # 
+    # 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]
@@ -332,9 +372,18 @@ module Wx
     alias_method :scale_factor=, :set_scale_factor
     
     # 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 wxMSW is not recommended because performance of drawing such bitmap is not very good.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>The bitmap object owns the mask once this has been called.
+    # </p>
+    # </div>
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>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.
+    # </p>
+    # </div>
     # @see Wx::Bitmap#get_mask
     # @see  Wx::Mask 
     # @param mask [Wx::Mask] 
@@ -343,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] 
@@ -353,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.
@@ -381,7 +432,6 @@ module Wx
   # Of course, this code relies on actually having the resources with the corresponding names (i.e. open_NxN) in MSW .rc file or Mac application bundle and open_NxN_png arrays being defined in the program code, e.g. by including a file generated with bin2c (see {bitmap_png_from_data}), on the other platforms.
   # 
   # Also note that the existing code using {Wx::Bitmap} is compatible with the functions taking {Wx::BitmapBundle} in wxWidgets 3.1.6 and later because bitmaps are implicitly convertible to the objects of this class, so just passing {Wx::Bitmap} to the functions taking {Wx::BitmapBundle} continues to work and if high resolution versions of bitmap are not (yet) available for the other toolbar tools, single bitmaps can continue to be used instead.
-  # === 
   # 
   # Category:  Graphics Device Interface (GDI)
   # 
@@ -391,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]
@@ -415,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]
@@ -434,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] 
@@ -442,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]
@@ -449,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]
@@ -456,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]
@@ -463,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]
@@ -470,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]
@@ -477,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]
@@ -484,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]
@@ -492,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]
@@ -503,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] 
@@ -510,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] 
@@ -524,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
@@ -542,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.
@@ -551,10 +622,14 @@ 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.
-  # 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.
   # 
-  # === 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>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.
+  # </p>
+  # </div>
   # 
   # Category:  Graphics Device Interface (GDI)
   # @see Wx::Bitmap
@@ -569,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.
@@ -586,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.
@@ -602,7 +679,8 @@ module Wx
     def create(*args) end
     
     # Returns the mask as a monochrome bitmap.
-    # Currently this method is implemented in wxMSW, wxGTK and wxOSX.
+    # 
+    # 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

@@ -7,8 +7,9 @@
 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
+  # ### Styles
   # 
   # This class supports the following styles:
   # 
@@ -21,22 +22,21 @@ module Wx
   # - {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.
-  # === Events emitted by this class
+  # ### 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> wxMSW Appearance
-  #   </td><td> wxGTK Appearance
-  #   </td><td> wxOSX 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 
   # 
   # 
+  # @wxrb_require USE_BMPBUTTON
   class BitmapButton < Button
   
     # @overload initialize()
@@ -44,7 +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.
-    #   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}.
+    #   
+    #   <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>
     #   @see Wx::BitmapButton#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -59,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] 
@@ -72,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.
@@ -80,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.