wxruby3 1.6.1 → 1.7.0

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

@@ -0,0 +1,253 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # This is convenience class that derives from both {Wx::Control} and {Wx::ItemContainer}.
+  # 
+  # It is used as basis for some wxWidgets controls ({Wx::Choice} and {Wx::ListBox}).
+  # 
+  # Category:  {Wx::Controls}
+  # @see Wx::ItemContainer
+  # @see  Wx::ItemContainerImmutable 
+  # 
+  # 
+  class ControlWithItems < Control
+  
+    # @overload append(item)
+    #   Appends item into the control.
+    #   
+    #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
+    #   @param item [String]  String to add.
+    #   @return [Integer]
+    # @overload append(item, clientData)
+    #   Appends item into the control.
+    #   
+    #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
+    #   @param item [String]  String to add.
+    #   @param clientData [Object]  Pointer to client data to associate with the new item.
+    #   @return [Integer]
+    # @overload append(items)
+    #   Appends several items at once into the control.
+    #   
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @return [Integer]
+    # @overload append(items, clientData)
+    #   Appends several items at once into the control.
+    #   
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [Integer]
+    def append(*args) end
+    
+    # Returns a pointer to the client data associated with the given item (if any).
+    # 
+    # It is an error to call this function for a control which doesn't have typed client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # Notice that the returned pointer is still owned by the control and will be deleted by it, use {Wx::ControlWithItems#detach_client_object} if you want to remove the pointer from the control.
+    # 
+    # A pointer to the client data, or nil if not present.
+    # @param n [Integer]  The zero-based position of the item.
+    # @return [Object]
+    def get_client_object(n) end
+    alias_method :client_object, :get_client_object
+    
+    # Associates the given typed client data pointer with the given item: the data object will be deleted when the item is deleted (either explicitly by using {Wx::ControlWithItems#delete} or implicitly when the control itself is destroyed).
+    # 
+    # Note that it is an error to call this function if any untyped client data pointers had been associated with the control items before.
+    # @param n [Integer]  The zero-based item index.
+    # @param data [Object]  The client data to associate with the item.
+    # @return [void]
+    def set_client_object(n, data) end
+    
+    # @overload insert(item, pos)
+    #   Inserts item into the control.
+    #   
+    #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param item [String]  String to add.
+    #   @param pos [Integer]  Position to insert item before, zero based.
+    #   @return [Integer]
+    # @overload insert(item, pos, clientData)
+    #   Inserts item into the control.
+    #   
+    #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param item [String]  String to add.
+    #   @param pos [Integer]  Position to insert item before, zero based.
+    #   @param clientData [Object]  Pointer to client data to associate with the new item.
+    #   @return [Integer]
+    # @overload insert(items, pos)
+    #   Inserts several items at once into the control.
+    #   
+    #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
+    #   
+    #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @return [Integer]
+    # @overload insert(items, pos, clientData)
+    #   Inserts several items at once into the control.
+    #   
+    #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
+    #   
+    #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [Integer]
+    def insert(*args) end
+    
+    # @overload set(items)
+    #   Replaces the current control contents with the given items.
+    #   
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @return [void]
+    # @overload set(items, clientData)
+    #   Replaces the current control contents with the given items.
+    #   
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [void]
+    def set(*args) end
+    
+    # Removes all items from the control.
+    # 
+    # {Wx::ControlWithItems#clear} also deletes the client data of the existing items if it is owned by the control.
+    # @return [void]
+    def clear; end
+    
+    # Deletes an item from the control.
+    # 
+    # The client data associated with the item will be also deleted if it is owned by the control. Note that it is an error (signalled by an assert failure in debug builds) to remove an item with the index negative or greater or equal than the number of items in the control.
+    # If there is a currently selected item below the item being deleted, i.e. if {Wx::ControlWithItems#get_selection} returns a valid index greater than or equal to n, the selection is invalidated when this function is called. However if the selected item appears before the item being deleted, the selection is preserved unchanged.
+    # @see Wx::ControlWithItems#clear 
+    # @param n [Integer]  The zero-based item index.
+    # @return [void]
+    def delete(n) end
+    
+    # The control may maintain its items in a sorted order in which case items are automatically inserted at the right position when they are inserted or appended.
+    # 
+    # Returns true if the control maintains its items in a sorted order.
+    # @return [Boolean]
+    def is_sorted; end
+    alias_method :sorted?, :is_sorted
+    
+    # Returns the client object associated with the given item and transfers its ownership to the caller.
+    # 
+    # This method, unlike {Wx::ControlWithItems#get_client_object}, expects the caller to delete the returned pointer. It also replaces the internally stored pointer with nil, i.e. completely detaches the client object pointer from the control.
+    # It's an error to call this method unless {Wx::ControlWithItems#has_client_object_data} returns true.
+    # 
+    # The associated client object pointer to be deleted by caller or nil.
+    # @param n [Integer]  The zero-based item index.
+    # @return [Object]
+    def detach_client_object(n) end
+    
+    # Returns true, if either untyped data (<code>void*</code>) or object data ({Wx::ClientData}*) is associated with the items of the control.
+    # @return [Boolean]
+    def has_client_data; end
+    alias_method :has_client_data?, :has_client_data
+    
+    # Returns true, if object data is associated with the items of the control.
+    # 
+    # Object data pointers have the type <code>wxClientData*</code> instead of <code>void*</code> and, importantly, are owned by the control, i.e. will be deleted by it, unlike their untyped counterparts.
+    # @return [Boolean]
+    def has_client_object_data; end
+    alias_method :has_client_object_data?, :has_client_object_data
+    
+    # Returns the number of items in the control.
+    # 
+    # 
+    # @see Wx::ControlWithItems#is_empty 
+    # @return [Integer]
+    def get_count; end
+    alias_method :count, :get_count
+    
+    # Returns true if the control is empty or false if it has some items.
+    # 
+    # 
+    # @see Wx::ControlWithItems#get_count 
+    # @return [Boolean]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+    # Returns the label of the item with the given index.
+    # 
+    # The index must be valid, i.e. less than the value returned by {Wx::ControlWithItems#get_count}, otherwise an assert is triggered. Notably, this function can't be called if the control is empty.
+    # 
+    # The label of the item.
+    # @param n [Integer]  The zero-based index.
+    # @return [String]
+    def get_string(n) end
+    alias_method :string, :get_string
+    
+    # Returns the array of the labels of all items in the control.
+    # @return [Array<String>]
+    def get_strings; end
+    alias_method :strings, :get_strings
+    
+    # Sets the label for the given item.
+    # @param n [Integer]  The zero-based item index.
+    # @param string [String]  The label to set.
+    # @return [void]
+    def set_string(n, string) end
+    
+    # Finds an item whose label matches the given string.
+    # 
+    # The zero-based position of the item, or {Wx::NOT_FOUND} if the string was not found.
+    # @param string [String]  String to find.
+    # @param caseSensitive [Boolean]  Whether search is case sensitive (default is not).
+    # @return [Integer]
+    def find_string(string, caseSensitive=false) end
+    
+    # Sets the selection to the given item n or removes the selection entirely if n == {Wx::NOT_FOUND}.
+    # 
+    # Note that this does not cause any command events to be emitted nor does it deselect any other items in the controls which support multiple selections.
+    # @see Wx::ControlWithItems#set_string
+    # @see  Wx::ControlWithItems#set_string_selection 
+    # @param n [Integer]  The string position to select, starting from zero.
+    # @return [void]
+    def set_selection(n) end
+    alias_method :selection=, :set_selection
+    
+    # Returns the index of the selected item or {Wx::NOT_FOUND} if no item is selected.
+    # 
+    # The position of the current selection.
+    # @see Wx::ControlWithItems#set_selection
+    # @see  Wx::ControlWithItems#get_string_selection 
+    # @return [Integer]
+    def get_selection; end
+    alias_method :selection, :get_selection
+    
+    # Selects the item with the specified string in the control.
+    # 
+    # This method doesn't cause any command events to be emitted.
+    # Notice that this method is case-insensitive, i.e. the string is compared with all the elements of the control case-insensitively and the first matching entry is selected, even if it doesn't have exactly the same case as this string and there is an exact match afterwards.
+    # 
+    # true if the specified string has been selected, false if it wasn't found in the control.
+    # @param string [String]  The string to select.
+    # @return [Boolean]
+    def set_string_selection(string) end
+    alias_method :string_selection=, :set_string_selection
+    
+    # Returns the label of the selected item or an empty string if no item is selected.
+    # 
+    # 
+    # @see Wx::ControlWithItems#get_selection 
+    # @return [String]
+    def get_string_selection; end
+    alias_method :string_selection, :get_string_selection
+    
+    # This is the same as {Wx::ControlWithItems#set_selection} and exists only because it is slightly more natural for controls which support multiple selection.
+    # @param n [Integer] 
+    # @return [void]
+    def select(n) end
+    
+  end # ControlWithItems
+  
+
+end

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

