wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0-x64-mingw-ucrt

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

@@ -24,7 +24,7 @@ module Wx
   # Returns true if between two {begin_busy_cursor} and {end_busy_cursor} calls.
   # 
   # @see Wx::BusyCursor.
-  # @return [true,false]
+  # @return [Boolean]
   def self.is_busy; end
   
   # Ring the system bell.
@@ -50,9 +50,9 @@ module Wx
   # For normal keys, returns true if the specified key is currently down.
   # For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns true if the key is toggled such that its LED indicator is lit. There is currently no way to test whether togglable keys are up or down.
   # Even though there are virtual key codes defined for mouse buttons, they cannot be used with this function currently.
-  # In {Wx::GTK}, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
-  # @param key [KeyCode] 
-  # @return [true,false]
+  # In wxGTK, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
+  # @param key [Wx::KeyCode] 
+  # @return [Boolean]
   def self.get_key_state(key) end
   
   # Returns the mouse position in screen coordinates.
@@ -66,7 +66,7 @@ module Wx
   
   # This function enables or disables all top level windows.
   # It is used by {safe_yield}.
-  # @param enable [true,false] 
+  # @param enable [Boolean] 
   # @return [void]
   def self.enable_top_level_windows(enable=true) end
   
@@ -95,14 +95,17 @@ module Wx
   # @see  execute
   # @param document [String] 
   # @param flags [Integer] 
-  # @return [true,false]
+  # @return [Boolean]
   def self.launch_default_application(document, flags=0) end
   
   # Opens the url in user's default browser.
   # If the flags parameter contains {Wx::BROWSER_NEW_WINDOW} flag, a new window is opened for the URL (currently this is only supported under Windows).
   # And unless the flags parameter contains {Wx::BROWSER_NOBUSYCURSOR} flag, a busy cursor is shown while the browser is being launched (using {Wx::BusyCursor}).
   # The parameter url is interpreted as follows:
-  # - if it has a valid scheme (e.g. <code>"file:"</code>, <code>"http:"</code> or <code>"mailto:"</code>) it is passed to the appropriate browser configured in the user system.- if it has no valid scheme (e.g. it's a local file path without the <code>"file:"</code> prefix), then {Wx::FileExists} and {Wx::DirExists} are used to test if it's a local file/directory; if it is, then the browser is called with the url parameter eventually prefixed by <code>"file:"</code>.- if it has no valid scheme and it's not a local file/directory, then <code>"http:"</code> is prepended and the browser is called.
+  # 
+  # - if it has a valid scheme (e.g. <code>"file:"</code>, <code>"http:"</code> or <code>"mailto:"</code>) it is passed to the appropriate browser configured in the user system.
+  # - if it has no valid scheme (e.g. it's a local file path without the <code>"file:"</code> prefix), then {Wx::FileExists} and {Wx::DirExists} are used to test if it's a local file/directory; if it is, then the browser is called with the url parameter eventually prefixed by <code>"file:"</code>.
+  # - if it has no valid scheme and it's not a local file/directory, then <code>"http:"</code> is prepended and the browser is called.
   # 
   # Returns true if the application was successfully launched.
   # For some configurations of the running user, the application which is launched to open the given URL may be URL-dependent (e.g. a browser may be used for local URLs while another one may be used for remote URLs).
@@ -110,7 +113,7 @@ module Wx
   # @see  execute
   # @param url [String] 
   # @param flags [Integer] 
-  # @return [true,false]
+  # @return [Boolean]
   def self.launch_default_browser(url, flags=0) end
   
   # Copies the user's email address into the supplied buffer, by concatenating the values returned by {get_full_host_name} and {get_user_id}.
@@ -119,7 +122,7 @@ module Wx
   def self.get_email_address; end
   
   # Returns the amount of free memory in bytes under environments which support it, and -1 if not supported or failed to perform measurement.
-  # @return [Wx::MemorySize]
+  # @return [Integer]
   def self.get_free_memory; end
   
   # Return the (current) user's home directory.
@@ -176,19 +179,19 @@ module Wx
   # @param majorVsn [Integer] 
   # @param minorVsn [Integer] 
   # @param microVsn [Integer] 
