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

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

@@ -0,0 +1,282 @@
+# :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.
+  # 
+  # 
+  # 
+  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
+  
+  # 
+  # 
+  # 
+  # 
+  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.
+  # If {Wx::Setup::USE_UNICODE} is 0, all strings are encoded in the encoding given to Wx::XmlDocument::Load (default is UTF-8).
+  # 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.
+  # 
+  # === 
+  # 
+  # Category:  {Wx::XML}
+  # @see Wx::XmlDocument
+  # @see  Wx::XmlDoctype
+  # @see  Wx::XmlAttribute 
+  # 
+  # 
+  class XmlNode < ::Object
+  
+    # @overload initialize(type, name, content=Wx::EMPTY_STRING, lineNo=-1)
+    #   A simplified version of the first constructor form, assuming a NULL parent.
+    #   @param type [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 [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 NULL 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 [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.
+    # 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.
+    # @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 [true,false]
+    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=Wx::EMPTY_STRING) 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 NULL 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 [true,false]
+    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 NULL 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>"tagnametagcontent/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 NULL 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 [XmlNodeType]
+    def get_type; end
+    alias_method :type, :get_type
+    
+    # Returns true if this node has a attribute named attrName.
+    # @param attrName [String] 
+    # @return [true,false]
+    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.
+    # 
+    # For historical reasons, followingNode may be NULL. 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).
+    # @see Wx::XmlNode#add_child
+    # @see  Wx::XmlNode#insert_child_after 
+    # @param child [Wx::XmlNode] 
+    # @param followingNode [Wx::XmlNode] 
+    # @return [true,false]
+    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 NULL if this node has no children yet  in that case, child will become this node's only child node.
+    # @return [true,false]
+    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 [true,false]
+    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 [true,false] 
+    # @return [void]
+    def set_no_conversion(noconversion) end
+    alias_method :no_conversion=, :set_no_conversion
+    
+    # Sets the type of this node.
+    # @param type [XmlNodeType] 
+    # @return [void]
+    def set_type(type) end
+    alias_method :type=, :set_type
+    
+  end # XmlNode
+  
+
+end

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

