# :stopdoc:
# This file is automatically generated by the WXRuby3 documentation 
# generator. Do not alter this file.
# :startdoc:


module Wx

  # 
  BITMAP_SCREEN_DEPTH = -1
  
  # An empty {Wx::Bitmap} object.
  # 
  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;
  # - 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}
  # @see Bitmaps and Icons
  # @see  Supported Bitmap File Formats
  # @see  Wx::DC#blit
  # @see  Wx::Icon
  # @see  Wx::Cursor
  # @see  Wx::MemoryDC
  # @see  Wx::Image
  # @see  Wx::PixelData 
  # 
  # 
  # 
  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
  class Bitmap < GDIObject
  
    # @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(
    #                     Wx::Rect.new(0, 0, oldBitmap.width, oldBitmap.height))
    #   ```
    #   @param bitmap [Wx::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.
    #   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+.
    #   @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 [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 [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 [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 [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.
    #   @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 [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
    
    # Creates the bitmap from an icon.
    # @param icon [Wx::Icon] 
    # @return [Boolean]
    def copy_from_icon(icon) end
    
    # @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.
    #   @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 [Boolean]
    # @overload create(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 [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.
    #   @param dc [Wx::DC]  DC from which the scaling factor is inherited
    #   @return [Boolean]
    def create(*args) end
    
    # @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:
    #   
    #   - {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.
    #   @param scale [Float]  Scale factor used by the bitmap, see {Wx::Bitmap#set_scale_factor}.
    #   @param depth [Integer]  The number of bits used to represent each bitmap pixel.
    #   @return [Boolean]
    # @overload create_with_dip_size(width, height, scale, 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 width [Integer] 
    #   @param height [Integer] 
    #   @param scale [Float] 
    #   @param depth [Integer] 
    #   @return [Boolean]
    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.
    # @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.
    # @param logicalScale [Float]  Scale factor used by the bitmap, see {Wx::Bitmap#set_scale_factor}.
    # @return [Boolean]
    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]
    def get_dip_size; end
    alias_method :dip_size, :get_dip_size
    
    # 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 
    # @return [Integer]
    def get_height; end
    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
    # @return [Float]
    def get_logical_height; end
    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
    # @see  Wx::Bitmap#get_logical_height
    # @see  Wx::Bitmap#get_size
    # @return [Wx::Size]
    def get_logical_size; end
    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
    # @return [Float]
    def get_logical_width; end
    alias_method :logical_width, :get_logical_width
    
    # 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]
    def get_mask; end
    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]
    def get_sub_bitmap(rect) end
    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
    # @see  Wx::Bitmap#get_logical_width
    # @see  Wx::Bitmap#get_logical_height
    # @see  Wx::Bitmap#get_logical_size
    # @return [Float]
    def get_scale_factor; end
    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
    # @see  Wx::Bitmap#get_logical_size 
    # @return [Wx::Size]
    def get_size; end
    alias_method :size, :get_size
    
    # 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 
    # @return [Integer]
    def get_width; end
    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
    alias_method :has_alpha?, :has_alpha
    
    # Returns true if bitmap data is present.
    # @return [Boolean]
    def is_ok; end
    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>
    # @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.
    # @return [Boolean]
    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>
    # @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.
    # @param palette [Wx::Palette]  An optional palette used for saving the bitmap.
    # @return [Boolean]
    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] 
    # @return [void]
    def set_scale_factor(scale) end
    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 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] 
    # @return [void]
    def set_mask(mask) end
    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] 
    # @param sizeNeeded [Array(Integer, Integer), Wx::Size] 
    # @return [void]
    def self.rescale(bmp, sizeNeeded) end
    
  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.
  # - A custom bitmap source using {Wx::BitmapBundleImpl}.
  # - A single {Wx::Bitmap} or {Wx::Image} for backwards compatibility.
  #  Objects of {Wx::BitmapBundle} class have value-like semantics, i.e. they can be copied around freely (and cheaply) and don't need to be allocated on the heap. However they usually are created using static factory functions (known as "pseudo-constructors") such as {Wx::BitmapBundle.from_bitmaps} instead of using the real constructors.
  # ```ruby
  #   class MyFrame < Wx::Frame
  #     
  #     def initialize
  #       super(nil, Wx::ID_ANY, "My frame")
  #       # ...
  #       tool_bar = create_toolBar
  #    
  #       bitmaps = [
  #           Wx::Bitmap(:open_32x32, Wx::BitmapType::BITMAP_TYPE_PNG),
  #           Wx::Bitmap(:open_48x48, Wx::BitmapType::BITMAP_TYPE_PNG),
  #           Wx::Bitmap(:open_64x64, Wx::BitmapType::BITMAP_TYPE_PNG)
  #         ]
  #  
  #       tool_bar.add_tool(Wx::ID_OPEN, "Open", Wx::BitmapBundle.from_bitmaps(bitmaps))
  #     end
  # ```
  # 
  # The code shown above will use 32 pixel bitmap in normal DPI, 64 pixel bitmap in "high DPI", i.e. pixel-doubling or 200% resolution, and 48 pixel bitmap in 150% resolution. For all the other resolutions, the bitmap with the "best" matching size will be used, where "best" is deemed to be the bitmap with the closest size if it can be used without scaling (so that in this example the 64px bitmap will be used at 175% resolution because it typically looks much better than either downscaling it or upscaling the 48px bitmap to 56px) or, if there is no bitmap with close enough size, a bitmap upscaled by an integer scaling factor is used. Note that custom bitmap bundles can use a different algorithm for selecting the best match by overriding Wx::BitmapBundleImpl#get_preferred_bitmap_size_at_scale.
  # 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)
  # 
  # 
  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
  class BitmapBundle < ::Object
  
    # @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]
    # @overload initialize(other)
    #   Copy constructor creates a copy of another bundle.
    #   @param other [Wx::BitmapBundle] 
    #   @return [Wx::BitmapBundle]
    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]
    def get_default_size; end
    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] 
    # @return [Wx::Size]
    def get_preferred_bitmap_size_at_scale(scale) end
    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]
    def get_preferred_bitmap_size_for(window) end
    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]
    def get_preferred_logical_size_for(window) end
    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]
    def get_bitmap(size) end
    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]
    def get_bitmap_for(window) end
    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]
    def get_icon(size) end
    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]
    def get_icon_for(window) end
    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]
    def is_same_as(other) end
    alias_method :same_as?, :is_same_as
    
    # @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]
    # @overload self.from_bitmaps(bitmap1, bitmap2)
    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
    #   @param bitmap1 [Wx::Bitmap] 
    #   @param bitmap2 [Wx::Bitmap] 
    #   @return [Wx::BitmapBundle]
    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] 
    # @return [Wx::BitmapBundle]
    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] 
    # @return [Wx::BitmapBundle]
    def self.from_image(image) end
    
    # @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
    #   @param extension [String]  File extension, without leading dot (png by default)
    #   @return [Wx::BitmapBundle]
    # @overload self.from_files(fullpathname)
    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
    #   @param fullpathname [String] 
    #   @return [Wx::BitmapBundle]
    def self.from_files(*args) end
    
    # This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
    # @param data [String] 
    # @param sizeDef [Array(Integer, Integer), Wx::Size] 
    # @return [Wx::BitmapBundle]
    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.
    # @return [Wx::BitmapBundle]
    def self.from_svg_file(path, sizeDef) end
    
  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">
  # <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
  # @see  Wx::DC#blit
  # @see  Wx::MemoryDC 
  # 
  # 
  class Mask < Object
  
    # @overload initialize()
    #   Default constructor.
    #   @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 [Wx::Mask]
    # @overload initialize(bitmap)
    #   Constructs a mask from a monochrome bitmap.
    #   @param bitmap [Wx::Bitmap] 
    #   @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 [Wx::Mask]
    def initialize(*args) end
    
    # @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.
    #   @return [Boolean]
    # @overload create(bitmap)
    #   Constructs a mask from a monochrome bitmap.
    #   @param bitmap [Wx::Bitmap] 
    #   @return [Boolean]
    # @overload create(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 [Boolean]
    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
    alias_method :bitmap, :get_bitmap
    
  end # Mask
  

end