-  # @return [true,false]
+  # @return [Boolean]
   def self.check_os_version(majorVsn, minorVsn=0, microVsn=0) end
   
   # Returns true if the operating system the program is running under is 64 bit.
   # The check is performed at run-time and may differ from the value available at compile-time (at compile-time you can just check if <code>sizeof(void*) == 8</code>) since the program could be running in emulation mode or in a mixed 32/64 bit system.
   # This function is not 100% reliable on some systems given the fact that there isn't always a standard way to do a reliable check on the OS bitness.
-  # @return [true,false]
+  # @return [Boolean]
   def self.is_platform64bit; end
   
   # Returns true if the current platform is little endian (instead of big endian).
   # The check is performed at run-time.
   # @see Byte Order Functions and Macros
-  # @return [true,false]
+  # @return [Boolean]
   def self.is_platform_little_endian; end
   
   # Returns the CPU architecture name.
@@ -201,7 +204,10 @@ module Wx
   # In some situations the current process and native CPU architecture may be different.
   # This returns the native CPU architecture regardless of the current process CPU architecture.
   # Common examples for CPU architecture differences are the following:
-  # - Win32 process in x64 Windows (WoW)- Win32 or x64 process on ARM64 Windows (WoW64)- x86_64 process on ARM64 macOS (Rosetta 2)
+  # 
+  # - Win32 process in x64 Windows (WoW)
+  # - Win32 or x64 process on ARM64 Windows (WoW64)
+  # - x86_64 process on ARM64 macOS (Rosetta 2)
   # 
   # The returned string may be empty if the CPU architecture couldn't be recognized.
   # @see get_cpu_architecture_name
@@ -213,7 +219,7 @@ module Wx
   # 
   # true on success, false if an error occurred.
   # @param flags [Integer]  One of {Wx::SHUTDOWN_POWEROFF}, {Wx::SHUTDOWN_REBOOT} or {Wx::SHUTDOWN_LOGOFF} (currently implemented only for MSW) possibly combined with {Wx::SHUTDOWN_FORCE} which forces shutdown under MSW by forcefully terminating all the applications. As doing this can result in a data loss, this flag shouldn't be used unless really necessary.
-  # @return [true,false]
+  # @return [Boolean]
   def self.shutdown(flags=Wx::SHUTDOWN_POWEROFF) end
   
 

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

@@ -34,7 +34,7 @@ module Wx
     
     # @overload initialize()
     #   Default constructor, you must call {Wx::VListBox#create} later.
-    #   @return [VListBox]
+    #   @return [Wx::VListBox]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::VListBoxNameStr)
     #   Normal constructor which calls {Wx::VListBox#create} internally.
     #   @param parent [Wx::Window] 
@@ -43,7 +43,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [VListBox]
+    #   @return [Wx::VListBox]
     def initialize(*args) end
     
     # Deletes all items from the control.
@@ -60,7 +60,7 @@ module Wx
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::VListBoxNameStr) end
     
     # Deselects all the items in the listbox.
@@ -68,7 +68,7 @@ module Wx
     # true if any items were changed, i.e. if there had been any selected items before, or false if all the items were already deselected.
     # @see Wx::VListBox#select_all
     # @see  Wx::VListBox#select 
-    # @return [true,false]
+    # @return [Boolean]
     def deselect_all; end
     
     # Get the number of items in the control.
@@ -115,20 +115,20 @@ module Wx
     alias_method :selection_background, :get_selection_background
     
     # Returns true if the listbox was created with {Wx::LB_MULTIPLE} style and so supports multiple selection or false if it is a single selection listbox.
-    # @return [true,false]
+    # @return [Boolean]
     def has_multiple_selection; end
     alias_method :has_multiple_selection?, :has_multiple_selection
     
     # Returns true if this item is the current one, false otherwise.
     # The current item is always the same as selected one for the single selection listbox and in this case this method is equivalent to {Wx::VListBox#is_selected} but they are different for multi selection listboxes where many items may be selected but only one (at most) is current.
     # @param item [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_current(item) end
     alias_method :current?, :is_current
     
     # Returns true if this item is selected, false otherwise.
     # @param item [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_selected(item) end
     alias_method :selected?, :is_selected
     
@@ -137,8 +137,8 @@ module Wx
     # 
     # This function is only valid for the multiple selection listboxes, use {Wx::VListBox#set_selection} for the single selection ones.
     # @param item [Integer] 
-    # @param select [true,false] 
-    # @return [true,false]
+    # @param select [Boolean] 
+    # @return [Boolean]
     def select(item, select=true) end
     
     # Selects all the items in the listbox.