@@ -0,0 +1,304 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Flags which can be used with {Wx::XmlResource::XmlResource}.
+  # 
+  # 
+  # 
+  class XmlResourceFlags < Wx::Enum
+  
+    # Translatable strings will be translated via {_}.
+    # 
+    XRC_USE_LOCALE = Wx::XmlResourceFlags.new(1)
+    
+    # Subclass property of object nodes will be ignored (useful for previews in XRC editors).
+    # 
+    XRC_NO_SUBCLASSING = Wx::XmlResourceFlags.new(2)
+    
+    # Prevent the XRC files from being reloaded from disk in case they have been modified there since being last loaded (may slightly speed up loading them).
+    # 
+    XRC_NO_RELOADING = Wx::XmlResourceFlags.new(4)
+    
+    # Expand environment variables for paths in XRC (such as bitmaps or icons).
+    # 
+    XRC_USE_ENVVARS = Wx::XmlResourceFlags.new(8)
+    
+  end # XmlResourceFlags
+  
+  # This is the main class for interacting with the XML-based resource system.
+  # The class holds XML resources from one or more .xml files, binary files or zip archive files.
+  # Note that this is a singleton class and you'll never allocate/deallocate it. Just use the static {Wx::XmlResource.get} getter.
+  # 
+  # === 
+  # 
+  # Category:  XML Based Resource System (XRC)
+  # @see XML Based Resource System (XRC)
+  # @see  XRC File Format
+  # 
+  # 
+  class XmlResource < Object
+  
+    # @overload initialize(filemask, flags=Wx::XRC_USE_LOCALE, domain=Wx::EMPTY_STRING)
+    #   Constructor.
+    #   @param filemask [String]  The XRC file, archive file, or wildcard specification that will be used to load all resource files inside a zip archive.
+    #   @param flags [Integer]  One or more value of the {Wx::XmlResourceFlags} enumeration.
+    #   @param domain [String]  The name of the gettext catalog to search for translatable strings. By default all loaded catalogs will be searched. This provides a way to allow the strings to only come from a specific catalog.
+    #   @return [XmlResource]
+    # @overload initialize(flags=Wx::XRC_USE_LOCALE, domain=Wx::EMPTY_STRING)
+    #   Constructor.
+    #   @param flags [Integer]  One or more value of the {Wx::XmlResourceFlags} enumeration.
+    #   @param domain [String]  The name of the gettext catalog to search for translatable strings. By default all loaded catalogs will be searched. This provides a way to allow the strings to only come from a specific catalog.
+    #   @return [XmlResource]
+    def initialize(*args) end
+    
+    # Attaches an unknown control to the given panel/window/dialog.
+    # Unknown controls are used in conjunction with <object class="unknown">.
+    # @param name [String] 
+    # @param control [Wx::Window] 
+    # @param parent [Wx::Window] 
+    # @return [true,false]
+    def attach_unknown_control(name, control, parent=nil) end
+    
+    # Compares the XRC version to the argument.
+    # Returns -1 if the XRC version is less than the argument, +1 if greater, and 0 if they are equal.
+    # @param major [Integer] 
+    # @param minor [Integer] 
+    # @param release [Integer] 
+    # @param revision [Integer] 
+    # @return [Integer]
+    def compare_version(major, minor, release, revision) end
+    
+    # Returns the domain (message catalog) that will be used to load translatable strings in the XRC.
+    # @return [Wx::String]
+    def get_domain; end
+    alias_method :domain, :get_domain
+    
+    # Returns flags, which may be a bitlist of {Wx::XmlResourceFlags} enumeration values.
+    # @return [Integer]
+    def get_flags; end
+    alias_method :flags, :get_flags
+    
+    # Returns the {Wx::XmlNode} containing the definition of the object with the given name or NULL.
+    # This function recursively searches all the loaded XRC files for an object with the specified name. If the object is found, the {Wx::XmlNode} corresponding to it is returned, so this function can be used to access additional information defined in the XRC file and not used by {Wx::XmlResource} itself, e.g. contents of application-specific XML tags.
+    # 
+    # The node corresponding to the resource with the given name or NULL.
+    # @param name [String]  The name of the resource which must be unique for this function to work correctly, if there is more than one resource with the given name the choice of the one returned by this function is undefined.
+    # @return [Wx::XmlNode]
+    def get_resource_node(name) end
+    alias_method :resource_node, :get_resource_node
+    
+    # Returns version information (a.b.c.d = d + 256*c + 2562*b + 2563*a).
+    # @return [Integer]
+    def get_version; end
+    alias_method :version, :get_version
+    
+    # Initializes handlers for all supported controls/windows.
+    # This will make the executable quite big because it forces linking against most of the wxWidgets library.
+    # @return [void]
+    def init_all_handlers; end
+    
+    # Loads resources from XML files that match given filemask.
+    # Example: 
+    # 
+    #   if (!wxXmlResource::Get()->Load("rc/*.xrc"))
+    #       wxLogError("Couldn't load resources!");
+    # 
+    # If {Wx::USE_FILESYS} is enabled, this method understands {Wx::FileSystem} URLs (see Wx::FileSystem#find_first).
+    # 
+    # If you are sure that the argument is name of single XRC file (rather than an URL or a wildcard), use {Wx::XmlResource#load_file} instead.
+    # @see Wx::XmlResource#load_file
+    # @see  Wx::XmlResource#load_all_files 
+    # @param filemask [String] 
+    # @return [true,false]
+    def load(filemask) end
+    
+    # Simpler form of {Wx::XmlResource#load} for loading a single XRC file.
+    # 
+    # @see Wx::XmlResource#load
+    # @see  Wx::XmlResource#load_all_files
+    # @see  Wx::XmlResource#load_document 
+    # @param file [Wx::FileName] 
+    # @return [true,false]
+    def load_file(file) end
+    
+    # Loads all .xrc files from directory dirname.
+    # Tries to load as many files as possible; if there's an error while loading one file, it still attempts to load other files.
+    # @see Wx::XmlResource#load_file
+    # @see  Wx::XmlResource#load 
+    # @param dirname [String] 
+    # @return [true,false]
+    def load_all_files(dirname) end
+    
+    # Loads a bitmap resource from a file.
+    # @param name [String] 
+    # @return [Wx::Bitmap]
+    def load_bitmap(name) end
+    
+    # Loads a dialog.
+    # parent points to parent window (if any).
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [Wx::Dialog]
+    def load_dialog(parent, name) end
+    
+    # Loads a dialog.
+    # parent points to parent window (if any).
+    # This form is used to finish creation of an already existing instance (the main reason for this is that you may want to use derived class with a new event table). Example:
+    # 
+    #   MyDialog dlg;
+    #   wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
+    #   dlg.ShowModal();
+    # @param dlg [Wx::Dialog] 
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [true,false]
+    def load_dialog_subclass(dlg, parent, name) end
+    
+    # Loads a frame from the resource.
+    # parent points to parent window (if any).
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [Wx::Frame]
+    def load_frame(parent, name) end
+    
+    # Loads the contents of a frame onto an existing {Wx::Frame}.
+    # This form is used to finish creation of an already existing instance (the main reason for this is that you may want to use derived class with a new event table).
+    # @param frame [Wx::Frame] 
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [true,false]
+    def load_frame_subclass(frame, parent, name) end
+    
+    # Loads an icon resource from a file.
+    # @param name [String] 
+    # @return [Wx::Icon]
+    def load_icon(name) end
+    
+    # Loads menu from resource.
+    # Returns NULL on failure.
+    # @param name [String] 
+    # @return [Wx::Menu]
+    def load_menu(name) end
+    
+    # @overload load_menu_bar(parent, name)
+    #   Loads a menubar from resource.
+    #   Returns NULL on failure.
+    #   @param parent [Wx::Window] 
+    #   @param name [String] 
+    #   @return [Wx::MenuBar]
+    # @overload load_menu_bar(name)
+    #   @param name [String] 
+    #   @return [Wx::MenuBar]
+    def load_menu_bar(*args) end
+    
+    # @overload load_object(parent, name, classname)
+    #   Load an object from the resource specifying both the resource name and the class name.
+    #   The first overload lets you load nonstandard container windows and returns NULL on failure. The second one lets you finish the creation of an existing instance and returns false on failure.
+    #   In either case, only the resources defined at the top level of XRC files can be loaded by this function, use {Wx::XmlResource#load_object_recursively} if you need to load an object defined deeper in the hierarchy.
+    #   @param parent [Wx::Window] 
+    #   @param name [String] 
+    #   @param classname [String] 
+    #   @return [Wx::Object]
+    # @overload load_object(instance, parent, name, classname)
+    #   @param instance [Wx::Object] 
+    #   @param parent [Wx::Window] 
+    #   @param name [String] 
+    #   @param classname [String] 
+    #   @return [true,false]
+    def load_object(*args) end
+    
+    # @overload load_object_recursively(parent, name, classname)
+    #   Load an object from anywhere in the resource tree.
+    #   These methods are similar to {Wx::XmlResource#load_object} but may be used to load an object from anywhere in the resource tree and not only the top level. Note that you will very rarely need to do this as in normal use the entire container window (defined at the top level) is loaded and not its individual children but this method can be useful in some particular situations.
+    #   @param parent [Wx::Window] 
+    #   @param name [String] 
+    #   @param classname [String] 
+    #   @return [Wx::Object]
+    # @overload load_object_recursively(instance, parent, name, classname)
+    #   @param instance [Wx::Object] 
+    #   @param parent [Wx::Window] 
+    #   @param name [String] 
+    #   @param classname [String] 
+    #   @return [true,false]
+    def load_object_recursively(*args) end
+    
+    # Loads a panel.
+    # parent points to the parent window.
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [Wx::Panel]
+    def load_panel(parent, name) end
+    
+    # Loads a panel.
+    # parent points to the parent window. This form is used to finish creation of an already existing instance.
+    # @param panel [Wx::Panel] 
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [true,false]
+    def load_panel_subclass(panel, parent, name) end
+    
+    # Loads a toolbar.
+    # @param parent [Wx::Window] 
+    # @param name [String] 
+    # @return [Wx::ToolBar]
+    def load_tool_bar(parent, name) end
+    
+    # Sets the domain (message catalog) that will be used to load translatable strings in the XRC.
+    # @param domain [String] 
+    # @return [void]
+    def set_domain(domain) end
+    alias_method :domain=, :set_domain
+    
+    # Sets flags (bitlist of {Wx::XmlResourceFlags} enumeration values).
+    # @param flags [Integer] 
+    # @return [void]
+    def set_flags(flags) end
+    alias_method :flags=, :set_flags
+    
+    # This function unloads a resource previously loaded by {Wx::XmlResource#load}.
+    # Returns true if the resource was successfully unloaded and false if it hasn't been found in the list of loaded resources.
+    # @param filename [String] 
+    # @return [true,false]
+    def unload(filename) end
+    
+    # Registers subclasses factory for use in XRC.
+    # This is useful only for language bindings developers who need a way to implement subclassing in wxWidgets ports that don't support {Wx::RTTI} (e.g. {Wx::Python}).
+    # @param factory [Wx::XmlSubclassFactory] 
+    # @return [void]
+    def self.add_subclass_factory(factory) end
+    
+    # Returns a string ID corresponding to the given numeric ID.
+    # The string returned is such that calling {Wx::XmlResource.get_xrcid} with it as parameter yields numId. If there is no string identifier corresponding to the given numeric one, an empty string is returned.
+    # Notice that, unlike {Wx::XmlResource.get_xrcid}, this function is slow as it checks all of the identifiers used in XRC.
+    # @param numId [Integer] 
+    # @return [String]
+    def self.find_xrcid_by_id(numId) end
+    
+    # Gets the global resources object or creates one if none exists.
+    # @return [Wx::XmlResource]
+    def self.get; end
+    
+    # Returns a numeric ID that is equivalent to the string ID used in an XML resource.
+    # If an unknown str_id is requested (i.e. other than {Wx::ID_XXX} or integer), a new record is created which associates the given string with a number.
+    # If value_if_not_found is {Wx::StandardID::ID_NONE}, the number is obtained via {new_id}. Otherwise value_if_not_found is used.
+    # Macro <code>XRCID(name)</code> is provided for convenient use in event tables.
+    # IDs returned by XRCID() cannot be used with the <code>EVT_*_RANGE</code> macros, because the order in which they are assigned to symbolic name values is not guaranteed.
+    # @param str_id [String] 
+    # @param value_if_not_found [Integer] 
+    # @return [Integer]
+    def self.get_xrcid(str_id, value_if_not_found=Wx::ID_NONE) end
+    
+    # Sets the global resources object and returns a pointer to the previous one (may be NULL).
+    # @param res [Wx::XmlResource] 
+    # @return [Wx::XmlResource]
+    def self.set(res) end
+    
+  end # XmlResource
+  
+
+end

