wxruby3 1.6.1 → 1.7.0

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

@@ -0,0 +1,88 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::WizardPageSimple} is the simplest possible {Wx::WizardPage} implementation: it just returns the pointers given to its constructor from {Wx::WizardPage#get_next} and {Wx::WizardPage#get_prev} functions.
+  # 
+  # This makes it very easy to use the objects of this class in the wizards where the pages order is known statically - on the other hand, if this is not the case you must derive your own class from {Wx::WizardPage} instead.
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::Wizard
+  # @see  page_samples_wizard 
+  # 
+  # 
+  # @wxrb_require USE_WIZARDDLG
+  class WizardPageSimple < WizardPage
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [Wx::WizardPageSimple]
+    # @overload initialize(parent, prev=nil, next_=nil, bitmap=(Wx::BitmapBundle.new()))
+    #   Constructor takes the previous and next pages.
+    #   
+    #   They may be modified later by {Wx::WizardPageSimple#set_prev} or {Wx::WizardPageSimple#set_next}.
+    #   @param parent [Wx::Wizard] 
+    #   @param prev [Wx::WizardPage] 
+    #   @param next_ [Wx::WizardPage] 
+    #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    #   @return [Wx::WizardPageSimple]
+    # @overload initialize(parent, prev=nil, next_=nil, bitmap=(Wx::BitmapBundle.new()), &block)
+    #   Constructor takes the previous and next pages.
+    #   
+    #   They may be modified later by {Wx::WizardPageSimple#set_prev} or {Wx::WizardPageSimple#set_next}.
+    #   @param parent [Wx::Wizard] 
+    #   @param prev [Wx::WizardPage] 
+    #   @param next_ [Wx::WizardPage] 
+    #   @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    #   @yieldparam [Wx::WizardPageSimple] win new instance
+    #   @return [Wx::WizardPageSimple]
+    def initialize(*args) end
+    
+    # Creates the wizard page.
+    # 
+    # Must be called if the default constructor had been used to create the object.
+    # @param parent [Wx::Wizard] 
+    # @param prev [Wx::WizardPage] 
+    # @param next_ [Wx::WizardPage] 
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    # @return [Boolean]
+    def create(parent=nil, prev=nil, next_=nil, bitmap=(Wx::BitmapBundle.new())) end
+    
+    # A helper chaining this page with the next one.
+    # 
+    # Notice that this method returns a reference to the next page, so the calls to it can, in turn, be chained:
+    # 
+    # ```ruby
+    #   firstPage = FirstPage.new # derived from Wx::WizardPageSimple
+    #   firstPage.chain(SecondPage.new)
+    #              .chain(ThirdPage.new)
+    #              .chain(LastPage.new)
+    # ```
+    # 
+    # This makes this method the simplest way to define the order of changes in fully static wizards, i.e. in those where the order doesn't depend on the choices made by the user in the wizard pages during run-time.
+    # 
+    # Reference to next on which {Wx::WizardPageSimple#chain} can be called again.
+    # @param next_ [Wx::WizardPageSimple] 
+    # @return [Wx::WizardPageSimple]
+    def chain(next_) end
+    
+    # Sets the next page.
+    # @param next_ [Wx::WizardPage] 
+    # @return [void]
+    def set_next(next_) end
+    alias_method :next_=, :set_next
+    
+    # Sets the previous page.
+    # @param prev [Wx::WizardPage] 
+    # @return [void]
+    def set_prev(prev) end
+    alias_method :prev=, :set_prev
+    
+  end # WizardPageSimple
+  
+
+end

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

@@ -0,0 +1,79 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  EXTEND_LAST_ON_EACH_LINE = 1
+  
+  # 
+  # 
+  REMOVE_LEADING_SPACES = 2
+  
+  # 
+  # 
+  WRAPSIZER_DEFAULT_FLAGS = 3
+  
+  # A wrap sizer lays out its items in a single line, like a box sizer  as long as there is space available in that direction.
+  # 
+  # Once all available space in the primary direction has been used, a new line is added and items are added there.
+  # So a wrap sizer has a primary orientation for adding items, and adds lines as needed in the secondary direction.
+  # 
+  # Category:  Window Layout
+  # @see Wx::BoxSizer
+  # @see  Wx::Sizer
+  # @see  Sizers Overview 
+  # 
+  # 
+  class WrapSizer < BoxSizer
+  
+    # @overload initialize(orient=Wx::Orientation::HORIZONTAL, flags=Wx::WRAPSIZER_DEFAULT_FLAGS)
+    #   Constructor for a {Wx::WrapSizer}.
+    #   
+    #   orient determines the primary direction of the sizer (the most common case being {Wx::Orientation::HORIZONTAL}). The flags parameter can be a combination of the values {Wx::EXTEND_LAST_ON_EACH_LINE} which will cause the last item on each line to use any remaining space on that line and {Wx::REMOVE_LEADING_SPACES} which removes any spacer elements from the beginning of a row.
+    #   Both of these flags are on by default.
+    #   @param orient [Integer] 
+    #   @param flags [Integer] 
+    #   @return [Wx::WrapSizer]
+    # @overload initialize(orient=Wx::Orientation::HORIZONTAL, flags=Wx::WRAPSIZER_DEFAULT_FLAGS, &block)
+    #   Constructor for a {Wx::WrapSizer}.
+    #   
+    #   orient determines the primary direction of the sizer (the most common case being {Wx::Orientation::HORIZONTAL}). The flags parameter can be a combination of the values {Wx::EXTEND_LAST_ON_EACH_LINE} which will cause the last item on each line to use any remaining space on that line and {Wx::REMOVE_LEADING_SPACES} which removes any spacer elements from the beginning of a row.
+    #   Both of these flags are on by default.
+    #   @param orient [Integer] 
+    #   @param flags [Integer] 
+    #   @yieldparam [Wx::WrapSizer] sizer new Sizer instance
+    #   @return [Wx::WrapSizer]
+    def initialize(*args) end
+    
+    # Not used by an application.
+    # 
+    # This is the mechanism by which sizers can inform sub-items of the first determined size component. The sub-item can then better determine its size requirements.
+    # Returns true if the information was used (and the sub-item min size was updated).
+    # @param direction [Integer] 
+    # @param size [Integer] 
+    # @param availableOtherDir [Integer] 
+    # @return [Boolean]
+    def inform_first_direction(direction, size, availableOtherDir) end
+    
+    # Method which must be overridden in the derived sizer classes.
+    # 
+    # The implementation should reposition the children using the current total size available to the sizer (m_size) and the size computed by the last call to {Wx::WrapSizer#calc_min}.
+    # @param minSize [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def reposition_children(minSize) end
+    
+    # Implements the calculation of a box sizer's minimal.
+    # 
+    # It is used internally only and must not be called by the user. Documented for information.
+    # @return [Wx::Size]
+    def calc_min; end
+    
+  end # WrapSizer
+  
+
+end

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

@@ -0,0 +1,316 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  XML_NO_INDENTATION = -1
+  
+  # Represents XML node type.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_XML
+  class XmlNodeType < Wx::Enum
+  
+    # 
+    # 
+    XML_ELEMENT_NODE = Wx::XmlNodeType.new(1)
+    
+    # 
+    # 
+    XML_ATTRIBUTE_NODE = Wx::XmlNodeType.new(2)
+    
+    # 
+    # 
+    XML_TEXT_NODE = Wx::XmlNodeType.new(3)
+    
+    # 
+    # 
+    XML_CDATA_SECTION_NODE = Wx::XmlNodeType.new(4)
+    
+    # 
+    # 
+    XML_ENTITY_REF_NODE = Wx::XmlNodeType.new(5)
+    
+    # 
+    # 
+    XML_ENTITY_NODE = Wx::XmlNodeType.new(6)
+    
+    # 
+    # 
+    XML_PI_NODE = Wx::XmlNodeType.new(7)
+    
+    # 
+    # 
+    XML_COMMENT_NODE = Wx::XmlNodeType.new(8)
+    
+    # 
+    # 
+    XML_DOCUMENT_NODE = Wx::XmlNodeType.new(9)
+    
+    # 
+    # 
+    XML_DOCUMENT_TYPE_NODE = Wx::XmlNodeType.new(10)
+    
+    # 
+    # 
+    XML_DOCUMENT_FRAG_NODE = Wx::XmlNodeType.new(11)
+    
+    # 
+    # 
+    XML_NOTATION_NODE = Wx::XmlNodeType.new(12)
+    
+    # 
+    # 
+    XML_HTML_DOCUMENT_NODE = Wx::XmlNodeType.new(13)
+    
+  end # XmlNodeType
+  
+  # 
+  # 
+  # 
+  # 
+  # @wxrb_require USE_XML
+  class XmlDocumentLoadFlag < Wx::Enum
+  
+    # 
+    # 
+    XMLDOC_NONE = Wx::XmlDocumentLoadFlag.new(0)
+    
+    # 
+    # 
+    XMLDOC_KEEP_WHITESPACE_NODES = Wx::XmlDocumentLoadFlag.new(1)
+    
+  end # XmlDocumentLoadFlag
+  
+  # Represents a node in an XML document.
+  # 
+  # See {Wx::XmlDocument}.
+  # Each node is named and depending on the node type it may also hold content or be given attributes.
+  # The two most common node types are {Wx::XmlNodeType::XML_ELEMENT_NODE} and {Wx::XmlNodeType::XML_TEXT_NODE}. {Wx::XmlNodeType::XML_ELEMENT_NODE} represents a pair of XML element tags, whilst {Wx::XmlNodeType::XML_TEXT_NODE} represents the text value that can belong to the element.
+  # A {Wx::XmlNodeType::XML_ELEMENT_NODE} has a title, and optionally attributes, but does not have any content. A {Wx::XmlNodeType::XML_TEXT_NODE} does not have a title or attributes but should normally have content.
+  # For example: in the XML fragment <code><title>hi</title></code> there is an element node with the name title and a single text node child with the text hi as content.
+  # A {Wx::XmlNodeType::XML_PI_NODE} represents a Processing Instruction (PI) node with the name parameter set as the target and the contents parameter set as the instructions. Note that whilst the PI instructions are often in the form of pseudo-attributes, these do not use the node's attribute member. It is the user's responsibility to code and decode the PI instruction text.
+  # The {Wx::XmlNodeType::XML_DOCUMENT_TYPE_NODE} is not implemented at this time. Instead, you should get and set the DOCTYPE values using the {Wx::XmlDocument} class.
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Once a {Wx::XmlNode} has been added to a {Wx::XmlDocument} it becomes owned by the document and this has two implications. Firstly, the {Wx::XmlDocument} takes responsibility for deleting the node so the user should not delete it; and secondly, a {Wx::XmlNode} must always be created on the heap and never on the stack.
+  # </p>
+  # </div>
+  # 
+  # Category:  {Wx::XML}
+  # @see Wx::XmlDocument
+  # @see  Wx::XmlDoctype
+  # @see  Wx::XmlAttribute 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_XML
+  class XmlNode < ::Object
+  
+    # @overload initialize(type, name, content=(''), lineNo=-1)
+    #   A simplified version of the first constructor form, assuming a nil parent.
+    #   @param type [Wx::XmlNodeType]  One of the {Wx::XmlNodeType} enumeration value.
+    #   @param name [String]  The name of the node. This is the string which appears between angular brackets.
+    #   @param content [String]  The content of the node. Only meaningful when type is {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
+    #   @param lineNo [Integer]  Number of line this node was present at in input file or -1.
+    #   @return [Wx::XmlNode]
+    # @overload initialize(node)
+    #   Copy constructor.
+    #   
+    #   Note that this does NOT copy siblings and parent pointer, i.e. {Wx::XmlNode#get_parent} and {Wx::XmlNode#get_next} will return nil after using copy ctor and are never unmodified by {Wx::operator=()}. On the other hand, it DOES copy children and attributes.
+    #   @param node [Wx::XmlNode] 
+    #   @return [Wx::XmlNode]
+    def initialize(*args) end
+    
+    # Appends an attribute with given name and value to the list of attributes for this node.
+    # @param name [String] 
+    # @param value [String] 
+    # @return [void]
+    def add_attribute(name, value) end
+    
+    # Adds node child as the last child of this node.
+    # 
+    # Once added, the XML tree takes ownership of this object and there is no need to delete it.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Note that this function works in O(n) time where n is the number of existing children. Consequently, adding large number of child nodes using this method can be expensive, because it has O(n^2) time complexity in number of nodes to be added. Use {Wx::XmlNode#insert_child_after} to populate XML tree in linear time.
+    # </p>
+    # </div>
+    # @see Wx::XmlNode#insert_child
+    # @see  Wx::XmlNode#insert_child_after 
+    # @param child [Wx::XmlNode] 
+    # @return [void]
+    def add_child(child) end
+    
+    # Removes the first attributes which has the given name from the list of attributes for this node.
+    # @param name [String] 
+    # @return [Boolean]
+    def delete_attribute(name) end
+    
+    # Returns the value of the attribute named attrName if it does exist.
+    # 
+    # If it does not exist, the defaultVal is returned.
+    # @param attrName [String] 
+    # @param defaultVal [String] 
+    # @return [String]
+    def get_attribute(attrName, defaultVal=('')) end
+    alias_method :attribute, :get_attribute
+    
+    # Returns the first child of this node.
+    # 
+    # To get a pointer to the second child of this node (if it does exist), use the {Wx::XmlNode#get_next} function on the returned value.
+    # @return [Wx::XmlNode]
+    def get_children; end
+    alias_method :children, :get_children
+    
+    # Returns the content of this node.
+    # 
+    # Can be an empty string. Be aware that for nodes of type {Wx::XmlNodeType::XML_ELEMENT_NODE} (the most used node type) the content is an empty string. See {Wx::XmlNode#get_node_content} for more details.
+    # @return [Wx::String]
+    def get_content; end
+    alias_method :content, :get_content
+    
+    # Returns the number of nodes which separate this node from grandparent.
+    # 
+    # This function searches only the parents of this node until it finds grandparent or the nil node (which is the parent of non-linked nodes or the parent of a {Wx::XmlDocument}'s root element node).
+    # @param grandparent [Wx::XmlNode] 
+    # @return [Integer]
+    def get_depth(grandparent=nil) end
+    alias_method :depth, :get_depth
+    
+    # Returns a flag indicating whether encoding conversion is necessary when saving.
+    # 
+    # The default is false.
+    # You can improve saving efficiency considerably by setting this value.
+    # @return [Boolean]
+    def get_no_conversion; end
+    alias_method :no_conversion, :get_no_conversion
+    
+    # Returns line number of the node in the input XML file or <code>-1</code> if it is unknown.
+    # @return [Integer]
+    def get_line_number; end
+    alias_method :line_number, :get_line_number
+    
+    # Returns the name of this node.
+    # 
+    # Can be an empty string (e.g. for nodes of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}).
+    # @return [Wx::String]
+    def get_name; end
+    alias_method :name, :get_name
+    
+    # Returns a pointer to the sibling of this node or nil if there are no siblings.
+    # @return [Wx::XmlNode]
+    def get_next; end
+    alias_method :next_, :get_next
+    
+    # Returns the content of the first child node of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}.
+    # 
+    # This function is very useful since the XML snippet <code>"<tagname>tagcontent</tagname>"</code> is represented by expat with the following tag tree:
+    # 
+    # ```
+    #   wxXML_ELEMENT_NODE name="tagname", content=""
+    #   |-- wxXML_TEXT_NODE name="", content="tagcontent"
+    # ```
+    # 
+    # or eventually:
+    # 
+    # ```
+    #   wxXML_ELEMENT_NODE name="tagname", content=""
+    #   |-- wxXML_CDATA_SECTION_NODE name="", content="tagcontent"
+    # ```
+    # 
+    # An empty string is returned if the node has no children of type {Wx::XmlNodeType::XML_TEXT_NODE} or {Wx::XmlNodeType::XML_CDATA_SECTION_NODE}, or if the content of the first child of such types is empty.
+    # @return [String]
+    def get_node_content; end
+    alias_method :node_content, :get_node_content
+    
+    # Returns a pointer to the parent of this node or nil if this node has no parent.
+    # @return [Wx::XmlNode]
+    def get_parent; end
+    alias_method :parent, :get_parent
+    
+    # Returns the type of this node.
+    # @return [Wx::XmlNodeType]
+    def get_type; end
+    alias_method :type, :get_type
+    
+    # Returns true if this node has a attribute named attrName.
+    # @param attrName [String] 
+    # @return [Boolean]
+    def has_attribute(attrName) end
+    alias_method :has_attribute?, :has_attribute
+    
+    # Inserts the child node immediately before followingNode in the children list.
+    # 
+    # Once inserted, the XML tree takes ownership of the new child and there is no need to delete it.
+    # true if followingNode has been found and the child node has been inserted.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>For historical reasons, followingNode may be nil. In that case, then child is prepended to the list of children and becomes the first child of this node, i.e. it behaves identically to using the first children (as returned by {Wx::XmlNode#get_children}) for followingNode).
+    # </p>
+    # </div>
+    # @see Wx::XmlNode#add_child
+    # @see  Wx::XmlNode#insert_child_after 
+    # @param child [Wx::XmlNode] 
+    # @param followingNode [Wx::XmlNode] 
+    # @return [Boolean]
+    def insert_child(child, followingNode) end
+    
+    # Inserts the child node immediately after precedingNode in the children list.
+    # 
+    # Once inserted, the XML tree takes ownership of the new child and there is no need to delete it.
+    # true if precedingNode has been found and the child node has been inserted.
+    # @see Wx::XmlNode#insert_child
+    # @see  Wx::XmlNode#add_child 
+    # @param child [Wx::XmlNode]  The child to insert.
+    # @param precedingNode [Wx::XmlNode]  The node to insert child after. As a special case, this can be nil if this node has no children yet  in that case, child will become this node's only child node.
+    # @return [Boolean]
+    def insert_child_after(child, precedingNode) end
+    
+    # Returns true if the content of this node is a string containing only whitespaces (spaces, tabs, new lines, etc).
+    # 
+    # Note that this function is locale-independent since the parsing of XML documents must always produce the exact same tree regardless of the locale it runs under.
+    # @return [Boolean]
+    def is_whitespace_only; end
+    alias_method :whitespace_only?, :is_whitespace_only
+    
+    # Sets the content of this node.
+    # @param con [String] 
+    # @return [void]
+    def set_content(con) end
+    alias_method :content=, :set_content
+    
+    # Sets the name of this node.
+    # @param name [String] 
+    # @return [void]
+    def set_name(name) end
+    alias_method :name=, :set_name
+    
+    # Sets a flag to indicate whether encoding conversion is necessary when saving.
+    # 
+    # The default is false.
+    # You can improve saving efficiency considerably by setting this value.
+    # @param noconversion [Boolean] 
+    # @return [void]
+    def set_no_conversion(noconversion) end
+    alias_method :no_conversion=, :set_no_conversion
+    
+    # Sets the type of this node.
+    # @param type [Wx::XmlNodeType] 
+    # @return [void]
+    def set_type(type) end
+    alias_method :type=, :set_type
+    
+  end # XmlNode
+  
+
+end