@@ -147,7 +147,7 @@ module Wx
     # This method is only valid for multi selection listboxes.
     # @see Wx::VListBox#deselect_all
     # @see  Wx::VListBox#select 
-    # @return [true,false]
+    # @return [Boolean]
     def select_all; end
     
     # Selects all items in the specified range which may be given in any order.
@@ -158,7 +158,7 @@ module Wx
     # @see  Wx::VListBox#select 
     # @param from [Integer] 
     # @param to [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def select_range(from, to) end
     
     # Set the number of items to be shown in the control.

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

@@ -64,7 +64,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor, you must call {Wx::VScrolledWindow#create} later.
-    #   @return [VScrolledWindow]
+    #   @return [Wx::VScrolledWindow]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PanelNameStr)
     #   This is the normal constructor, no need to call {Wx::VScrolledWindow#create} after using this constructor.
     #   {Wx::VSCROLL} is always automatically added to the style, there is no need to specify it explicitly.
@@ -74,7 +74,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The initial window size.
     #   @param style [Integer]  The window style. There are no special style bits defined for this class.
     #   @param name [String]  The name for this window; usually not used.
-    #   @return [VScrolledWindow]
+    #   @return [Wx::VScrolledWindow]
     def initialize(*args) end
     
     # Same as the non-default constructor, but returns a status code: true if ok, false if the window couldn't be created.
@@ -85,7 +85,7 @@ module Wx
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PanelNameStr) end
     
     # Returns the number of rows the target window contains.
@@ -108,7 +108,7 @@ module Wx
     
     # Returns true if the given row is currently visible (even if only partially visible) or false otherwise.
     # @param row [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_row_visible(row) end
     alias_method :row_visible?, :is_row_visible
     
@@ -125,20 +125,20 @@ module Wx
     
     # Scroll by the specified number of pages which may be positive (to scroll down) or negative (to scroll up).
     # @param pages [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def scroll_row_pages(pages) end
     
     # Scroll by the specified number of rows which may be positive (to scroll down) or negative (to scroll up).
     # true if the window was scrolled, false otherwise (for example, if we're trying to scroll down but we are already showing the last row).
     # @param rows [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def scroll_rows(rows) end
     
     # Scroll to the specified row.
     # It will become the first visible row in the window.
     # true if we scrolled the window, false if nothing was done.
     # @param row [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def scroll_to_row(row) end
     
     # Set the number of rows the window contains.
@@ -165,7 +165,7 @@ module Wx
     
     # With physical scrolling on (when this is true), the device origin is changed properly when a {Wx::PaintDC} is prepared, children are actually moved and laid out properly, and the contents of the window (pixels) are actually moved.
     # When this is false, you are responsible for repainting any invalidated areas of the window yourself to account for the new scroll position.
-    # @param scrolling [true,false] 
+    # @param scrolling [Boolean] 
     # @return [void]
     def enable_physical_scrolling(scrolling=true) end
     
@@ -189,7 +189,7 @@ module Wx
     
     # Returns true if the given scroll unit is currently visible (even if only partially visible) or false otherwise.
     # @param unit [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_visible(unit) end
     alias_method :visible?, :is_visible
     

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

@@ -13,7 +13,9 @@ module Wx
   # {Wx::Validator} is the base class for a family of validator classes that mediate between a class of control, and application data.
   # A validator has three major roles:
   # 
-  # - To transfer data from a C++ variable or own storage to and from a control.- To validate data in a control, and show an appropriate error message.- To filter events (such as keystrokes), thereby changing the behaviour of the associated control.
+  # - To transfer data from a C++ variable or own storage to and from a control.
+  # - To validate data in a control, and show an appropriate error message.
+  # - To filter events (such as keystrokes), thereby changing the behaviour of the associated control.
   # 
   # Validators can be plugged into controls dynamically.
   # To specify a default, "null" validator, use {Wx::DEFAULT_VALIDATOR}.
@@ -32,7 +34,7 @@ module Wx
   class Validator < EvtHandler
   
     # Constructor.
-    # @return [Validator]
+    # @return [Wx::Validator]
     def initialize; end
     
     # Returns the window associated with the validator.
@@ -43,9 +45,9 @@ module Wx
     # Associates a window with the validator.
     # This function is automatically called by wxWidgets when creating a {Wx::Window}-derived class instance which takes a {Wx::Validator} reference. Since wxWidgets 3.1.1, it can be overridden in custom validators in order to perform any one-time initialization or checks of the window when the validator is associated with it.
     # E.g. 