data/lib/wx/doc/grid/grid.rb

@@ -0,0 +1,20 @@
+
+module Wx::GRID
+
+  GRID_VALUE_STRING = 'string'
+  GRID_VALUE_BOOL = 'bool'
+  GRID_VALUE_NUMBER = 'long'
+  GRID_VALUE_FLOAT = 'double'
+  GRID_VALUE_CHOICE = 'choice'
+  GRID_VALUE_DATE = 'date'
+  GRID_VALUE_TEXT = GRID_VALUE_STRING
+  GRID_VALUE_LONG = GRID_VALUE_NUMBER
+  
+  class Grid
+
+    alias :set_table :assign_table
+    alias :table= :assign_table
+
+  end
+  
+end

data/lib/wx/doc/help_controller.rb

@@ -0,0 +1,14 @@
+
+class Wx::HelpController
+
+  # @return [void] Only does something for Wx::HTML::HtmlHelpController
+  def get_frame_parameters; end
+
+end
+
+class Wx::ExtHelpController
+
+  # @return [void] Only does something for Wx::HTML::HtmlHelpController
+  def get_frame_parameters; end
+
+end

data/lib/wx/doc/html/html_help_controller.rb

@@ -0,0 +1,8 @@
+
+class Wx::HTML::HelpController
+
+  # Returns the latest frame size and position settings and whether a new frame is drawn with each invocation.
+  # @return [Array(Wx::Frame,Wx::Size,Wx::Point,Boolean)] latest frame settings
+  def get_frame_parameters; end
+
+end

