wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

data/lib/wx/doc/gen/html/html_window.rb

@@ -0,0 +1,386 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::HTML
+
+  # 
+  # 
+  # 
+  # 
+  class HtmlURLType < Wx::Enum
+  
+    # 
+    # 
+    HTML_URL_PAGE = Wx::HTML::HtmlURLType.new(0)
+    
+    # 
+    # 
+    HTML_URL_IMAGE = Wx::HTML::HtmlURLType.new(1)
+    
+    # 
+    # 
+    HTML_URL_OTHER = Wx::HTML::HtmlURLType.new(2)
+    
+  end # HtmlURLType
+  
+  # 
+  HW_SCROLLBAR_NEVER = 2
+  
+  # 
+  HW_SCROLLBAR_AUTO = 4
+  
+  # 
+  HW_NO_SELECTION = 8
+  
+  # 
+  HW_DEFAULT_STYLE = 4
+  
+  # Enum for {Wx::HTML::HtmlWindow#on_opening_url} and Wx::HtmlWindowInterface::OnOpeningURL.
+  # 
+  # 
+  # 
+  class HtmlOpeningStatus < Wx::Enum
+  
+    # Open the requested URL.
+    # 
+    HTML_OPEN = Wx::HTML::HtmlOpeningStatus.new(0)
+    
+    # Do not open the URL.
+    # 
+    HTML_BLOCK = Wx::HTML::HtmlOpeningStatus.new(1)
+    
+    # Redirect to another URL (returned from OnOpeningURL)
+    # 
+    HTML_REDIRECT = Wx::HTML::HtmlOpeningStatus.new(2)
+    
+  end # HtmlOpeningStatus
+  
+  # 
+  # 
+  EVT_HTML_CELL_CLICKED = 10348
+  
+  # 
+  # 
+  EVT_HTML_CELL_HOVER = 10349
+  
+  # 
+  # 
+  EVT_HTML_LINK_CLICKED = 10350
+  
+  # {Wx::HTML::HtmlWindow} is probably the only class you will directly use unless you want to do something special (like adding new tag handlers or MIME filters).
+  # The purpose of this class is to display rich content pages (either local file or downloaded via HTTP protocol) in a window based on a subset of the HTML standard. The width of the window is constant, given in the constructor and virtual height is changed dynamically depending on page size. Once the window is created you can set its content by calling {Wx::HTML::HtmlWindow#set_page} with raw HTML, {Wx::HTML::HtmlWindow#load_page} with a {Wx::FileSystem} location or {Wx::HTML::HtmlWindow#load_file} with a filename.
+  # If you want complete HTML/CSS support as well as a Javascript engine, consider using {Wx::WebView} instead.
+  # 
+  # {Wx::HTML::HtmlWindow} uses the {Wx::Image} class for displaying images, so you need to initialize the handlers for any image formats you use before loading a page. See {Wx::InitAllImageHandlers} and {Wx::Image.add_handler}.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::HTML::HW_SCROLLBAR_NEVER}: Never display scrollbars, not even when the page is larger than the window. 
+  # - {Wx::HTML::HW_SCROLLBAR_AUTO}: Display scrollbars only if page's size exceeds window's size. 
+  # - {Wx::HTML::HW_NO_SELECTION}: Don't allow the user to select text. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::HTML::HtmlLinkEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_html_cell_clicked}(id, meth = nil, &block): A {Wx::HTML::HtmlCell} was clicked. 
+  # - {Wx::EvtHandler#evt_html_cell_hover}(id, meth = nil, &block): The mouse passed over a {Wx::HTML::HtmlCell}. 
+  # - {Wx::EvtHandler#evt_html_link_clicked}(id, meth = nil, &block): A {Wx::HTML::HtmlCell} which contains a hyperlink was clicked. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::HTML}
+  # @see Wx::HTML::HtmlLinkEvent
+  # @see  Wx::HTML::HtmlCellEvent 
+  # 
+  # 
+  class HtmlWindow < ScrolledWindow
+  
+    # @overload initialize()
+    #   Default ctor.
+    #   @return [HtmlWindow]
+    # @overload initialize(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HW_DEFAULT_STYLE, name=("Wx::HTML_WINDOW"))
+    #   Constructor.
+    #   The parameters are the same as Wx::Scrolled#initialize constructor.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [HtmlWindow]
+    def initialize(*args) end
+    
+    # Appends HTML fragment to currently displayed text and refreshes the window.
+    # false if an error occurred, true otherwise.
+    # @param source [String]  HTML code fragment
+    # @return [true,false]
+    def append_to_page(source) end
+    
+    # Returns pointer to the top-level container.
+    # 
+    # @see Cells and Containers
+    # @see  Printing Framework Overview 
+    # @return [Wx::HtmlContainerCell]
+    def get_internal_representation; end
+    alias_method :internal_representation, :get_internal_representation
+    
+    # Returns anchor within currently opened page (see {Wx::HTML::HtmlWindow#get_opened_page}).
+    # If no page is opened or if the displayed page wasn't produced by call to {Wx::HTML::HtmlWindow#load_page}, empty string is returned.
+    # @return [String]
+    def get_opened_anchor; end
+    alias_method :opened_anchor, :get_opened_anchor
+    
+    # Returns full location of the opened page.
+    # If no page is opened or if the displayed page wasn't produced by call to {Wx::HTML::HtmlWindow#load_page}, empty string is returned.
+    # @return [String]
+    def get_opened_page; end
+    alias_method :opened_page, :get_opened_page
+    
+    # Returns title of the opened page or {Wx::EmptyString} if the current page does not contain <TITLE> tag.
+    # @return [String]
+    def get_opened_page_title; end
+    alias_method :opened_page_title, :get_opened_page_title
+    
+    # Returns a pointer to the current parser.
+    # @return [Wx::HtmlWinParser]
+    def get_parser; end
+    alias_method :parser, :get_parser
+    
+    # Returns the related frame.
+    # @return [Wx::Frame]
+    def get_related_frame; end
+    alias_method :related_frame, :get_related_frame
+    
+    # Moves back to the previous page.
+    # Only pages displayed using {Wx::HTML::HtmlWindow#load_page} are stored in history list.
+    # @return [true,false]
+    def history_back; end
+    
+    # Returns true if it is possible to go back in the history i.e.
+    # {Wx::HTML::HtmlWindow#history_back} won't fail.
+    # @return [true,false]
+    def history_can_back; end
+    
+    # Returns true if it is possible to go forward in the history i.e.
+    # {Wx::HTML::HtmlWindow#history_forward} won't fail.
+    # @return [true,false]
+    def history_can_forward; end
+    
+    # Clears history.
+    # @return [void]
+    def history_clear; end
+    
+    # Moves to next page in history.
+    # Only pages displayed using {Wx::HTML::HtmlWindow#load_page} are stored in history list.
+    # @return [true,false]
+    def history_forward; end
+    
+    # Loads an HTML page from a file and displays it.
+    # false if an error occurred, true otherwise
+    # @see Wx::HTML::HtmlWindow#load_page 
+    # @param filename [String] 
+    # @return [true,false]
+    def load_file(filename) end
+    
+    # Unlike {Wx::HTML::HtmlWindow#set_page} this function first loads the HTML page from location and then displays it.
+    # false if an error occurred, true otherwise
+    # @see Wx::HTML::HtmlWindow#load_file 
+    # @param location [String]  The address of the document. See the wxFileSystem Overview for details on the address format and {Wx::FileSystem} for a description of how the file is opened.
+    # @return [true,false]
+    def load_page(location) end
+    
+    # Called when an URL is being opened (either when the user clicks on a link or an image is loaded).
+    # The URL will be opened only if {Wx::HTML::HtmlWindow#on_opening_url} returns {Wx::HTML::HtmlOpeningStatus::HTML_OPEN}. This method is called by Wx::HtmlParser::OpenURL.
+    # You can override {Wx::HTML::HtmlWindow#on_opening_url} to selectively block some URLs (e.g. for security reasons) or to redirect them elsewhere. Default behaviour is to always return {Wx::HTML::HtmlOpeningStatus::HTML_OPEN}.
+    # 
+    # The return value is:
+    # - {Wx::HTML::HtmlOpeningStatus::HTML_OPEN}: Open the URL.- {Wx::HTML::HtmlOpeningStatus::HTML_BLOCK}: Deny access to the URL, Wx::HtmlParser::OpenURL will return NULL.- {Wx::HTML::HtmlOpeningStatus::HTML_REDIRECT}: Don't open url, redirect to another URL. {Wx::HTML::HtmlWindow#on_opening_url} must fill *redirect with the new URL. {Wx::HTML::HtmlWindow#on_opening_url} will be called again on returned URL.
+    # @param type [HtmlURLType]  Indicates type of the resource. Is one of
+    #   - {Wx::HTML::HtmlURLType::HTML_URL_PAGE}: Opening a HTML page.- {Wx::HTML::HtmlURLType::HTML_URL_IMAGE}: Opening an image.- {Wx::HTML::HtmlURLType::HTML_URL_OTHER}: Opening a resource that doesn't fall into any other category.
+    # @param url [String]  URL being opened.
+    # @return [HtmlOpeningStatus]
+    def on_opening_url(type, url) end
+    
+    # Called on parsing <TITLE> tag.
+    # @param title [String] 
+    # @return [void]
+    def on_set_title(title) end
+    
+    # This reads custom settings from {Wx::Config}.
+    # It uses the path 'path' if given, otherwise it saves info into currently selected path. The values are stored in sub-path {Wx::HTML::HtmlWindow}. Read values: all things set by {Wx::HTML::HtmlWindow#set_fonts}, {Wx::HTML::HtmlWindow#set_borders}.
+    # @param cfg [Wx::ConfigBase]  {Wx::Config} from which you want to read the configuration.
+    # @param path [String]  Optional path in config tree. If not given current path is used.
+    # @return [void]
+    def read_customization(cfg, path=Wx::EMPTY_STRING) end
+    
+    # Selects all text in the window.
+    # 
+    # @see Wx::HTML::HtmlWindow#select_line
+    # @see  Wx::HTML::HtmlWindow#select_word 
+    # @return [void]
+    def select_all; end
+    
+    # Selects the line of text that pos points at.
+    # Note that pos is relative to the top of displayed page, not to window's origin, use Wx::Scrolled#calc_unscrolled_position to convert physical coordinate.
+    # @see Wx::HTML::HtmlWindow#select_all
+    # @see  Wx::HTML::HtmlWindow#select_word 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def select_line(pos) end
+    
+    # Selects the word at position pos.
+    # Note that pos is relative to the top of displayed page, not to window's origin, use Wx::Scrolled#calc_unscrolled_position to convert physical coordinate.
+    # @see Wx::HTML::HtmlWindow#select_all
+    # @see  Wx::HTML::HtmlWindow#select_line 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @return [void]
+    def select_word(pos) end
+    
+    # Returns the current selection as plain text.
+    # Returns an empty string if no text is currently selected.
+    # @return [String]
+    def selection_to_text; end
+    
+    # This function sets the space between border of window and HTML contents.
+    # See image:
+    # @param b [Integer]  indentation from borders in pixels
+    # @return [void]
+    def set_borders(b) end
+    alias_method :borders=, :set_borders
+    
+    # This function sets font sizes and faces.
+    # See Wx::HtmlDCRenderer::SetFonts for detailed description.
+    # @see SetSize() 
+    # @param normal_face [String] 
+    # @param fixed_face [String] 
+    # @param sizes [Array(Integer,Integer,Integer,Integer,Integer,Integer,Integer), nil] 
+    # @return [void]
+    def set_fonts(normal_face, fixed_face, sizes=nil) end
+    
+    # Sets default font sizes and/or default font size.
+    # See Wx::HtmlDCRenderer::SetStandardFonts for detailed description.
+    # @see Wx::HTML::HtmlWindow#set_fonts 
+    # @param size [Integer] 
+    # @param normal_face [String] 
+    # @param fixed_face [String] 
+    # @return [void]
+    def set_standard_fonts(size=-1, normal_face=Wx::EMPTY_STRING, fixed_face=Wx::EMPTY_STRING) end
+    alias_method :standard_fonts=, :set_standard_fonts
+    
+    # Sets the source of a page and displays it, for example:
+    # htmlwin -> SetPage("<html><body>Hello, world!</body></html>");
+    # 
+    # If you want to load a document from some location use {Wx::HTML::HtmlWindow#load_page} instead.
+    # 
+    # false if an error occurred, true otherwise.
+    # @param source [String]  The HTML to be displayed.
+    # @return [true,false]
+    def set_page(source) end
+    alias_method :page=, :set_page
+    
+    # Sets the frame in which page title will be displayed.
+    # format is the format of the frame title, e.g. "HtmlHelp : %s". It must contain exactly one s. This s is substituted with HTML page title.
+    # @param frame [Wx::Frame] 
+    # @param format [String] 
+    # @return [void]
+    def set_related_frame(frame, format) end
+    
+    # @overload set_related_status_bar(index)
+    #   <b>After</b> calling {Wx::HTML::HtmlWindow#set_related_frame}, this sets statusbar slot where messages will be displayed.
+    #   (Default is -1 = no messages.)
+    #   @param index [Integer]  Statusbar slot number (0..n)
+    #   @return [void]
+    # @overload set_related_status_bar(statusbar, index=0)
+    #   <b>Sets</b> the associated statusbar where messages will be displayed.
+    #   Call this instead of {Wx::HTML::HtmlWindow#set_related_frame} if you want statusbar updates only, no changing of the frame title.
+    #   @param statusbar [Wx::StatusBar]  Statusbar pointer
+    #   @param index [Integer]  Statusbar slot number (0..n)
+    #   @return [void]
+    def set_related_status_bar(*args) end
+    alias_method :related_status_bar=, :set_related_status_bar
+    
+    # Returns content of currently displayed page as plain text.
+    # @return [String]
+    def to_text; end
+    
+    # Saves custom settings into {Wx::Config}.
+    # It uses the path 'path' if given, otherwise it saves info into currently selected path. Regardless of whether the path is given or not, the function creates sub-path {Wx::HTML::HtmlWindow}.
+    # Saved values: all things set by {Wx::HTML::HtmlWindow#set_fonts}, {Wx::HTML::HtmlWindow#set_borders}.
+    # @param cfg [Wx::ConfigBase]  {Wx::Config} to which you want to save the configuration.
+    # @param path [String]  Optional path in config tree. If not given, the current path is used.
+    # @return [void]
+    def write_customization(cfg, path=Wx::EMPTY_STRING) end
+    
+    # Adds an input filter to the static list of available filters.
+    # These filters are present by default:
+    # 
+    #   text/html
+    #   text/plain
+    #   image/*
+    # 
+    # The plain text filter will be used if no other filter matches.
+    # @param filter [Wx::HtmlFilter] 
+    # @return [void]
+    def self.add_filter(filter) end
+    
+    # Retrieves the default cursor for a given HTMLCursor type.
+    # @param type [HTMLCursor]  HTMLCursor type to retrieve.
+    # @return [Wx::Cursor]
+    def self.get_default_html_cursor(type) end
+    
+    # Sets the default cursor for a given HTMLCursor type.
+    # These cursors are used for all {Wx::HTML::HtmlWindow} objects by default, but can be overridden on a per-window basis.
+    # @param type [HTMLCursor]  HTMLCursor type to retrieve.
+    # @param cursor [Wx::Cursor]  The default cursor for the specified cursor type.
+    # @return [void]
+    def self.set_default_html_cursor(type, cursor) end
+    
+  end # HtmlWindow
+  
+  # This class is the parent class of input filters for {Wx::HTML::HtmlWindow}.
+  # It allows you to read and display files of different file formats.
+  # === 
+  # 
+  # Category:  {Wx::HTML}
+  # @see Input Filters 
+  # 
+  # 
+  class HtmlFilter < Object
+  
+    # Constructor.
+    # @return [HtmlFilter]
+    def initialize; end
+    
+    # Returns true if this filter is capable of reading file file.
+    # Example: 
+    # 
+    #   bool MyFilter::CanRead(const wxFSFile& file)
+    #   {
+    #       return (file.GetMimeType() == "application/x-ugh");
+    #   }
+    # @param file [Wx::FSFile] 
+    # @return [true,false]
+    def can_read(file) end
+    alias_method :can_read?, :can_read
+    
+    # Reads the file and returns string with HTML document.
+    # Example: 
+    # 
+    #   wxString MyImgFilter::ReadFile(const wxFSFile& file)
+    #   {
+    #       return "<html><body><img src=\"" + file.GetLocation() +
+    #              "\"></body></html>";
+    #   }
+    # @param file [Wx::FSFile] 
+    # @return [String]
+    def read_file(file) end
+    
+  end # HtmlFilter
+  
+
+end

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