@@ -0,0 +1,45 @@
+# ----------------------------------------------------------------------------
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# ----------------------------------------------------------------------------
+
+
+module Wx
+
+  # wxRuby version string
+  WXRUBY_VERSION = '1.7.0'
+
+  # wxRuby version release type (alpha, beta, rc)
+  WXRUBY_RELEASE_TYPE = ''
+  # wxRuby major version number
+  WXRUBY_MAJOR = 1
+  # wxRuby minor version number
+  WXRUBY_MINOR = 7
+  # wxRuby release number
+  WXRUBY_RELEASE = 0
+
+  # Convenience string for WxWidgets version info
+  WXWIDGETS_VERSION = '3.3.2'
+
+  # Integer constant reflecting the major version of the wxWidgets release used to build wxRuby
+  WXWIDGETS_MAJOR_VERSION = 3
+
+  # Integer constant reflecting the minor version of the wxWidgets release used to build wxRuby
+  WXWIDGETS_MINOR_VERSION = 3
+
+  # Integer constant reflecting the release number of the wxWidgets release used to build wxRuby
+  WXWIDGETS_RELEASE_NUMBER = 2
+
+  # Integer constant reflecting the sub-release number of the wxWidgets release used to build wxRuby
+  WXWIDGETS_SUBRELEASE_NUMBER = 0
+
+  # Integer constant reflecting the wxWidgets wxDEBUG_LEVEL
+  WXWIDGETS_DEBUG_LEVEL = 1
+
+  # Boolean constant indicating if wxRuby was build in debug (true) or release (false) mode
+  DEBUG = false
+
+  # Platform id of the wxWidgets port used to build wxRuby
+  PLATFORM = 'WXGTK'
+
+end

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

