wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

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

@@ -0,0 +1,340 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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.
+  # 
+  # 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:
+  # 
+  #   // 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 
+  # 
+  # 
+  class Variant < Object
+  
+    # Appends a value to the list.
+    # @param value [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
+    # @return [void]
+    def append(value) end
+    
+    # Makes the variant null by deleting the internal data and set the name to {Wx::EmptyString}.
+    # @return [void]
+    def clear; end
+    
+    # Deletes the contents of the list.
+    # @return [void]
+    def clear_list; end
+    
+    # Deletes the zero-based item from the list.
+    # @param item [Integer] 
+    # @return [true,false]
+    def delete(item) end
+    
+    # Returns the number of elements in the list.
+    # @return [Integer]
+    def get_count; end
+    alias_method :count, :get_count
+    
+    # Inserts a value at the front of the list.
+    # @param value [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
+    # @return [void]
+    def insert(value) end
+    
+    # Makes an empty list.
+    # This differs from a null variant which has no data; a null list is of type list, but the number of elements in the list is zero.
+    # @return [void]
+    def null_list; end
+    
+    # @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]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [String] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [String] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [String] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Integer] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [true,false] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Float] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Integer] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Integer] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Object] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Wx::Object] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Array<Wx::Variant>] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Array<String>] 
+    #   @return [true,false]
+    # @overload ==(value)
+    #   Equality test operator.
+    #   @param value [Time,Date,DateTime] 
+    #   @return [true,false]
+    def ==(*args) end
+    
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Variant]
+    # @overload initialize(data, name=Wx::EMPTY_STRING)
+    #   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]
+    # @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]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a string.
+    #   @param value [String] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a long.
+    #   @param value [Integer] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a bool.
+    #   @param value [true,false] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a double.
+    #   @param value [Float] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a {Wx::LongLong}.
+    #   @param value [Integer] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a {Wx::ULongLong}.
+    #   @param value [Integer] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(value, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a list of variants.
+    #   @param value [Array<Wx::Variant>] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(val, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a {Wx::DateTime}.
+    #   @param val [Time,Date,DateTime] 
+    #   @param name [String] 
+    #   @return [Variant]
+    # @overload initialize(val, name=Wx::EMPTY_STRING)
+    #   Constructs a variant from a {Wx::ArrayString}.
+    #   @param val [Array<String>] 
+    #   @param name [String] 
+    #   @return [Variant]
+    def initialize(*args) end
+    
+    # Returns the string array value.
+    # @return [Array<String>]
+    def get_array_string; end
+    alias_method :array_string, :get_array_string
+    
+    # Returns the boolean value.
+    # @return [true,false]
+    def get_bool; end
+    alias_method :bool, :get_bool
+    
+    # Returns the character value.
+    # @return [String]
+    def get_char; end
+    alias_method :char, :get_char
+    
+    # Returns a pointer to the internal variant data.
+    # To take ownership of this data, you must call its Wx::VariantData#inc_ref method. When you stop using it, Wx::VariantData#dec_ref must be called as well.
+    # @return [Object]
+    def get_object; end
+    alias_method :object, :get_object
+    
+    # Returns the date value.
+    # @return [Time,Date,DateTime]
+    def get_date_time; end
+    alias_method :date_time, :get_date_time
+    
+    # Returns the floating point value.
+    # @return [Float]
+    def get_double; end
+    alias_method :double, :get_double
+    
+    # Returns the integer value.
+    # @return [Integer]
+    def get_long; end
+    alias_method :long, :get_long
+    
+    # Returns the signed 64-bit integer value.
+    # @return [Integer]
+    def get_long_long; end
+    alias_method :long_long, :get_long_long
+    
+    # Returns a constant reference to the variant name.
+    # @return [Wx::String]
+    def get_name; end
+    alias_method :name, :get_name
+    
+    # Gets the string value.
+    # @return [String]
+    def get_string; end
+    alias_method :string, :get_string
+    
+    # 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).
+    # @return [String]
+    def get_type; end
+    alias_method :type, :get_type
+    
+    # Returns the unsigned 64-bit integer value.
+    # @return [Integer]
+    def get_u_long_long; end
+    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]
+    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]
+    def is_type(type) end
+    alias_method :type?, :is_type
+    
+    # Makes the variant null by deleting the internal data.
+    # @return [void]
+    def make_null; end
+    
+    # Makes a string representation of the variant value (for any type).
+    # @return [String]
+    def make_string; end
+    
+    # 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]
+    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]
+    def unshare; end
+    
+  end # Variant
+  
+
+end