data/lib/wx/doc/pg/events.rb

@@ -0,0 +1,15 @@
+
+class Wx::EvtHandler
+
+  # @!group PG Event handler methods
+
+  # Respond to {Wx::PG::EVT_PG_PAGE_CHANGED} event, generated when selected property page has been changed by the user.
+  # Processes a {Wx::PG::EVT_PG_PAGE_CHANGED} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::PG::PropertyGridEvent] event the event to handle
+  def evt_pg_page_changed(id, meth = nil, &block) end
+
+  # @!endgroup
+
+end

data/lib/wx/doc/pg/pg_property.rb

@@ -0,0 +1,8 @@
+
+module Wx::PG
+
+  PG_LABEL = Wx::PG::PG_LABEL_STRING
+
+  PG_DEFAULT_IMAGE_SIZE = Wx::DEFAULT_SIZE
+
+end

data/lib/wx/doc/pg/pgeditor.rb

@@ -0,0 +1,21 @@
+
+module Wx::PG
+
+  # Standard property text editor
+  PG_EDITOR_TEXT_CTRL = Wx::PG::PGEditor.get_standard_editor_class('TextCtrl')
+  # Standard property text editor with custom editor dialog button
+  PG_EDITOR_TEXT_CTRL_AND_BUTTON = Wx::PG::PGEditor.get_standard_editor_class('TextCtrlAndButton')
+  # Standard choice property editor
+  PG_EDITOR_CHOICE = Wx::PG::PGEditor.get_standard_editor_class('Choice')
+  # Standard choice property editor with custom editor dialog button
+  PG_EDITOR_CHOICE_AND_BUTTON = Wx::PG::PGEditor.get_standard_editor_class('ChoiceAndButton')
+  # Standard checkbox property editor
+  PG_EDITOR_CHECK_BOX = Wx::PG::PGEditor.get_standard_editor_class('CheckBox')
+  # Standard combobox property editor
+  PG_EDITOR_COMBO_BOX = Wx::PG::PGEditor.get_standard_editor_class('ComboBox')
+  # Standard spin control property editor
+  PG_EDITOR_SPIN_CTRL = Wx::PG::PGEditor.get_standard_editor_class('SpinCtrl')
+  # Standard date picker property editor
+  PG_EDITOR_DATE_PICKER_CTRL = Wx::PG::PGEditor.get_standard_editor_class('DatePickerCtrl')
+
+end