-    # ```
-    #   new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
-    #                  wxTextValidator(wxFILTER_ALPHA, &g_data.m_string));
+    # ```ruby
+    #   Wx::TextCtrl.new(self, Wx::ID_ANY, '', Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 0,
+    #                    Wx::TextValidator.new(Wx::FILTER_ALPHA))
     # ```
     #  will automatically link the {Wx::TextValidator} instance with the {Wx::TextCtrl} instance and call {Wx::Validator#set_window} method on the {Wx::TextValidator} object.
     # @param window [Wx::Window] 
@@ -56,16 +58,16 @@ module Wx
     # This overridable function is called when the value in the associated window must be validated.
     # false if the value in the window is not valid; you may pop up an error dialog.
     # @param parent [Wx::Window]  The parent of the window associated with the validator.
-    # @return [true,false]
+    # @return [Boolean]
     def validate(parent) end
     
     # This functions switches on or turns off the error sound produced by the validators if an invalid key is pressed.
-    # @param suppress [true,false]  If true, error sound is not played when a validator detects an error. If false, error sound is enabled.
+    # @param suppress [Boolean]  If true, error sound is not played when a validator detects an error. If false, error sound is enabled.
     # @return [void]
     def self.suppress_bell_on_error(suppress=true) end
     
     # Returns if the error sound is currently disabled.
-    # @return [true,false]
+    # @return [Boolean]
     def self.is_silent; end
     
   end # Validator

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

@@ -8,92 +8,17 @@ module Wx
 
   # The {Wx::Variant} class represents a container for any type.
   # A variant's value can be changed at run time, possibly to a different type of value.
-  # As of wxWidgets 2.9.1, {Wx::GRID::GridCellAttr::AttrKind::Any} has become the preferred variant class. While most controls still use {Wx::Variant} in their interface, you can start using {Wx::GRID::GridCellAttr::AttrKind::Any} in your code because of an implicit conversion layer. See below for more information.
+  # In wxRuby Wx::Variant is the only available Wx variant class (unlike in C++) and almost exclusively for
+  # use in combination with the property grid classes (see the {Wx::PG} module).
   # 
-  # As standard, {Wx::Variant} can store values of type bool, {Wx::Char}, double, long, string, string list, time, date, void pointer, list of strings, and list of variants. However, an application can extend {Wx::Variant}'s capabilities by deriving from the class {Wx::VariantData} and using the {Wx::VariantData} form of the {Wx::Variant} constructor or assignment operator to assign this data to a variant. Actual values for user-defined types will need to be accessed via the {Wx::VariantData} object, unlike the case for basic data types where convenience functions such as {Wx::Variant#get_long} can be used.
-  # Under Microsoft Windows, three additional {Wx::VariantData}-derived classes  {Wx::VariantDataCurrency}, {Wx::VariantDataErrorCode} and {Wx::VariantDataSafeArray}  are available for interoperation with OLE VARIANT when using {Wx::AutomationObject}.
-  # Pointers to any {Wx::Object} derived class can also easily be stored in a {Wx::Variant}. {Wx::Variant} will then use wxWidgets' built-in RTTI system to set the type name (returned by {Wx::Variant#get_type}) and to perform type-safety checks at runtime.
-  # This class is useful for reducing the programming for certain tasks, such as an editor for different data types, or a remote procedure call protocol.
-  # An optional name member is associated with a {Wx::Variant}. This might be used, for example, in CORBA or OLE automation classes, where named parameters are required.
-  # Note that as of wxWidgets 2.7.1, {Wx::Variant} is reference counted. Additionally, the convenience macros DECLARE_VARIANT_OBJECT() and IMPLEMENT_VARIANT_OBJECT() were added so that adding (limited) support for conversion to and from {Wx::Variant} can be very easily implemented without modifying either {Wx::Variant} or the class to be stored by {Wx::Variant}. Since assignment operators cannot be declared outside the class, the shift left operators are used like this:
+  # By default Wx::Variant can store values of type bool, {Integer}, {Float}, {String}, {Time} (or {Date} / {DateTime}), {Array} of {String}, 
+  # {Array} of {Wx::Variant}, {Wx::Font}, {Wx::Colour} and {Wx::ColourPropertyValue}.
+  # In addition Wx::Variant can store any Ruby {Object}.
   # 