@@ -0,0 +1,267 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  ICON_SCREEN_DEPTH = -1
+  
+  # An empty {Wx::Icon}.
+  # 
+  NULL_ICON = nil
+  
+  # An empty {Wx::IconBundle}.
+  # 
+  NULL_ICON_BUNDLE = nil
+  
+  # An icon is a small rectangular bitmap usually used for denoting a minimized application.
+  # It differs from a {Wx::Bitmap} in always having a mask associated with it for transparent drawing. On some platforms, icons and bitmaps are implemented identically, since there is no real distinction between a {Wx::Bitmap} with a mask and an icon; and there is no specific icon format on some platforms (X-based applications usually standardize on XPMs for small bitmaps and icons). However, some platforms (such as Windows) make the distinction, so a separate class is provided.
+  # It is usually desirable to associate a pertinent icon with a frame. Icons can also be used for other purposes, for example with {Wx::TreeCtrl} and {Wx::ListCtrl}. Icons have different formats on different platforms therefore separate icons will usually be created for the different environments. Platform-specific methods for creating a {Wx::Icon} structure are catered for, and this is an occasion where conditional compilation will probably be required. Note that a new icon must be created for every time the icon is to be used for a new window. In Windows, the icon will not be reloaded if it has already been used. An icon allocated to a frame will be deleted when the frame is deleted. For more information please see Bitmaps and Icons.
+  # 
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # Predefined objects/pointers: {Wx::NULL_ICON}
+  # @see Bitmaps and Icons
+  # @see  Supported Bitmap File Formats
+  # @see  Wx::IconBundle
+  # @see  Wx::DC#draw_icon
+  # @see  Wx::Cursor 
+  # 
+  # 
+  class Icon < GDIObject
+  
+    # @overload initialize()
+    #   Default ctor.
+    #   Constructs an icon object with no data; an assignment or another member function such as {Wx::Icon#load_file} must be called subsequently.
+    #   @return [Icon]
+    # @overload initialize(icon)
+    #   Copy ctor.
+    #   @param icon [Wx::Icon] 
+    #   @return [Icon]
+    # @overload initialize(name, type=Wx::ICON_DEFAULT_TYPE, desiredWidth=-1, desiredHeight=-1)
+    #   Loads an icon from a file or resource.
+    #   
+    #   @see Wx::Icon#load_file 
+    #   @param name [String]  This can refer to a resource name or a filename under MS Windows and X. Its meaning is determined by the type parameter.
+    #   @param type [BitmapType]  May be one of the {Wx::BitmapType} values and indicates which type of bitmap should be loaded. See the note in the class detailed description. Note that the {Wx::ICON_DEFAULT_TYPE} constant has different value under different wxWidgets ports. See the {Wx::icon.h} header for the value it takes for a specific port.
+    #   @param desiredWidth [Integer]  Specifies the desired width of the icon. This parameter only has an effect in Windows where icon resources can contain several icons of different sizes.
+    #   @param desiredHeight [Integer]  Specifies the desired height of the icon. This parameter only has an effect in Windows where icon resources can contain several icons of different sizes.
+    #   @return [Icon]
+    # @overload initialize(loc)
+    #   Loads an icon from the specified location.
+    #   @param loc [Wx::IconLocation] 
+    #   @return [Icon]
+    def initialize(*args) end
+    
+    # Attach a Windows icon handle.
+    # This {Wx::MSW}-specific method allows assigning a native Windows HICON (which must be cast to WXHICON opaque handle type) to {Wx::Icon}. Notice that this means that the HICON will be destroyed by {Wx::Icon} when it is destroyed.
+    # true if successful.
+    # 
+    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # @param icon [WXHICON] 
+    # @return [true,false]
+    def create_from_hicon(icon) end
+    
+    # Copies bmp bitmap to this icon.
+    # Under MS Windows the bitmap must have mask colour set.
+    # @see Wx::Icon#load_file 
+    # @param bmp [Wx::Bitmap] 
+    # @return [void]
+    def copy_from_bitmap(bmp) end
+    
+    # Gets the colour depth of the icon.
+    # A value of 1 indicates a monochrome icon.
+    # @return [Integer]
+    def get_depth; end
+    alias_method :depth, :get_depth
+    
+    # Gets the height of the icon in physical pixels.
+    # 
+    # @see Wx::Icon#get_width
+    # @see  Wx::Icon#get_logical_height 
+    # @return [Integer]
+    def get_height; end
+    alias_method :height, :get_height
+    
+    # Gets the height of the icon in logical pixels.
+    # See {Wx::Bitmap#get_logical_height}.
+    # @return [Float]
+    def get_logical_height; end
+    alias_method :logical_height, :get_logical_height
+    
+    # Gets the size of the icon in logical pixels.
+    # See {Wx::Bitmap#get_logical_size}.
+    # @return [Wx::Size]
+    def get_logical_size; end
+    alias_method :logical_size, :get_logical_size
+    
+    # Gets the width of the icon in logical pixels.
+    # See {Wx::Bitmap#get_logical_width}.
+    # @return [Float]
+    def get_logical_width; end
+    alias_method :logical_width, :get_logical_width
+    
+    # Gets the scale factor of this icon.
+    # See {Wx::Bitmap#get_scale_factor}.
+    # @return [Float]
+    def get_scale_factor; end
+    alias_method :scale_factor, :get_scale_factor
+    
+    # Gets the size of the icon in physical pixels.
+    # 
+    # @see Wx::Icon#get_logical_size 
+    # @return [Wx::Size]
+    def get_size; end
+    alias_method :size, :get_size
+    
+    # Gets the width of the icon in physical pixels.
+    # 
+    # @see Wx::Icon#get_height
+    # @see  Wx::Icon#get_logical_width 
+    # @return [Integer]
+    def get_width; end
+    alias_method :width, :get_width
+    
+    # Returns true if icon data is present.
+    # @return [true,false]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # Loads an icon from a file or resource.
+    # true if the operation succeeded, false otherwise.
+    # @param name [String]  Either a filename or a Windows resource name. The meaning of name is determined by the type parameter.
+    # @param type [BitmapType]  One of the {Wx::BitmapType} values; see the note in the class detailed description. Note that the {Wx::ICON_DEFAULT_TYPE} constant has different value under different wxWidgets ports. See the {Wx::icon.h} header for the value it takes for a specific port.
+    # @param desiredWidth [Integer]  Specifies the desired width of the icon. This parameter only has an effect in Windows where icon resources can contain several icons of different sizes.
+    # @param desiredHeight [Integer]  Specifies the desired height of the icon. This parameter only has an effect in Windows where icon resources can contain several icons of different sizes.
+    # @return [true,false]
+    def load_file(name, type=Wx::ICON_DEFAULT_TYPE, desiredWidth=-1, desiredHeight=-1) end
+    
+  end # Icon
+  
+  # This class contains multiple copies of an icon in different sizes.
+  # It is typically used in {Wx::Dialog#set_icons} and {Wx::TopLevelWindow#set_icons}.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # Predefined objects/pointers: {Wx::NULL_ICON_BUNDLE}
+  # 
+  class IconBundle < GDIObject
+  
+    # Return invalid icon if exact size is not found.
+    # 
+    FALLBACK_NONE = 0
+    
+    # Return the icon of the system icon size if exact size is not found.
+    # 
+    FALLBACK_SYSTEM = 1
+    
+    # Return the icon of closest larger size or, if there is no icon of larger size in the bundle, the closest icon of smaller size.
+    # 
+    FALLBACK_NEAREST_LARGER = 2
+    
+    # @overload initialize()
+    #   Default ctor.
+    #   @return [IconBundle]
+    # @overload initialize(file, type=Wx::BITMAP_TYPE_ANY)
+    #   Initializes the bundle with the icon(s) found in the file.
+    #   @param file [String] 
+    #   @param type [BitmapType] 
+    #   @return [IconBundle]
+    # @overload initialize(stream, type=Wx::BITMAP_TYPE_ANY)
+    #   Initializes the bundle with the icon(s) found in the stream.
+    #   Notice that the stream must be seekable, at least if it contains more than one icon. The stream pointer is positioned after the last icon read from the stream when this function returns.
+    #   @param stream [IO,Wx::InputStream] 
+    #   @param type [BitmapType] 
+    #   @return [IconBundle]
+    # @overload initialize(icon)
+    #   Initializes the bundle with a single icon.
+    #   @param icon [Wx::Icon] 
+    #   @return [IconBundle]
+    # @overload initialize(resourceName, module_)
+    #   Initializes the bundle with all sizes of a group icon with resourceName stored as an MS Windows resource in module.
+    #   When module is 0, the current instance is used.
+    #   
+    #   Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    #   @see AddIcon(const wxString&
+    #   @see  WXHINSTANCE)
+    #   @param resourceName [String] 
+    #   @param module_ [WXHINSTANCE] 
+    #   @return [IconBundle]
+    # @overload initialize(ic)
+    #   Copy constructor.
+    #   @param ic [Wx::IconBundle] 
+    #   @return [IconBundle]
+    def initialize(*args) end
+    
+    # @overload add_icon(file, type=Wx::BITMAP_TYPE_ANY)
+    #   Adds all the icons contained in the file to the bundle; if the collection already contains icons with the same width and height, they are replaced by the new ones.
+    #   @param file [String] 
+    #   @param type [BitmapType] 
+    #   @return [void]
+    # @overload add_icon(stream, type=Wx::BITMAP_TYPE_ANY)
+    #   Adds all the icons contained in the stream to the bundle; if the collection already contains icons with the same width and height, they are replaced by the new ones.
+    #   Notice that, as well as in the constructor loading the icon bundle from stream, the stream must be seekable, at least if more than one icon is to be loaded from it.
+    #   @param stream [IO,Wx::InputStream] 
+    #   @param type [BitmapType] 
+    #   @return [void]
+    # @overload add_icon(resourceName, module_)
+    #   Loads all sizes of a group icon with resourceName stored as an MS Windows resource in module.
+    #   When module is 0, the current instance is used.
+    #   Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    #   @param resourceName [String] 
+    #   @param module_ [WXHINSTANCE] 
+    #   @return [void]
+    # @overload add_icon(icon)
+    #   Adds the icon to the collection; if the collection already contains an icon with the same width and height, it is replaced by the new one.
+    #   @param icon [Wx::Icon] 
+    #   @return [void]
+    def add_icon(*args) end
+    
+    # @overload get_icon(size, flags=Wx::FALLBACK_SYSTEM)
+    #   Returns the icon with the given size.
+    #   If size is {Wx::DEFAULT_SIZE}, it is interpreted as the standard system icon size, i.e. the size returned by {Wx::SystemSettings.get_metric} for {Wx::SystemMetric::SYS_ICON_X} and {Wx::SystemMetric::SYS_ICON_Y}.
+    #   If the bundle contains an icon with exactly the requested size, it's always returned. Otherwise, the behaviour depends on the flags. If only {Wx::IconBundle::FALLBACK_NONE} is given, the function returns an invalid icon. If {Wx::IconBundle::FALLBACK_SYSTEM} is given, it tries to find the icon of standard system size, regardless of the size passed as parameter. Otherwise, or if the icon system size is not found either, but {Wx::IconBundle::FALLBACK_NEAREST_LARGER} flag is specified, the function returns the smallest icon of the size larger than the requested one or, if this fails too, just the icon closest to the specified size.
+    #   The flags parameter is available only since wxWidgets 2.9.4.
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param flags [Integer] 
+    #   @return [Wx::Icon]
+    # @overload get_icon(size=Wx::DEFAULT_COORD, flags=Wx::FALLBACK_SYSTEM)
+    #   Same as.
+    #   GetIcon( wxSize( size, size ) ) 
+    #   .
+    #   @param size [Integer] 
+    #   @param flags [Integer] 
+    #   @return [Wx::Icon]
+    def get_icon(*args) end
+    alias_method :icon, :get_icon
+    
+    # Returns the icon with exactly the given size or {Wx::NULL_ICON} if this size is not available.
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @return [Wx::Icon]
+    def get_icon_of_exact_size(size) end
+    alias_method :icon_of_exact_size, :get_icon_of_exact_size
+    
+    # return the number of available icons
+    # @return [Integer]
+    def get_icon_count; end
+    alias_method :icon_count, :get_icon_count
+    
+    # return the icon at index (must be < {Wx::IconBundle#get_icon_count})
+    # @param n [Integer] 
+    # @return [Wx::Icon]
+    def get_icon_by_index(n) end
+    alias_method :icon_by_index, :get_icon_by_index
+    
+    # Returns true if the bundle doesn't contain any icons, false otherwise (in which case a call to {Wx::IconBundle#get_icon} with default parameter should return a valid icon).
+    # @return [true,false]
+    def is_empty; end
+    alias_method :empty?, :is_empty
+    
+  end # IconBundle
+  
+
+end

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

@@ -0,0 +1,38 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::IconLocation} is a tiny class describing the location of an (external, i.e.
+  # not embedded into the application resources) icon. For most platforms it simply contains the file name but under some others (notably Windows) the same file may contain multiple icons and so this class also stores the index of the icon inside the file.
+  # In any case, its details should be of no interest to the application code and most of them are not even documented here (on purpose) as it is only meant to be used as an opaque class: the application may get the object of this class from somewhere and the only reasonable thing to do with it later is to create a {Wx::Icon} from it.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # @see Wx::Icon
+  # @see  Wx::FileType::GetIcon 
+  # 
+  # 
+  class IconLocation < ::Object
+  
+    # Returns true if the object is valid, i.e. was properly initialized, and false otherwise.
+    # @return [true,false]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # @param filename [String] 
+    # @return [void]
+    def set_file_name(filename) end
+    alias_method :file_name=, :set_file_name
+    
+    # @return [Wx::String]
+    def get_file_name; end
+    alias_method :file_name, :get_file_name
+    
+  end # IconLocation
+  
+
+end