wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

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

@@ -0,0 +1,1108 @@
+# :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_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 {Wx::MSW} 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)
+    
+    # A wait cursor with a standard arrow.
+    # 
+    CURSOR_ARROWWAIT = Wx::StockCursor.new(27)
+    
+    # 
+    # 
+    CURSOR_MAX = Wx::StockCursor.new(28)
+    
+  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 = nil
+  
+  # Global instance of a {Wx::Size} object initialized to (-1,-1).
+  # 
+  DEFAULT_SIZE = nil
+  
+  # Returns true if the display is colour, false otherwise.
+  # 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.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @return [true,false]
+  def self.colour_display; end
+  
+  # Returns the depth of the display (a value of 1 denotes a monochrome display).
+  # 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.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @return [Integer]
+  def self.display_depth; end
+  
+  # Globally sets the cursor; only has an effect on Windows, Mac and GTK+.
+  # You should call this function with {Wx::NULL_CURSOR} to restore the system cursor.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @see Wx::Cursor
+  # @see  Wx::Window#set_cursor
+  # @param cursor [Wx::Cursor] 
+  # @return [void]
+  def self.set_cursor(cursor) 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.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @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.
+  # 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.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @see Wx::Display
+  # @return [Wx::Size]
+  def self.get_display_ppi; end
+  
+  # Returns the display size in pixels.
+  # 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.
+  # 
+  # Include file: #include <wx/gdicmn.h>
+  # @see Wx::Display
+  # @return [Wx::Size]
+  def self.get_display_size; end
+  
+  # Returns the display size in millimeters.
+  # Include file: #include <wx/gdicmn.h>
+  # @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 
+  # 
+  # 
+  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 [true,false]
+    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:
+    # 
+    #   if ( !pos.IsFullySpecified() )
+    #   {
+    #       pos.SetDefaults(GetDefaultPosition());
+    #   }
+    # @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 [Point]
+    # @overload initialize(x, y)
+    #   Initializes the point object with the given x and y coordinates.
+    #   @param x [Integer] 
+    #   @param y [Integer] 
+    #   @return [Point]
+    # @overload initialize(pt)
+    #   Converts the given {Wx::RealPoint} (with floating point coordinates) to a {Wx::Point} instance.
+    #   Notice that this truncates the floating point values of pt components, if you want to round them instead you need to do it manually, e.g. 
+    #   
+    #     #include <wx/math.h>    // for wxRound()
+    #     
+    #     wxRealPoint rp = ...;
+    #     wxPoint p(wxRound(rp.x), wxRound(rp.y));
+    #   @param pt [Wx::RealPoint] 
+    #   @return [Point]
+    def initialize(*args) 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 
+  # 
+  # 
+  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 [Size]
+    # @overload initialize(width, height)
+    #   Initializes this size object with the given width and height.
+    #   @param width [Integer] 
+    #   @param height [Integer] 
+    #   @return [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 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 [true,false]
+    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:
+    # 
+    #   if ( !size.IsFullySpecified() )
+    #   {
+    #       size.SetDefaults(GetDefaultSize());
+    #   }
+    # @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 
+  # 
+  # 
+  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.
+    # @param r [Wx::Rect] 
+    # @param dir [Integer] 
+    # @return [Wx::Rect]
+    def centre_in(r, dir=Wx::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.
+    # @param r [Wx::Rect] 
+    # @param dir [Integer] 
+    # @return [Wx::Rect]
+    def center_in(r, dir=Wx::BOTH) end
+    
+    # @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(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
+    
+    # Moves the rectangle by the specified offset.
+    # If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.
+    # @param pt [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def offset(pt) 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 [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 [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 [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 [Rect]
+    # @overload initialize(size)
+    #   Creates a {Wx::Rect} object from size values at the origin.
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @return [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 [true,false]
+    # @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 [true,false]
+    # @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 [true,false]
+    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 [true,false]
+    def intersects(rect) end
+    
+    # Returns true if this rectangle has a width or height less than or equal to 0 and false otherwise.
+    # @return [true,false]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # 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 
+  # 
+  # 
+  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 [RealPoint]
+    # @overload initialize(x, y)
+    #   Initializes the point with the given coordinates.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [RealPoint]
+    # @overload initialize(pt)
+    #   Converts the given {Wx::Point} (with integer coordinates) to a {Wx::RealPoint}.
+    #   @param pt [Array(Integer, Integer), Wx::Point] 
+    #   @return [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}.
+  # 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  
+  # 
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # @see Wx::Colour 
+  # 
+  # 
+  class ColourDatabase < ::Object
+  
+    # Constructs the colour database.
+    # It will be initialized at the first use.
+    # @return [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
+    
+  end # ColourDatabase
+  
+
+end