@@ -0,0 +1,137 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  EVT_WEBREQUEST_STATE = 10337
+  
+  # 
+  # 
+  EVT_WEBREQUEST_DATA = 10338
+  
+  # This class represents a dialog that requests a user name and a password from the user.
+  # 
+  # Currently it is implemented as a generic wxWidgets dialog on all platforms.
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>For secure saving and loading users and passwords, have a look at {Wx::SecretStore}.
+  # </p>
+  # </div>
+  # 
+  # Category:  Common Dialogs
+  # @see wxCredentialEntryDialog Overview 
+  # 
+  # 
+  # @wxrb_require USE_CREDENTIALDLG
+  class CredentialEntryDialog < Dialog
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   
+    #   Call {Wx::CredentialEntryDialog#create} to really create the dialog later.
+    #   @return [Wx::CredentialEntryDialog]
+    # @overload initialize(parent, message, title, cred=(Wx::WebCredentials.new()))
+    #   Constructor.
+    #   
+    #   Use {Wx::CredentialEntryDialog#show_modal} to show the dialog.
+    #   See {Wx::CredentialEntryDialog#create} method for parameter description.
+    #   @param parent [Wx::Window] 
+    #   @param message [String] 
+    #   @param title [String] 
+    #   @param cred [Wx::WebCredentials] 
+    #   @return [Wx::CredentialEntryDialog]
+    # @overload initialize(parent, message, title, cred=(Wx::WebCredentials.new()), &block)
+    #   Constructor.
+    #   
+    #   Use {Wx::CredentialEntryDialog#show_modal} to show the dialog.
+    #   See {Wx::CredentialEntryDialog#create} method for parameter description.
+    #   @param parent [Wx::Window] 
+    #   @param message [String] 
+    #   @param title [String] 
+    #   @param cred [Wx::WebCredentials] 
+    #   @yieldparam [Wx::CredentialEntryDialog] win new instance
+    #   @return [Wx::CredentialEntryDialog]
+    def initialize(*args) end
+    
+    # Create the dialog constructed using the default constructor.
+    # @param parent [Wx::Window]  Parent window.
+    # @param message [String]  Message to show on the dialog.
+    # @param title [String]  Title of the dialog.
+    # @param cred [Wx::WebCredentials]  The default username and password to use (optional).
+    # @return [Boolean]
+    def create(parent, message, title, cred=(Wx::WebCredentials.new())) end
+    
+    # Returns the credentials entered by the user.
+    # 
+    # This should be called if {Wx::CredentialEntryDialog#show_modal} returned {Wx::StandardID::ID_OK}.
+    # @return [Wx::WebCredentials]
+    def get_credentials; end
+    alias_method :credentials, :get_credentials
+    
+    # Sets the current user name.
+    # 
+    # This function may be called before showing the dialog to provide the default value for the user name, if it's different from the one given at the creation time.
+    # @param user [String] 
+    # @return [void]
+    def set_user(user) end
+    alias_method :user=, :set_user
+    
+    # Sets the current password.
+    # 
+    # This function may be called before showing the dialog for the reasons similar to {Wx::CredentialEntryDialog#set_user}.
+    # @param password [String] 
+    # @return [void]
+    def set_password(password) end
+    alias_method :password=, :set_password
+    
+  end # CredentialEntryDialog
+  
+  # Simple class containing the username and password to use for authenticating.
+  # 
+  # Category:  {Wx::Networking}
+  # @see Wx::WebAuthChallenge 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_CREDENTIALDLG
+  class WebCredentials < ::Object
+  
+    # Create the new credentials object.
+    # 
+    # Note that the password is a {Wx::SecretValue} object, to construct it from a string you need to explicitly use {Wx::SecretValue} ctor.
+    # @param user [String] 
+    # @param password [Wx::SecretValue] 
+    # @return [Wx::WebCredentials]
+    def initialize(user=(''), password=(Wx::SecretValue.new())) end
+    
+    # Return true if user name is set.
+    # 
+    # This can be used to distinguish this object from the default-constructed one.
+    # @return [Boolean]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # Return the user.
+    # @return [Wx::String]
+    def get_user; end
+    alias_method :user, :get_user
+    
+    # Return the password.
+    # 
+    # 
+    # @see Wx::SecretString 
+    # @return [Wx::SecretValue]
+    def get_password; end
+    alias_method :password, :get_password
+    
+  end # WebCredentials
+  
+
+end

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