-  # ```
-  #   // in the header file
-  #   DECLARE_VARIANT_OBJECT(MyClass)
-  #   
-  #   // in the implementation file
-  #   IMPLEMENT_VARIANT_OBJECT(MyClass)
-  #   
-  #   // in the user code
-  #   wxVariant variant;
-  #   MyClass value;
-  #   variant << value;
-  #   
-  #   // or
-  #   value << variant;
-  # ```
-  # 
-  # For this to work, MyClass must derive from {Wx::Object}, implement the wxWidgets RTTI system and support the assignment operator and equality operator for itself. Ideally, it should also be reference counted to make copying operations cheap and fast. This can be most easily implemented using the reference counting support offered by {Wx::Object} itself. By default, wxWidgets already implements the shift operator conversion for a few of its drawing related classes:
-  # 
-  # ```
-  #   IMPLEMENT_VARIANT_OBJECT(wxColour)
-  #   IMPLEMENT_VARIANT_OBJECT(wxImage)
-  #   IMPLEMENT_VARIANT_OBJECT(wxIcon)
-  #   IMPLEMENT_VARIANT_OBJECT(wxBitmap)
-  # ```
-  # 
-  # Note that as of wxWidgets 2.9.0, {Wx::VariantData} no longer inherits from {Wx::Object} and {Wx::Variant} no longer uses the type-unsafe {Wx::List} class for list operations but the type-safe {Wx::VariantList} class. Also, {Wx::VariantData} now supports the Wx::VariantData#clone function for implementing the {Wx::Variant#unshare} function. Wx::VariantData#clone is implemented automatically by IMPLEMENT_VARIANT_OBJECT().
-  # Since {Wx::VariantData} no longer derives from {Wx::Object}, any code that tests the type of the data using {dynamic_cast} will require adjustment. You can use the macro {dynamic_cast_variant_data} with the same arguments as {dynamic_cast}, to use C++ RTTI type information instead of wxWidgets RTTI.
-  # 
-  # == wxVariant to wxAny Conversion Layer
-  # 
-  # {Wx::GRID::GridCellAttr::AttrKind::Any} is a more modern, template-based variant class. It is not directly compatible with {Wx::Variant}, but there is a transparent conversion layer.
-  # Following is an example how to use these conversions with {Wx::PG::PropertyGrid}'s property class {Wx::PG::PGProperty} (which currently uses {Wx::Variants} both internally and in the public API):
-  # 
-  # ```
-  #   // Get property value as wxAny instead of wxVariant
-  #   wxAny value = property->GetValue();
-  #   
-  #   // Do something with it
-  #   DoSomethingWithString(value.As<wxString>());
-  #   
-  #   // Write back new value to property
-  #   value = "New Value";
-  #   property->SetValue(value);
-  # ```
-  # 
-  # Some caveats: 
-  # - In {Wx::GRID::GridCellAttr::AttrKind::Any}, there are no separate types for handling integers of different sizes, so converting {Wx::GRID::GridCellAttr::AttrKind::Any} with 'long long' value will yield {Wx::Variant} of "long" type when the value is small enough to fit in without overflow. Otherwise, variant type "longlong" is used. Also note that {Wx::GRID::GridCellAttr::AttrKind::Any} holding unsigned integer will always be converted to "ulonglong" {Wx::Variant} type.
-  # 
-  # - Unlike {Wx::Variant}, {Wx::GRID::GridCellAttr::AttrKind::Any} does not store a (rarely needed) name string.
-  # 
-  # - Because of implicit conversion of {Wx::Variant} to {Wx::GRID::GridCellAttr::AttrKind::Any}, {Wx::GRID::GridCellAttr::AttrKind::Any} cannot usually contain value of type {Wx::Variant}. In other words, any.CheckType<{Wx::Variant}>() can never return true.
-  # 
-  # Supplied conversion functions will automatically work with all built-in {Wx::Variant} types, and also with all user-specified types generated using IMPLEMENT_VARIANT_OBJECT(). For hand-built {Wx::VariantData} classes, you will need to use supplied macros in a following manner:
-  # 
-  # ```
-  #   // Declare wxVariantData for data type Foo
-  #   class wxVariantDataFoo: public wxVariantData
-  #   {
-  #   public:
-  #       // interface
-  #       // ...
-  #   
-  #       DECLARE_WXANY_CONVERSION()
-  #   protected:
-  #       // data storage etc
-  #       // ...
-  #   };
-  #   
-  #   IMPLEMENT_TRIVIAL_WXANY_CONVERSION(Foo, wxVariantDataFoo)
-  # ```
-  # 
-  # === 
-  # 
-  # Category:  Data Structures
-  # @see Wx::VariantData
-  # @see  Wx::GRID::GridCellAttr::AttrKind::Any 
+  # An optional name member is associated with a Wx::Variant.
   # 
