wxruby3 1.6.0 → 1.7.0

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

@@ -0,0 +1,1271 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Bitmap type flags.
+  # 
+  # See {Wx::Bitmap} and {Wx::Image} classes.
+  # 
+  class BitmapType < Wx::Enum
+  
+    # 
+    # 
+    BITMAP_TYPE_INVALID = Wx::BitmapType.new(0)
+    
+    # 
+    # 
+    BITMAP_TYPE_BMP = Wx::BitmapType.new(1)
+    
+    # 
+    # 
+    BITMAP_TYPE_ICO = Wx::BitmapType.new(3)
+    
+    # 
+    # 
+    BITMAP_TYPE_CUR = Wx::BitmapType.new(5)
+    
+    # 
+    # 
+    BITMAP_TYPE_XBM = Wx::BitmapType.new(7)
+    
+    # 
+    # 
+    BITMAP_TYPE_XBM_DATA = Wx::BitmapType.new(8)
+    
+    # 
+    # 
+    BITMAP_TYPE_XPM = Wx::BitmapType.new(9)
+    
+    # 
+    # 
+    BITMAP_TYPE_XPM_DATA = Wx::BitmapType.new(10)
+    
+    # 
+    # 
+    BITMAP_TYPE_TIFF = Wx::BitmapType.new(11)
+    
+    # 
+    # 
+    BITMAP_TYPE_TIF = Wx::BitmapType.new(11)
+    
+    # 
+    # 
+    BITMAP_TYPE_GIF = Wx::BitmapType.new(13)
+    
+    # 
+    # 
+    BITMAP_TYPE_PNG = Wx::BitmapType.new(15)
+    
+    # 
+    # 
+    BITMAP_TYPE_JPEG = Wx::BitmapType.new(17)
+    
+    # 
+    # 
+    BITMAP_TYPE_PNM = Wx::BitmapType.new(19)
+    
+    # 
+    # 
+    BITMAP_TYPE_PCX = Wx::BitmapType.new(21)
+    
+    # 
+    # 
+    BITMAP_TYPE_PICT = Wx::BitmapType.new(23)
+    
+    # 
+    # 
+    BITMAP_TYPE_ICON = Wx::BitmapType.new(25)
+    
+    # 
+    # 
+    BITMAP_TYPE_ANI = Wx::BitmapType.new(27)
+    
+    # 
+    # 
+    BITMAP_TYPE_IFF = Wx::BitmapType.new(28)
+    
+    # 
+    # 
+    BITMAP_TYPE_TGA = Wx::BitmapType.new(29)
+    
+    # 
+    # 
+    BITMAP_TYPE_MACCURSOR = Wx::BitmapType.new(30)
+    
+    # 
+    # 
+    BITMAP_TYPE_WEBP = Wx::BitmapType.new(32)
+    
+    # 
+    # 
+    BITMAP_TYPE_ANY = Wx::BitmapType.new(50)
+    
+  end # BitmapType
+  
+  # Polygon filling mode.
+  # 
+  # See {Wx::DC#draw_polygon}.
+  # 
+  class PolygonFillMode < Wx::Enum
+  
+    # 
+    # 
+    ODDEVEN_RULE = Wx::PolygonFillMode.new(1)
+    
+    # 
+    # 
+    WINDING_RULE = Wx::PolygonFillMode.new(2)
+    
+  end # PolygonFillMode
+  
+  # Standard cursors.
+  # 
+  # Notice that under WXMSW some of these cursors are defined in wx.rc file and not by the system itself so you should include this file from your own resource file (possibly creating a trivial resource file just containing a single include line if you don't need it otherwise) to be able to use them.
+  # See {Wx::Cursor}.
+  # 
+  class StockCursor < Wx::Enum
+  
+    # 
+    # 
+    CURSOR_NONE = Wx::StockCursor.new(0)
+    
+    # A standard arrow cursor.
+    # 
+    CURSOR_ARROW = Wx::StockCursor.new(1)
+    
+    # A standard arrow cursor pointing to the right.
+    # 
+    CURSOR_RIGHT_ARROW = Wx::StockCursor.new(2)
+    
+    # Bullseye cursor.
+    # 
+    CURSOR_BULLSEYE = Wx::StockCursor.new(3)
+    
+    # Rectangular character cursor.
+    # 
+    CURSOR_CHAR = Wx::StockCursor.new(4)
+    
+    # A cross cursor.
+    # 
+    CURSOR_CROSS = Wx::StockCursor.new(5)
+    
+    # A hand cursor.
+    # 
+    CURSOR_HAND = Wx::StockCursor.new(6)
+    
+    # An I-beam cursor (vertical line).
+    # 
+    CURSOR_IBEAM = Wx::StockCursor.new(7)
+    
+    # Represents a mouse with the left button depressed.
+    # 
+    CURSOR_LEFT_BUTTON = Wx::StockCursor.new(8)
+    
+    # A magnifier icon.
+    # 
+    CURSOR_MAGNIFIER = Wx::StockCursor.new(9)
+    
+    # Represents a mouse with the middle button depressed.
+    # 
+    CURSOR_MIDDLE_BUTTON = Wx::StockCursor.new(10)
+    
+    # A no-entry sign cursor.
+    # 
+    CURSOR_NO_ENTRY = Wx::StockCursor.new(11)
+    
+    # A paintbrush cursor.
+    # 
+    CURSOR_PAINT_BRUSH = Wx::StockCursor.new(12)
+    
+    # A pencil cursor.
+    # 
+    CURSOR_PENCIL = Wx::StockCursor.new(13)
+    
+    # A cursor that points left.
+    # 
+    CURSOR_POINT_LEFT = Wx::StockCursor.new(14)
+    
+    # A cursor that points right.
+    # 
+    CURSOR_POINT_RIGHT = Wx::StockCursor.new(15)
+    
+    # An arrow and question mark.
+    # 
+    CURSOR_QUESTION_ARROW = Wx::StockCursor.new(16)
+    
+    # Represents a mouse with the right button depressed.
+    # 
+    CURSOR_RIGHT_BUTTON = Wx::StockCursor.new(17)
+    
+    # A sizing cursor pointing NE-SW.
+    # 
+    CURSOR_SIZENESW = Wx::StockCursor.new(18)
+    
+    # A sizing cursor pointing N-S.
+    # 
+    CURSOR_SIZENS = Wx::StockCursor.new(19)
+    
+    # A sizing cursor pointing NW-SE.
+    # 
+    CURSOR_SIZENWSE = Wx::StockCursor.new(20)
+    
+    # A sizing cursor pointing W-E.
+    # 
+    CURSOR_SIZEWE = Wx::StockCursor.new(21)
+    
+    # A general sizing cursor.
+    # 
+    CURSOR_SIZING = Wx::StockCursor.new(22)
+    
+    # A spraycan cursor.
+    # 
+    CURSOR_SPRAYCAN = Wx::StockCursor.new(23)
+    
+    # A wait cursor.
+    # 
+    CURSOR_WAIT = Wx::StockCursor.new(24)
+    
+    # A watch cursor.
+    # 
+    CURSOR_WATCH = Wx::StockCursor.new(25)
+    
+    # Transparent cursor.
+    # 
+    CURSOR_BLANK = Wx::StockCursor.new(26)
+    
+    # Standard X11 cursor (only in WXGTK).
+    # 
+    CURSOR_DEFAULT = Wx::StockCursor.new(27)
+    
+    # A wait cursor with a standard arrow.
+    # 
+    CURSOR_ARROWWAIT = Wx::StockCursor.new(28)
+    
+    # 
+    # 
+    CURSOR_MAX = Wx::StockCursor.new(29)
+    
+  end # StockCursor
+  
+  # Flags used by {Wx::Control.ellipsize} function.
+  # 
+  # 
+  # 
+  class EllipsizeFlags < Wx::Enum
+  
+    # No special flags.
+    # 
+    ELLIPSIZE_FLAGS_NONE = Wx::EllipsizeFlags.new(0)
+    
+    # Take mnemonics into account when calculating the text width.
+    # 
+    ELLIPSIZE_FLAGS_PROCESS_MNEMONICS = Wx::EllipsizeFlags.new(1)
+    
+    # Expand tabs in spaces when calculating the text width.
+    # 
+    ELLIPSIZE_FLAGS_EXPAND_TABS = Wx::EllipsizeFlags.new(2)
+    
+    # The default flags for {Wx::Control.ellipsize}.
+    # 
+    ELLIPSIZE_FLAGS_DEFAULT = Wx::EllipsizeFlags.new(3)
+    
+  end # EllipsizeFlags
+  
+  # The different ellipsization modes supported by the {Wx::Control.ellipsize} and Wx::RendererNative#draw_item_text functions.
+  # 
+  # 
+  # 
+  class EllipsizeMode < Wx::Enum
+  
+    # Don't ellipsize the text at all.
+    # 
+    ELLIPSIZE_NONE = Wx::EllipsizeMode.new(0)
+    
+    # Put the ellipsis at the start of the string, if the string needs ellipsization.
+    # 
+    ELLIPSIZE_START = Wx::EllipsizeMode.new(1)
+    
+    # Put the ellipsis in the middle of the string, if the string needs ellipsization.
+    # 
+    ELLIPSIZE_MIDDLE = Wx::EllipsizeMode.new(2)
+    
+    # Put the ellipsis at the end of the string, if the string needs ellipsization.
+    # 
+    ELLIPSIZE_END = Wx::EllipsizeMode.new(3)
+    
+  end # EllipsizeMode
+  
+  # Global instance of a {Wx::Point} initialized with values (-1,-1).
+  # 
+  DEFAULT_POSITION = Wx::Point.new(-1, -1)
+  
+  # Global instance of a {Wx::Size} object initialized to (-1,-1).
+  # 
+  DEFAULT_SIZE = Wx::Size.new(-1, -1)
+  
+  # Returns true if the display is colour, false otherwise.
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Use of this function is not recommended in the new code as it only works for the primary display. Use {Wx::Display#get_depth} to retrieve the depth of the appropriate display and compare it with 1 instead.
+  # </p>
+  # </div>
+  # @return [Boolean]
+  def self.colour_display; end
+  
+  # Returns the depth of the display (a value of 1 denotes a monochrome display).
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Use of this function is not recommended in the new code as it only works for the primary display. Use {Wx::Display#get_depth} to retrieve the depth of the appropriate display instead.
+  # </p>
+  # </div>
+  # @return [Integer]
+  def self.display_depth; end
+  
+  # Globally sets the cursor.
+  # 
+  # The globally set cursor overrides any cursor set for the individual windows, i.e. the specified cursor will be used for all windows of the application until this function is called again with an empty cursor bundle to restore the default behaviour of using the window-specific cursors.
+  # Note that this function won't update the cursor size if the DPI or user preferred cursor size changes, as this is considered unlikely to happen while this temporary cursor is shown. If you do want to update the cursor size, you need to handle {Wx::EVT_DPI_CHANGED} and {Wx::EVT_SYS_METRIC_CHANGED} events and call this function again from their handlers.
+  # @see Wx::Cursor
+  # @see  Wx::Window#set_cursor
+  # @see  Wx::Window#set_cursor_bundle
+  # @param cursors [Wx::CursorBundle] 
+  # @return [void]
+  def self.set_cursor(cursors) end
+  
+  # Returns the dimensions of the work area on the display.
+  # 
+  # On Windows this means the area not covered by the taskbar, etc. Other platforms are currently defaulting to the whole display until a way is found to provide this info for all window managers, etc.
+  # @see Wx::Display
+  # @return [Wx::Rect]
+  def self.get_client_display_rect; end
+  
+  # Returns the display resolution in pixels per inch.
+  # 
+  # The x component of the returned {Wx::Size} object contains the horizontal resolution and the y one  the vertical resolution.
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Use of this function is not recommended in the new code as it only works for the primary display. Use {Wx::Display#get_ppi} to retrieve the resolution of the appropriate display instead.
+  # </p>
+  # </div>
+  # @see Wx::Display
+  # @return [Wx::Size]
+  def self.get_display_ppi; end
+  
+  # Returns the display size in pixels.
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Use of this function is not recommended in the new code as it only works for the primary display. Use {Wx::Display#get_geometry} to retrieve the size of the appropriate display instead.
+  # </p>
+  # </div>
+  # @see Wx::Display
+  # @return [Wx::Size]
+  def self.get_display_size; end
+  
+  # Returns the display size in millimeters.
+  # 
+  # 
+  # @see Wx::Display
+  # @return [Wx::Size]
+  def self.get_display_size_mm; end
+  
+  # A {Wx::Point} is a useful data structure for graphics operations.
+  # 
+  # It contains integer x and y members. See {Wx::RealPoint} for a floating point version.
+  # Note that the width and height stored inside a {Wx::Point} object may be negative and that {Wx::Point} functions do not perform any check against negative values (this is used to e.g. store the special -1 value in {Wx::DEFAULT_POSITION} instance).
+  # 
+  # Category:  Data Structures
+  # Predefined objects/pointers: {Wx::DEFAULT_POSITION}
+  # @see Wx::RealPoint 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class Point < ::Object
+  
+    # Returns true if neither of the point components is equal to {Wx::DEFAULT_COORD}.
+    # 
+    # This method is typically used before calling {Wx::Point#set_defaults}.
+    # @return [Boolean]
+    def is_fully_specified; end
+    alias_method :fully_specified?, :is_fully_specified
+    
+    # Combine this object with another one replacing the uninitialized values.
+    # 
+    # It is typically used like this:
+    # 
+    # ```ruby
+    #   if !pos.is_fully_specified
+    #     pos.set_defaults(get_default_position)
+    #   end
+    # ```
+    # @see Wx::Point#is_fully_specified
+    # @param pt [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_defaults(pt) end
+    alias_method :defaults=, :set_defaults
+    
+    # x member.
+    # 
+    # 
+    # @return [Integer]
+    def x; end
+    # x member.
+    # 
+    # 
+    # @param val [Integer]
+    # @return [void]
+    def x=(val); end
+    
+    # y member.
+    # 
+    # 
+    # @return [Integer]
+    def y; end
+    # y member.
+    # 
+    # 
+    # @param val [Integer]
+    # @return [void]
+    def y=(val); end
+    
+    # @overload initialize()
+    #   Constructs a point.
+    #   
+    #   Initializes the internal x and y coordinates to zero.
+    #   @return [Wx::Point]
+    # @overload initialize(x, y)
+    #   Initializes the point object with the given x and y coordinates.
+    #   @param x [Integer] 
+    #   @param y [Integer] 
+    #   @return [Wx::Point]
+    # @overload initialize(pt)
+    #   Converts the given {Wx::RealPoint} (with floating point coordinates) to a {Wx::Point} instance.
+    #   
+    #   Notice that since v3.1.2 the behaviour of this constructor has changed to round the floating point values of pt components, if you want to truncate them instead, please use {Wx::Point.truncate}.
+    #   @param pt [Wx::RealPoint] 
+    #   @return [Wx::Point]
+    def initialize(*args) end
+    
+    # Creates a {Wx::Point} by rounding the coordinates of the given {Wx::RealPoint}.
+    # 
+    # This is equivalent to using the constructor taking {Wx::RealPoint} but is more explicit about the fact that rounding is performed.
+    # @param pt [Wx::RealPoint] 
+    # @return [Wx::Point]
+    def self.round(pt) end
+    
+    # Creates a {Wx::Point} by truncating the coordinates of the given {Wx::RealPoint}.
+    # 
+    # This is similar to {Wx::Point.round} but instead of rounding the coordinates, they are simply truncated to integers.
+    # @param pt [Wx::RealPoint] 
+    # @return [Wx::Point]
+    def self.truncate(pt) end
+    
+  end # Point
+  
+  # A {Wx::Size} is a useful data structure for graphics operations.
+  # 
+  # It simply contains integer x and y members.
+  # Note that the width and height stored inside a {Wx::Size} object may be negative and that {Wx::Size} functions do not perform any check against negative values (this is used to e.g. store the special -1 value in {Wx::DEFAULT_SIZE} instance). See also {Wx::Size#is_fully_specified} and {Wx::Size#set_defaults} for utility functions regarding the special -1 value.
+  # {Wx::Size} is used throughout wxWidgets as well as {Wx::Point} which, although almost equivalent to {Wx::Size}, has a different meaning: {Wx::Point} represents a position while {Wx::Size} represents the size.
+  # 
+  # Category:  Data Structures
+  # Predefined objects/pointers: {Wx::DEFAULT_SIZE}
+  # @see Wx::Point
+  # @see  Wx::RealPoint 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class Size < ::Object
+  
+    # @overload dec_by(pt)
+    #   Decreases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#inc_by 
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [void]
+    # @overload dec_by(size)
+    #   Decreases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#inc_by 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @return [void]
+    # @overload dec_by(dx, dy)
+    #   Decreases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#inc_by 
+    #   @param dx [Integer] 
+    #   @param dy [Integer] 
+    #   @return [void]
+    # @overload dec_by(d)
+    #   Decreases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#inc_by 
+    #   @param d [Integer] 
+    #   @return [void]
+    def dec_by(*args) end
+    
+    # @overload inc_by(pt)
+    #   Increases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#dec_by 
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [void]
+    # @overload inc_by(size)
+    #   Increases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#dec_by 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @return [void]
+    # @overload inc_by(dx, dy)
+    #   Increases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#dec_by 
+    #   @param dx [Integer] 
+    #   @param dy [Integer] 
+    #   @return [void]
+    # @overload inc_by(d)
+    #   Increases the size in both x and y directions.
+    #   
+    #   
+    #   @see Wx::Size#dec_by 
+    #   @param d [Integer] 
+    #   @return [void]
+    def inc_by(*args) end
+    
+    # @overload initialize()
+    #   Initializes this size object with zero width and height.
+    #   @return [Wx::Size]
+    # @overload initialize(width, height)
+    #   Initializes this size object with the given width and height.
+    #   @param width [Integer] 
+    #   @param height [Integer] 
+    #   @return [Wx::Size]
+    def initialize(*args) end
+    
+    # Decrements this object so that both of its dimensions are not greater than the corresponding dimensions of the size.
+    # 
+    # 
+    # @see Wx::Size#inc_to 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def dec_to(size) end
+    
+    # Decrements this object to be not bigger than the given size ignoring non-specified components.
+    # 
+    # This is similar to {Wx::Size#dec_to} but doesn't do anything for x or y component if the same component of size is not specified, i.e. set to {Wx::DEFAULT_COORD}.
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def dec_to_if_specified(size) end
+    
+    # Gets the height member.
+    # @return [Integer]
+    def get_height; end
+    alias_method :height, :get_height
+    
+    # Gets the width member.
+    # @return [Integer]
+    def get_width; end
+    alias_method :width, :get_width
+    
+    # Increments this object so that both of its dimensions are not less than the corresponding dimensions of the size.
+    # 
+    # 
+    # @see Wx::Size#dec_to 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def inc_to(size) end
+    
+    # Returns true if this size is at least as big as the other one in both directions.
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [Boolean]
+    def is_at_least(size) end
+    alias_method :at_least?, :is_at_least
+    
+    # Returns true if either of the size object components is 0 or -1/.
+    # 
+    # Empty {Wx::Size} objects don't define a valid size in the geometric sense.
+    # @see Wx::Rect#is_empty
+    # @return [Boolean]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # Returns true if neither of the size object components is equal to -1, which is used as default for the size values in wxWidgets (hence the predefined {Wx::DEFAULT_SIZE} has both of its components equal to -1).
+    # 
+    # This method is typically used before calling {Wx::Size#set_defaults}.
+    # @return [Boolean]
+    def is_fully_specified; end
+    alias_method :fully_specified?, :is_fully_specified
+    
+    # Scales the dimensions of this object by the given factors.
+    # 
+    # If you want to scale both dimensions by the same factor you can also use {Wx::operator*=()}.
+    # A reference to this object (so that you can concatenate other operations in the same line).
+    # @param xscale [Float] 
+    # @param yscale [Float] 
+    # @return [Wx::Size]
+    def scale(xscale, yscale) end
+    
+    # Sets the width and height members.
+    # @param width [Integer] 
+    # @param height [Integer] 
+    # @return [void]
+    def set(width, height) end
+    
+    # Combine this size object with another one replacing the default (i.e. equal to -1) components of this object with those of the other.
+    # 
+    # It is typically used like this:
+    # 
+    # ```ruby
+    #   if !size.is_fully_specified
+    #     size.set_defaults(get_default_size)
+    #   end
+    # ```
+    # @see Wx::Size#is_fully_specified 
+    # @param sizeDefault [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_defaults(sizeDefault) end
+    alias_method :defaults=, :set_defaults
+    
+    # Sets the height.
+    # @param height [Integer] 
+    # @return [void]
+    def set_height(height) end
+    alias_method :height=, :set_height
+    
+    # Sets the width.
+    # @param width [Integer] 
+    # @return [void]
+    def set_width(width) end
+    alias_method :width=, :set_width
+    
+  end # Size
+  
+  # Represents a rectangle with integer coordinates.
+  # 
+  # x and y members specify the coordinates of the rectangle top-left corner and width and height specify its width and height respectively. The usual C++ semi-open interval convention is used: point p lies inside the rectangle if and only if both conditions below are satisfied: 
+  # ```
+  #   x <= p.x < x + width
+  #   y <= p.y < y + height
+  # ```
+  # 
+  # In other words, the rectangle left and right boundaries are at x and <code>x+width-1</code> and its top and bottom boundaries are at y and <code>y+height-1</code> respectively.
+  # Note that the x and y coordinates may be negative, but width and height are always strictly positive for non-empty rectangles.
+  # 
+  # Category:  Data Structures
+  # @see Wx::Point
+  # @see  Wx::Size 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class Rect < ::Object
+  
+    # Returns the rectangle having the same size as this one but centered relatively to the given rectangle r.
+    # 
+    # By default, rectangle is centred in both directions but if dir includes only {Wx::Orientation::VERTICAL} or only {Wx::Orientation::HORIZONTAL}, then it is only centered in this direction while the other component of its position remains unchanged.
+    # @see Wx::Rect#make_centered_in 
+    # @param r [Wx::Rect] 
+    # @param dir [Integer] 
+    # @return [Wx::Rect]
+    def centre_in(r, dir=Wx::Orientation::BOTH) end
+    
+    # Returns the rectangle having the same size as this one but centered relatively to the given rectangle r.
+    # 
+    # By default, rectangle is centred in both directions but if dir includes only {Wx::Orientation::VERTICAL} or only {Wx::Orientation::HORIZONTAL}, then it is only centered in this direction while the other component of its position remains unchanged.
+    # @see Wx::Rect#make_centered_in 
+    # @param r [Wx::Rect] 
+    # @param dir [Integer] 
+    # @return [Wx::Rect]
+    def center_in(r, dir=Wx::Orientation::BOTH) end
+    
+    # @overload deflate(dx, dy)
+    #   Decrease the rectangle size.
+    #   
+    #   This method is the opposite from {Wx::Rect#inflate}: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to {Wx::Rect#inflate} for full description.
+    #   @param dx [Integer] 
+    #   @param dy [Integer] 
+    #   @return [Wx::Rect]
+    # @overload deflate(diff)
+    #   Decrease the rectangle size.
+    #   
+    #   This method is the opposite from {Wx::Rect#inflate}: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to {Wx::Rect#inflate} for full description.
+    #   @param diff [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Rect]
+    # @overload deflate(diff)
+    #   Decrease the rectangle size.
+    #   
+    #   This method is the opposite from {Wx::Rect#inflate}: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to {Wx::Rect#inflate} for full description.
+    #   @param diff [Integer] 
+    #   @return [Wx::Rect]
+    def deflate(*args) end
+    
+    # @overload inflate(dx, dy)
+    #   Increases the size of the rectangle.
+    #   
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)
+    #   - Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see Wx::Rect#deflate 
+    #   @param dx [Integer] 
+    #   @param dy [Integer] 
+    #   @return [Wx::Rect]
+    # @overload inflate(diff)
+    #   Increases the size of the rectangle.
+    #   
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)
+    #   - Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see Wx::Rect#deflate 
+    #   @param diff [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Rect]
+    # @overload inflate(diff)
+    #   Increases the size of the rectangle.
+    #   
+    #   The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2*dx and 2*dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction.
+    #   Inflating and deflating behaves "naturally". Defined more precisely, that means:
+    #   
+    #   - "Real" inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)
+    #   - Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).
+    #   @see Wx::Rect#deflate 
+    #   @param diff [Integer] 
+    #   @return [Wx::Rect]
+    def inflate(*args) end
+    
+    # Modifies the rectangle to contain the bounding box of this rectangle and the one passed in as parameter.
+    # @param rect [Wx::Rect] 
+    # @return [Wx::Rect]
+    def union(rect) end
+    
+    # @overload initialize()
+    #   Default constructor.
+    #   
+    #   Initializes to zero the internal x, y, width and height members.
+    #   @return [Wx::Rect]
+    # @overload initialize(x, y, width, height)
+    #   Creates a {Wx::Rect} object from x, y, width and height values.
+    #   @param x [Integer] 
+    #   @param y [Integer] 
+    #   @param width [Integer] 
+    #   @param height [Integer] 
+    #   @return [Wx::Rect]
+    # @overload initialize(topLeft, bottomRight)
+    #   Creates a {Wx::Rect} object from top-left and bottom-right points.
+    #   
+    #   The width of the rectangle will be <code>bottomRight.x-topLeft.x+1</code> and the height will be <code>bottomRight.y-topLeft.y+1</code>.
+    #   @param topLeft [Wx::Point] 
+    #   @param bottomRight [Wx::Point] 
+    #   @return [Wx::Rect]
+    # @overload initialize(pos, size)
+    #   Creates a {Wx::Rect} object from position pos and size values.
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Rect]
+    # @overload initialize(size)
+    #   Creates a {Wx::Rect} object from size values at the origin.
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Rect]
+    def initialize(*args) end
+    
+    # @overload contains(x, y)
+    #   Returns true if the given point is inside the rectangle (or on its boundary) and false otherwise.
+    #   @param x [Integer] 
+    #   @param y [Integer] 
+    #   @return [Boolean]
+    # @overload contains(pt)
+    #   Returns true if the given point is inside the rectangle (or on its boundary) and false otherwise.
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [Boolean]
+    # @overload contains(rect)
+    #   Returns true if the given rectangle is completely inside this rectangle (or touches its boundary) and false otherwise.
+    #   @param rect [Wx::Rect] 
+    #   @return [Boolean]
+    def contains(*args) end
+    
+    # Gets the bottom point of the rectangle.
+    # @return [Integer]
+    def get_bottom; end
+    alias_method :bottom, :get_bottom
+    
+    # Gets the position of the bottom left corner.
+    # @return [Wx::Point]
+    def get_bottom_left; end
+    alias_method :bottom_left, :get_bottom_left
+    
+    # Gets the position of the bottom right corner.
+    # @return [Wx::Point]
+    def get_bottom_right; end
+    alias_method :bottom_right, :get_bottom_right
+    
+    # Gets the height member.
+    # @return [Integer]
+    def get_height; end
+    alias_method :height, :get_height
+    
+    # Gets the left point of the rectangle (the same as {Wx::Rect#get_x}).
+    # @return [Integer]
+    def get_left; end
+    alias_method :left, :get_left
+    
+    # Gets the position.
+    # @return [Wx::Point]
+    def get_position; end
+    alias_method :position, :get_position
+    
+    # Gets the right point of the rectangle.
+    # @return [Integer]
+    def get_right; end
+    alias_method :right, :get_right
+    
+    # Gets the size.
+    # 
+    # 
+    # @see Wx::Rect#set_size 
+    # @return [Wx::Size]
+    def get_size; end
+    alias_method :size, :get_size
+    
+    # Gets the top point of the rectangle (the same as {Wx::Rect#get_y}).
+    # @return [Integer]
+    def get_top; end
+    alias_method :top, :get_top
+    
+    # Gets the position of the top left corner of the rectangle, same as {Wx::Rect#get_position}.
+    # @return [Wx::Point]
+    def get_top_left; end
+    alias_method :top_left, :get_top_left
+    
+    # Gets the position of the top right corner.
+    # @return [Wx::Point]
+    def get_top_right; end
+    alias_method :top_right, :get_top_right
+    
+    # Gets the width member.
+    # @return [Integer]
+    def get_width; end
+    alias_method :width, :get_width
+    
+    # Gets the x member.
+    # @return [Integer]
+    def get_x; end
+    alias_method :x, :get_x
+    
+    # Gets the y member.
+    # @return [Integer]
+    def get_y; end
+    alias_method :y, :get_y
+    
+    # Returns the overlapping portion of this rectangle and the one passed in as parameter.
+    # @param rect [Wx::Rect] 
+    # @return [Wx::Rect]
+    def intersect(rect) end
+    
+    # Returns true if this rectangle has a non-empty intersection with the rectangle rect and false otherwise.
+    # @param rect [Wx::Rect] 
+    # @return [Boolean]
+    def intersects(rect) end
+    
+    # Returns true if this rectangle has a width or height less than or equal to 0 and false otherwise.
+    # 
+    # This is equivalent to using <code>Wx::Rect#get_size.Wx::Rect#is_empty</code>.
+    # @see Wx::Size#is_empty 
+    # @return [Boolean]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # Center this rectangle inside the given rectangle r.
+    # 
+    # By default, rectangle is centred in both directions but if dir includes only {Wx::Orientation::VERTICAL} or only {Wx::Orientation::HORIZONTAL}, then it is only centered in this direction while the other component of its position remains unchanged.
+    # @see Wx::Rect#center_in
+    # @param r [Wx::Rect] 
+    # @param dir [Integer] 
+    # @return [void]
+    def make_centered_in(r, dir=Wx::Orientation::BOTH) end
+    
+    # Sets the height.
+    # @param height [Integer] 
+    # @return [void]
+    def set_height(height) end
+    alias_method :height=, :set_height
+    
+    # Sets the position.
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_position(pos) end
+    alias_method :position=, :set_position
+    
+    # Sets the size.
+    # 
+    # 
+    # @see Wx::Rect#get_size 
+    # @param s [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_size(s) end
+    alias_method :size=, :set_size
+    
+    # Sets the width.
+    # @param width [Integer] 
+    # @return [void]
+    def set_width(width) end
+    alias_method :width=, :set_width
+    
+    # Sets the x position.
+    # @param x [Integer] 
+    # @return [void]
+    def set_x(x) end
+    alias_method :x=, :set_x
+    
+    # Sets the y position.
+    # @param y [Integer] 
+    # @return [void]
+    def set_y(y) end
+    alias_method :y=, :set_y
+    
+    # Set the left side of the rectangle.
+    # 
+    # Notice that because the rectangle stores its left side and width, calling {Wx::Rect#set_left} changes the right side position too  but does preserve the width.
+    # @param left [Integer] 
+    # @return [void]
+    def set_left(left) end
+    alias_method :left=, :set_left
+    
+    # Set the right side of the rectangle.
+    # 
+    # Notice that this doesn't affect {Wx::Rect#get_left} return value but changes the rectangle width to set its right side to the given position.
+    # @param right [Integer] 
+    # @return [void]
+    def set_right(right) end
+    alias_method :right=, :set_right
+    
+    # Set the top edge of the rectangle.
+    # 
+    # Notice that because the rectangle stores its top side and height, calling {Wx::Rect#set_top} changes the bottom side position too  but does preserve the height.
+    # @param top [Integer] 
+    # @return [void]
+    def set_top(top) end
+    alias_method :top=, :set_top
+    
+    # Set the bottom edge of the rectangle.
+    # 
+    # Notice that this doesn't affect {Wx::Rect#get_top} return value but changes the rectangle height to set its bottom side to the given position.
+    # @param bottom [Integer] 
+    # @return [void]
+    def set_bottom(bottom) end
+    alias_method :bottom=, :set_bottom
+    
+    # Set the top-left point of the rectangle.
+    # @param p [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_top_left(p) end
+    alias_method :top_left=, :set_top_left
+    
+    # Set the bottom-right point of the rectangle.
+    # @param p [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_bottom_right(p) end
+    alias_method :bottom_right=, :set_bottom_right
+    
+    # Set the top-right point of the rectangle.
+    # @param p [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_top_right(p) end
+    alias_method :top_right=, :set_top_right
+    
+    # Set the bottom-left point of the rectangle.
+    # @param p [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def set_bottom_left(p) end
+    alias_method :bottom_left=, :set_bottom_left
+    
+  end # Rect
+  
+  # A {Wx::RealPoint} is a useful data structure for graphics operations.
+  # 
+  # It contains floating point x and y members. See {Wx::Point} for an integer version.
+  # Note that the coordinates stored inside a {Wx::RealPoint} object may be negative and that {Wx::RealPoint} functions do not perform any check against negative values.
+  # 
+  # Category:  Data Structures
+  # @see Wx::Point 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class RealPoint < ::Object
+  
+    # X coordinate of this point.
+    # 
+    # 
+    # @return [Float]
+    def x; end
+    # X coordinate of this point.
+    # 
+    # 
+    # @param val [Float]
+    # @return [void]
+    def x=(val); end
+    
+    # Y coordinate of this point.
+    # 
+    # 
+    # @return [Float]
+    def y; end
+    # Y coordinate of this point.
+    # 
+    # 
+    # @param val [Float]
+    # @return [void]
+    def y=(val); end
+    
+    # @overload initialize()
+    #   Initializes to zero the x and y members.
+    #   @return [Wx::RealPoint]
+    # @overload initialize(x, y)
+    #   Initializes the point with the given coordinates.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [Wx::RealPoint]
+    # @overload initialize(pt)
+    #   Converts the given {Wx::Point} (with integer coordinates) to a {Wx::RealPoint}.
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [Wx::RealPoint]
+    def initialize(*args) end
+    
+  end # RealPoint
+  
+  # wxWidgets maintains a database of standard RGB colours for a predefined set of named colours.
+  # 
+  # The application may add to this set if desired by using {Wx::ColourDatabase#add_colour} and may use it to look up colours by names using {Wx::ColourDatabase#find} or find the names for the standard colour using {Wx::ColourDatabase#find_name}.
+  # It is also possible to switch between the colour values defined in the CSS standard (see https://www.w3.org/TR/css-color-4/\#named-colors) and the traditional colour values which were used by wxWidgets versions earlier than 3.3.0, which may be useful to preserve the appearance of the existing code: if you need to do this, please call {Wx::ColourDatabase#use_scheme} with Traditional argument, but the use of new, standard colours is recommended.
+  # There is one predefined, global instance of this class called {Wx::TheColourDatabase}.
+  # The standard database contains at least the following colours:
+  # 
+  # AQUAMARINE 
+  # 
+  #  BLACK 
+  # 
+  #  BLUE 
+  # 
+  #  BLUE VIOLET 
+  # 
+  #  BROWN 
+  # 
+  #  CADET BLUE 
+  # 
+  #  CORAL 
+  # 
+  #  CORNFLOWER BLUE 
+  # 
+  #  CYAN 
+  # 
+  #  DARK GREY 
+  # 
+  #  DARK GREEN 
+  # 
+  #  DARK OLIVE GREEN 
+  # 
+  #  DARK ORCHID 
+  # 
+  #  DARK SLATE BLUE 
+  # 
+  #  DARK SLATE GREY 
+  # 
+  #  DARK TURQUOISE 
+  # 
+  #  DIM GREY 
+  # FIREBRICK 
+  # 
+  #  FOREST GREEN 
+  # 
+  #  GOLD 
+  # 
+  #  GOLDENROD 
+  # 
+  #  GREY 
+  # 
+  #  GREEN 
+  # 
+  #  GREEN YELLOW 
+  # 
+  #  INDIAN RED 
+  # 
+  #  KHAKI 
+  # 
+  #  LIGHT BLUE 
+  # 
+  #  LIGHT GREY 
+  # 
+  #  LIGHT STEEL BLUE 
+  # 
+  #  LIME GREEN 
+  # 
+  #  MAGENTA 
+  # 
+  #  MAROON 
+  # 
+  #  MEDIUM AQUAMARINE 
+  # 
+  #  MEDIUM BLUE 
+  # MEDIUM FOREST GREEN 
+  # 
+  #  MEDIUM GOLDENROD 
+  # 
+  #  MEDIUM ORCHID 
+  # 
+  #  MEDIUM SEA GREEN 
+  # 
+  #  MEDIUM SLATE BLUE 
+  # 
+  #  MEDIUM SPRING GREEN 
+  # 
+  #  MEDIUM TURQUOISE 
+  # 
+  #  MEDIUM VIOLET RED 
+  # 
+  #  MIDNIGHT BLUE 
+  # 
+  #  NAVY 
+  # 
+  #  ORANGE 
+  # 
+  #  ORANGE RED 
+  # 
+  #  ORCHID 
+  # 
+  #  PALE GREEN 
+  # 
+  #  PINK 
+  # 
+  #  PLUM 
+  # 
+  #  PURPLE 
+  # RED 
+  # 
+  #  SALMON 
+  # 
+  #  SEA GREEN 
+  # 
+  #  SIENNA 
+  # 
+  #  SKY BLUE 
+  # 
+  #  SLATE BLUE 
+  # 
+  #  SPRING GREEN 
+  # 
+  #  STEEL BLUE 
+  # 
+  #  TAN 
+  # 
+  #  THISTLE 
+  # 
+  #  TURQUOISE 
+  # 
+  #  VIOLET 
+  # 
+  #  VIOLET RED 
+  # 
+  #  WHEAT 
+  # 
+  #  WHITE 
+  # 
+  #  YELLOW 
+  # 
+  #  YELLOW GREEN 
+  # 
+  # See the "Database colours" page of the page_samples_drawing to see how all these colours look like.
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # @see Wx::Colour 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class ColourDatabase < ::Object
+  
+    # Possible colour schemes for {Wx::ColourDatabase#use_scheme}.
+    # 
+    # 
+    # 
+    class Scheme < Wx::Enum
+    
+      # Use CSS standard colours, default since 3.3.0.
+      # 
+      CSS = Wx::ColourDatabase::Scheme.new(0)
+      
+      # Use traditional wxWidgets colours for compatibility.
+      # 
+      Traditional = Wx::ColourDatabase::Scheme.new(1)
+      
+    end # Scheme
+    
+    # Constructs the colour database.
+    # 
+    # It will be initialized at the first use.
+    # @return [Wx::ColourDatabase]
+    def initialize; end
+    
+    # Adds a colour to the database.
+    # 
+    # If a colour with the same name already exists, it is replaced.
+    # @param colourName [String] 
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def add_colour(colourName, colour) end
+    
+    # Finds a colour given the name.
+    # 
+    # Returns an invalid colour object (that is, {Wx::Colour#is_ok} will return false) if the colour wasn't found in the database.
+    # @param colourName [String] 
+    # @return [Wx::Colour]
+    def find(colourName) end
+    
+    # Finds a colour name given the colour.
+    # 
+    # Returns an empty string if the colour is not found in the database.
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [String]
+    def find_name(colour) end
+    
+    # List all known colours by name.
+    # @return [Array<String>]
+    def get_all_names; end
+    alias_method :all_names, :get_all_names
+    
+    # Select the colour scheme to use.
+    # 
+    # By default, {Wx::ColourDatabase} uses CSS scheme which returns the standard values for the colours defined in the CSS specification, see https://www.w3.org/TR/css-color-4/\#named-colors
+    # If preserving compatibility with the behaviour and appearance of the previous wxWidgets versions is important, you may switch to the traditional colour scheme by using this function with Traditional argument, e.g. call
+    # 
+    # ```
+    #   wxTheColourDatabase->UseScheme(wxColourDatabase::Traditional);
+    # ```
+    # 
+    # during the application initialization. Please note that in the previous versions WXGTK already used CSS colour values, unlike all the other ports, so Traditional is not actually backwards compatible for WXGTK, but does make the colour values consistent across all platforms and the same as had been used by WXMSW and WXOSX before. In other words, to obtain 100% compatibility with the previous versions, the {Wx::ColourDatabase#use_scheme} call above should be made for all ports except WXGTK.
+    # Note that the colour names defined only by wxWidgets, which notably includes all colour variants with spaces in their names, are still available in the default CSS colour scheme, with their traditional values but the names of colours defined by CSS standard are taken from it, e.g. "GREEN" corresponds to <code>\#00ff00</code> in the traditional scheme but to <code>\#008000</code> in the CSS scheme. Similarly, CSS colour names that were not defined by the previous wxWidgets versions are available even when using the traditional scheme, the scheme choice only affects the values of the colours defined by both wxWidgets and CSS with different values.
+    # @param scheme [Wx::ColourDatabase::Scheme] 
+    # @return [void]
+    def use_scheme(scheme) end
+    
+  end # ColourDatabase
+  
+
+end