@@ -0,0 +1,193 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  NULL_CURSOR = nil
+  
+  # A cursor is a small bitmap used for denoting where the mouse pointer is, with a picture that indicates the point of a mouse click.
+  # 
+  # As with icons, cursors in X and MS Windows are created in a different manner. Therefore, separate cursors 
+  # will be created for the different environments. Platform-specific methods for creating a {Wx::Cursor} object 
+  # are catered for, and this is an occasion where conditional compilation will probably be required 
+  # (see {Wx::Icon} for an example).
+  # A single cursor object may be used in many windows (any subwindow type). The wxWidgets convention is to set 
+  # the cursor for a window, as in X, rather than to set it globally as in MS Windows, although a global 
+  # {set_cursor} function is also available for MS Windows use.
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # Predefined objects/pointers:
+  # - {Wx::NULL_CURSOR}
+  # - {Wx::STANDARD_CURSOR}
+  # - {Wx::HOURGLASS_CURSOR}
+  # - {Wx::CROSS_CURSOR}
+  # @see Wx::Bitmap
+  # @see  Wx::Icon
+  # @see  Wx::Window#set_cursor
+  # @see  Wx.set_cursor
+  # @see  Wx::StockCursor
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class Cursor < GDIObject
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Wx::Cursor]
+    # @overload initialize(bitmap, hotSpotX=0, hotSpotY=0)
+    #   Constructs a cursor from the provided bitmap and hotspot position.
+    #   @param bitmap [Wx::Bitmap]  The bitmap to use for the cursor, should be valid.
+    #   @param hotSpotX [Integer]  Hotspot x coordinate (relative to the top left of the image).
+    #   @param hotSpotY [Integer]  Hotspot y coordinate (relative to the top left of the image).
+    #   @return [Wx::Cursor]
+    # @overload initialize(bitmap, hotSpot)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param bitmap [Wx::Bitmap] 
+    #   @param hotSpot [Array(Integer, Integer), Wx::Point] 
+    #   @return [Wx::Cursor]
+    # @overload initialize(cursorName, type=Wx::CURSOR_DEFAULT_TYPE, hotSpotX=0, hotSpotY=0)
+    #   Constructs a cursor by passing a string resource name or filename.
+    #   
+    #   The arguments hotSpotX and hotSpotY are only used when there's no hotspot info in the resource/image-file to load (e.g. when using {Wx::BitmapType::BITMAP_TYPE_ICO} under WXMSW or {Wx::BitmapType::BITMAP_TYPE_XPM} under WXGTK).
+    #   @param cursorName [String]  The name of the resource or the image file to load.
+    #   @param type [Wx::BitmapType]  Icon type to load. It defaults to {Wx::CURSOR_DEFAULT_TYPE}, which is a \#define associated to different values on different platforms:
+    #     
+    #     - under Windows, it defaults to {Wx::BITMAP_TYPE_CUR_RESOURCE}. Other permitted types under Windows are {Wx::BitmapType::BITMAP_TYPE_CUR} (to load a cursor from a .cur cursor file), {Wx::BitmapType::BITMAP_TYPE_ICO} (to load a cursor from a .ico icon file) and {Wx::BitmapType::BITMAP_TYPE_ANI} (to load a cursor from a .ani icon file).
+    #     - under MacOS, it defaults to {Wx::BITMAP_TYPE_MACCURSOR_RESOURCE}; when specifying a string resource name, first a PNG and then a CUR image is searched in resources.
+    #     - under GTK, it defaults to {Wx::BitmapType::BITMAP_TYPE_XPM}. See the wxCursor(const wxImage& image) ctor for more info.
+    #     - under X11, it defaults to {Wx::BitmapType::BITMAP_TYPE_XPM}.
+    #   @param hotSpotX [Integer]  Hotspot x coordinate (relative to the top left of the image).
+    #   @param hotSpotY [Integer]  Hotspot y coordinate (relative to the top left of the image).
+    #   @return [Wx::Cursor]
+    # @overload initialize(name, type, hotSpot)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param name [String] 
+    #   @param type [Wx::BitmapType] 
+    #   @param hotSpot [Array(Integer, Integer), Wx::Point] 
+    #   @return [Wx::Cursor]
+    # @overload initialize(cursorId)
+    #   Constructs a cursor using a cursor identifier.
+    #   @param cursorId [Wx::StockCursor]  A stock cursor identifier. See {Wx::StockCursor}.
+    #   @return [Wx::Cursor]
+    # @overload initialize(image)
+    #   Constructs a cursor from a {Wx::Image}.
+    #   
+    #   If cursor are monochrome on the current platform, colors with the RGB elements all greater than 127 will be foreground, colors less than this background. The mask (if any) will be used to specify the transparent area.
+    #   In WXMSW the foreground will be white and the background black. If the cursor is larger than 32x32 it is resized.
+    #   In WXGTK, colour cursors and alpha channel are supported (starting from GTK+ 2.2). Otherwise the two most frequent colors will be used for foreground and background. In any case, the cursor will be displayed at the size of the image.
+    #   Under WXOSX (Cocoa), large cursors are supported.
+    #   Notice that the image can define the cursor hot spot. To set it you need to use {Wx::Image#set_option} with {Wx::IMAGE_OPTION_CUR_HOTSPOT_X} or {Wx::IMAGE_OPTION_CUR_HOTSPOT_Y}, e.g. 
+    #   ```ruby
+    #     image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX)
+    #     image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotSpotY)
+    #   ```
+    #   @param image [Wx::Image] 
+    #   @return [Wx::Cursor]
+    # @overload initialize(cursor)
+    #   Copy constructor, uses reference counting.
+    #   @param cursor [Wx::Cursor]  Pointer or reference to a cursor to copy.
+    #   @return [Wx::Cursor]
+    def initialize(*args) end
+    
+    # Returns true if cursor data is present.
+    # @return [Boolean]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # Returns the coordinates of the cursor hot spot.
+    # 
+    # The hot spot is the point at which the mouse is actually considered to be when this cursor is used.
+    # This method is currently implemented in WXMSW, WXGTK and WXOSX (since wxWidgets 3.3.0) and returns {Wx::DEFAULT_POSITION} in the other ports.
+    # @return [Wx::Point]
+    def get_hot_spot; end
+    alias_method :hot_spot, :get_hot_spot
+    
+  end # Cursor
+  
+  # A cursor bundle is a set of different versions of the same cursor at different sizes.
+  # 
+  # This class relationship with {Wx::Cursor} is similar to that of {Wx::BitmapBundle} with {Wx::Bitmap}, but it has a simpler interface because cursors are never scaled and always use the closest available size. It is typically used like the following:
+  # 
+  # ```
+  #   MyFrame::MyFrame()
+  #   {
+  #       SetCursorBundle(wxCursorBundle(wxBitmapBundle::FromResources("mycursor"),
+  #                                      wxPoint(1, 1)));
+  #   }
+  # ```
+  # 
+  # Please see {Wx::BitmapBundle} documentation for more information about different ways of creating it.
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class CursorBundle < ::Object
+  
+    # @overload initialize()
+    #   Default ctor constructs an empty bundle.
+    #   
+    #   Such bundle represents the absence of any custom cursor but not an empty cursor ({Wx::StockCursor::CURSOR_BLANK} can be used if this is really needed).
+    #   You can use the assignment operator to set the bundle contents later.
+    #   @return [Wx::CursorBundle]
+    # @overload initialize(bitmaps, hotSpot)
+    #   Create a cursor bundle from the given bitmap bundle.
+    #   @param bitmaps [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image]  The bitmap bundle to use for the cursor, typically containing bitmap in at least two sizes.
+    #   @param hotSpot [Array(Integer, Integer), Wx::Point]  Hotspot coordinates (relative to the top left of the image). The coordinates are relative to the default size of the bitmap bundle and are scaled by wxWidgets for other sizes.
+    #   @return [Wx::CursorBundle]
+    # @overload initialize(bitmaps, hotSpotX=0, hotSpotY=0)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param bitmaps [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    #   @param hotSpotX [Integer] 
+    #   @param hotSpotY [Integer] 
+    #   @return [Wx::CursorBundle]
+    # @overload initialize(other)
+    #   Copy constructor performs a shallow copy of the bundle.
+    #   
+    #   This operation is cheap as it doesn't copy any bitmaps.
+    #   @param other [Wx::CursorBundle] 
+    #   @return [Wx::CursorBundle]
+    def initialize(*args) end
+    
+    # Check if cursor bundle is non-empty.
+    # @return [Boolean]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # Clear the bundle contents.
+    # 
+    # {Wx::CursorBundle#is_ok} will return false after doing this.
+    # Use the assignment operator to set the bundle contents later.
+    # @return [void]
+    def clear; end
+    
+    # Get the cursor of the size suitable for the given window.
+    # @param window [Wx::Window] 
+    # @return [Wx::Cursor]
+    def get_cursor_for(window) end
+    alias_method :cursor_for, :get_cursor_for
+    
+    # Get the cursor of the default size.
+    # 
+    # Prefer to use {Wx::CursorBundle#get_cursor_for} instead if there is a suitable window available, this function only exists as last resort.
+    # @return [Wx::Cursor]
+    def get_cursor_for_main_window; end
+    alias_method :cursor_for_main_window, :get_cursor_for_main_window
+    
+    # Check if two objects refer to the same bundle.
+    # 
+    # Note that this compares the object identity, i.e. this function returns true only for copies of the same bundle, but false for two bundles created from the same bitmap bundle and same hotspot coordinates.
+    # @param other [Wx::CursorBundle] 
+    # @return [Boolean]
+    def is_same_as(other) end
+    alias_method :same_as?, :is_same_as
+    
+  end # CursorBundle
+  
+
+end