+  # In wxRuby Wx::Variant also provides the standard conversion methods #to_i, #to_s and #to_f for supported
+  # value types. In case of incompatible value types these methods will raise a {TypeError} exception.
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
@@ -114,7 +39,7 @@ module Wx
     
     # Deletes the zero-based item from the list.
     # @param item [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def delete(item) end
     
     # Returns the number of elements in the list.
@@ -135,119 +60,119 @@ module Wx
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [String] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [String] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [String] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Integer] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
-    #   @param value [true,false] 
-    #   @return [true,false]
+    #   @param value [Boolean] 
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Float] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Integer] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Integer] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Object] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Wx::Object] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Array<Wx::Variant>] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Array<String>] 
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload ==(value)
     #   Equality test operator.
     #   @param value [Time,Date,DateTime] 
-    #   @return [true,false]
+    #   @return [Boolean]
     def ==(*args) end
     
     # @overload initialize()
     #   Default constructor.
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(data, name=(''))
     #   Constructs a variant directly with a {Wx::VariantData} object.
     #   {Wx::Variant} will take ownership of the {Wx::VariantData} and will not increase its reference count.
     #   @param data [Object] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(variant)
     #   Constructs a variant from another variant by increasing the reference count.
     #   @param variant [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a string.
     #   @param value [String] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a long.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a bool.
-    #   @param value [true,false] 
+    #   @param value [Boolean] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a double.
     #   @param value [Float] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a {Wx::LongLong}.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a {Wx::ULongLong}.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a list of variants.
     #   @param value [Array<Wx::Variant>] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(val, name=(''))
     #   Constructs a variant from a {Wx::DateTime}.
     #   @param val [Time,Date,DateTime] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(val, name=(''))
     #   Constructs a variant from a {Wx::ArrayString}.
     #   @param val [Array<String>] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     def initialize(*args) end
     
     # Returns the string array value.
@@ -256,7 +181,7 @@ module Wx
     alias_method :array_string, :get_array_string
     
     # Returns the boolean value.
-    # @return [true,false]
+    # @return [Boolean]
     def get_bool; end
     alias_method :bool, :get_bool
     
@@ -303,9 +228,21 @@ module Wx
     
     # Returns the value type as a string.
     # The built-in types are:
-    # - "bool"- "char"- "datetime"- "double"- "list"- "long"- "longlong"- "string"- "ulonglong"- "arrstring"- "void*"
     # 
-    # If the variant is null, the value type returned is the string "null" (not the empty string).
+    # - "bool"
+    # - "char"
+    # - "datetime"
+    # - "double"
+    # - "list"
+    # - "long"
+    # - "longlong"
+    # - "string"
+    # - "ulonglong"
+    # - "arrstring"
+    # 
+    # If the variant is null, the value type returned is the string "null" (not the empty string). 
+    #         
+    # If the variant contains an arbitrary Ruby {Object}, the value type returned is the result of `variant.get_object.class.name`.
     # @return [String]
     def get_type; end
     alias_method :type, :get_type
@@ -316,13 +253,13 @@ module Wx
     alias_method :u_long_long, :get_u_long_long
     
     # Returns true if there is no data associated with this variant, false if there is data.
-    # @return [true,false]
+    # @return [Boolean]
     def is_null; end
     alias_method :null?, :is_null
     
     # Returns true if type matches the type of the variant, false otherwise.
     # @param type [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_type(type) end
     alias_method :type?, :is_type
     
@@ -336,12 +273,12 @@ module Wx
     
     # Returns true if value matches an element in the list.
     # @param value [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
-    # @return [true,false]
+    # @return [Boolean]
     def member(value) end
     
     # Makes sure that any data associated with this variant is not shared with other variants.
     # For this to work, Wx::VariantData#clone must be implemented for the data types you are working with. Wx::VariantData#clone is implemented for all the default data types.
-    # @return [true,false]
+    # @return [Boolean]
     def unshare; end
     
   end # Variant