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

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

@@ -62,6 +62,8 @@ module Wx::HTML
   # Helper class for {Wx::HTML::HtmlHelpData}.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class HtmlBookRecord < ::Object
   
     # @param bookfile [String] 
@@ -125,6 +127,8 @@ module Wx::HTML
   # Helper class for {Wx::HTML::HtmlHelpData}.
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class HtmlHelpDataItem < ::Object
   
     # @return [HtmlHelpDataItem]

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

@@ -108,7 +108,7 @@ module Wx::HTML
   
   # This class is used by {Wx::HTML::HtmlHelpController} to display help within a frame or dialog, but you can use it yourself to create an embedded HTML help window.
   # For example: 
-  # 
+  # ```
   #   // m_embeddedHelpWindow is a wxHtmlHelpWindow
   #   // m_embeddedHtmlHelp is a wxHtmlHelpController
   #   
@@ -119,6 +119,7 @@ module Wx::HTML
   #   m_embeddedHelpWindow->Create(this, wxID_ANY, wxDefaultPosition, GetClientSize(),
   #                                wxTAB_TRAVERSAL|wxBORDER_NONE, wxHF_DEFAULT_STYLE);
   #   m_embeddedHtmlHelp.AddBook(wxFileName(wxT("doc.zip")));
+  # ```
   # 
   # You should pass the style {Wx::HTML::HF_EMBEDDED} to the style parameter of {Wx::HTML::HtmlHelpController} to allow the embedded window to be destroyed independently of the help controller.
   # === 

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

@@ -56,6 +56,46 @@ module Wx::HTML
     # @return [true,false]
     def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::HtmlListBoxNameStr) end
     
+    
+    protected
+    
+    # Called when the user clicks on hypertext link.
+    # Does nothing by default. Overloading this method is deprecated; intercept the event instead.
+    # @see Wx::HTML::HtmlLinkInfo. 
+    # @param n [Integer]  Index of the item containing the link.
+    # @param link [Wx::HtmlLinkInfo]  Description of the link.
+    # @return [void]
+    def on_link_clicked(n, link) end
+    
+    # This virtual function may be overridden to change the appearance of the background of the selected cells in the same way as {Wx::HTML::HtmlListBox#get_selected_text_colour}.
+    # It should be rarely, if ever, used because {Wx::VListBox#set_selection_background} allows changing the selection background for all cells at once and doing anything more fancy is probably going to look strangely.
+    # @see Wx::HTML::HtmlListBox#get_selected_text_colour 
+    # @param colBg [Wx::Colour,String,Symbol] 
+    # @return [Wx::Colour]
+    def get_selected_text_bg_colour(colBg) end
+    alias_method :selected_text_bg_colour, :get_selected_text_bg_colour
+    
+    # This virtual function may be overridden to customize the appearance of the selected cells.
+    # It is used to determine how the colour colFg is going to look inside selection. By default all original colours are completely ignored and the standard, system-dependent, selection colour is used but the program may wish to override this to achieve some custom appearance.
+    # @see Wx::HTML::HtmlListBox#get_selected_text_bg_colour
+    # @see  Wx::VListBox#set_selection_background
+    # @see  Wx::SystemSettings.get_colour 
+    # @param colFg [Wx::Colour,String,Symbol] 
+    # @return [Wx::Colour]
+    def get_selected_text_colour(colFg) end
+    alias_method :selected_text_colour, :get_selected_text_colour
+    
+    # This function may be overridden to decorate HTML returned by {Wx::HTML::HtmlListBox#on_get_item}.
+    # @param n [Integer] 
+    # @return [String]
+    def on_get_item_markup(n) end
+    
+    # This method must be implemented in the derived class and should return the body (i.e. without html nor body tags) of the HTML fragment for the given item.
+    # Note that this function should always return a text fragment for the n item which renders with the same height both when it is selected and when it's not: i.e. if you call, inside your {Wx::HTML::HtmlListBox#on_get_item} implementation, <code>IsSelected(n)</code> to make the items appear differently when they are selected, then you should make sure that the returned HTML fragment will render with the same height or else you'll see some artifacts when the user selects an item.
+    # @param n [Integer] 
+    # @return [String]
+    def on_get_item(n) end
+    
   end # HtmlListBox
   
   # {Wx::HTML::SimpleHtmlListBox} is an implementation of {Wx::HTML::HtmlListBox} which shows HTML content in the listbox rows.
@@ -117,17 +157,6 @@ module Wx::HTML
     #   @return [true,false]
     def create(*args) end
     
-    # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=Wx::HTML::HLB_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SimpleHtmlListBoxNameStr)
-    #   Constructor, creating and showing the HTML list box.
-    #   @param parent [Wx::Window]  Parent window. Must not be NULL.
-    #   @param id [Integer]  Window identifier. A value of -1 indicates a default value.
-    #   @param pos [Array(Integer, Integer), Wx::Point]  Window position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
-    #   @param size [Array(Integer, Integer), Wx::Size]  Window size. If {Wx::DEFAULT_SIZE} is specified then the window is sized appropriately.
-    #   @param choices [Array<String>]  An array of strings with which to initialise the control.
-    #   @param style [Integer]  Window style. See {Wx::HLB_}* flags.
-    #   @param validator [Wx::Validator]  Window validator.
-    #   @param name [String]  Window name.
-    #   @return [SimpleHtmlListBox]
     # @overload initialize(parent, id, pos, size, choices, style=Wx::HTML::HLB_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::SimpleHtmlListBoxNameStr)
     #   Constructor, creating and showing the HTML list box.
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -144,6 +173,104 @@ module Wx::HTML
     #   @return [SimpleHtmlListBox]
     def initialize(*args) end
     
+    # @overload append(item)
+    #   Appends item into the control.
+    #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
+    #   @param item [String]  String to add.
+    #   @return [Integer]
+    # @overload append(item, clientData)
+    #   Appends item into the control.
+    #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
+    #   @param item [String]  String to add.
+    #   @param clientData [Object]  Pointer to client data to associate with the new item.
+    #   @return [Integer]
+    # @overload append(items)
+    #   Appends several items at once into the control.
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @return [Integer]
+    # @overload append(items, clientData)
+    #   Appends several items at once into the control.
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [Integer]
+    def append(*args) end
+    
+    # Returns a pointer to the client data associated with the given item (if any).
+    # It is an error to call this function for a control which doesn't have untyped client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # 
+    # A pointer to the client data, or NULL if not present.
+    # @param n [Integer]  The zero-based position of the item.
+    # @return [Object]
+    def get_client_data(n) end
+    alias_method :client_data, :get_client_data
+    
+    # Associates the given untyped client data pointer with the given item.
+    # Note that it is an error to call this function if any typed client data pointers had been associated with the control items before.
+    # @param n [Integer]  The zero-based item index.
+    # @param data [Object]  The client data to associate with the item.
+    # @return [void]
+    def set_client_data(n, data) end
+    
+    # @overload insert(item, pos)
+    #   Inserts item into the control.
+    #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param item [String]  String to add.
+    #   @param pos [Integer]  Position to insert item before, zero based.
+    #   @return [Integer]
+    # @overload insert(item, pos, clientData)
+    #   Inserts item into the control.
+    #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param item [String]  String to add.
+    #   @param pos [Integer]  Position to insert item before, zero based.
+    #   @param clientData [Object]  Pointer to client data to associate with the new item.
+    #   @return [Integer]
+    # @overload insert(items, pos)
+    #   Inserts several items at once into the control.
+    #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
+    #   
+    #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @return [Integer]
+    # @overload insert(items, pos, clientData)
+    #   Inserts several items at once into the control.
+    #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
+    #   
+    #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param pos [Integer]  Position to insert the items before, zero based.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [Integer]
+    def insert(*args) end
+    
+    # @overload set(items)
+    #   Replaces the current control contents with the given items.
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @return [void]
+    # @overload set(items, clientData)
+    #   Replaces the current control contents with the given items.
+    #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
+    #   @param items [Array<String>]  Array of strings to insert.
+    #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
+    #   @return [void]
+    def set(*args) end
+    
+    # Deletes an item from the control.
+    # The client data associated with the item will be also deleted if it is owned by the control. Note that it is an error (signalled by an assert failure in debug builds) to remove an item with the index negative or greater or equal than the number of items in the control.
+    # If there is a currently selected item below the item being deleted, i.e. if {Wx::HTML::SimpleHtmlListBox#get_selection} returns a valid index greater than or equal to n, the selection is invalidated when this function is called. However if the selected item appears before the item being deleted, the selection is preserved unchanged.
+    # @see Wx::HTML::SimpleHtmlListBox#clear 
+    # @param n [Integer]  The zero-based item index.
+    # @return [void]
+    def delete(n) end
+    
+    # Returns true, if either untyped data (<code>void*</code>) or object data ({Wx::ClientData}*) is associated with the items of the control.
+    # @return [true,false]
+    def has_client_data; end
+    alias_method :has_client_data?, :has_client_data
+    
   end # SimpleHtmlListBox
   
 

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

@@ -273,7 +273,9 @@ module Wx::HTML
     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>");
+    # ```
+    #   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.
     # 
@@ -319,9 +321,11 @@ module Wx::HTML
     # 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] 
@@ -358,11 +362,12 @@ module Wx::HTML
     
     # 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
@@ -370,12 +375,13 @@ module Wx::HTML
     
     # 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

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

@@ -0,0 +1,147 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  HL_CONTEXTMENU = 1
+  
+  # 
+  HL_ALIGN_LEFT = 2
+  
+  # 
+  HL_ALIGN_RIGHT = 4
+  
+  # 
+  HL_ALIGN_CENTRE = 8
+  
+  # 
+  HL_DEFAULT_STYLE = 2097161
+  
+  # 
+  # 
+  EVT_HYPERLINK = 10023
+  
+  # This class shows a static text element which links to an URL.
+  # Appearance and behaviour is completely customizable.
+  # In fact, when the user clicks on the hyperlink, a {Wx::HyperlinkEvent} is sent but if that event is not handled (or it's skipped; see {Wx::Event#skip}), then a call to {launch_default_browser} is done with the hyperlink's URL.
+  # Note that standard {Wx::Window} functions like {Wx::Window#set_background_colour}, {Wx::Window#set_font}, {Wx::Window#set_cursor}, {Wx::Window#set_label} can be used to customize appearance of the hyperlink.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::HL_ALIGN_LEFT}: Align the text to the left. 
+  # - {Wx::HL_ALIGN_RIGHT}: Align the text to the right. This style is not supported under Windows. 
+  # - {Wx::HL_ALIGN_CENTRE}: Center the text (horizontally). This style is not supported under Windows. 
+  # - {Wx::HL_CONTEXTMENU}: Pop up a context menu when the hyperlink is right-clicked. The context menu contains a "Copy URL" menu item which is automatically handled by the hyperlink and which just copies in the clipboard the URL (not the label) of the control. 
+  # - {Wx::HL_DEFAULT_STYLE}: The default style for {Wx::HyperlinkCtrl}: {Wx::Border::BORDER_NONE}|{Wx::HL_CONTEXTMENU}|{Wx::HL_ALIGN_CENTRE}. 
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::HyperlinkEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_hyperlink}(id, meth = nil, &block): The hyperlink was (left) clicked. If this event is not handled in user's code (or it's skipped; see {Wx::Event#skip}), then a call to {Wx::LaunchDefaultBrowser} is done with the hyperlink's URL. 
+  # 
+  # Currently this class is implemented using native support in {Wx::GTK} and {Wx::MSW} and a generic version is used by the other ports.
+  # === 
+  # 
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> {Wx::MSW} Appearance
+  #   </td><td> {Wx::GTK} Appearance
+  #   </td><td> {Wx::OSX} Appearance
+  #   </td></tr></table></div>
+  # @see Wx::URL
+  # @see  Wx::HyperlinkEvent 
+  # 
+  # 
+  class HyperlinkCtrl < Control
+  
+    # @overload initialize()
+    #   @return [HyperlinkCtrl]
+    # @overload initialize(parent, id, label, url, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HL_DEFAULT_STYLE, name=Wx::HyperlinkCtrlNameStr)
+    #   Constructor.
+    #   See {Wx::HyperlinkCtrl#create} for more info.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param label [String] 
+    #   @param url [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [HyperlinkCtrl]
+    def initialize(*args) end
+    
+    # Creates the hyperlink control.
+    # @param parent [Wx::Window]  Parent window. Must not be NULL.
+    # @param id [Integer]  Window identifier. A value of {Wx::StandardID::ID_ANY} indicates a default value.
+    # @param label [String]  The label of the hyperlink.
+    # @param url [String]  The URL associated with the given label.
+    # @param pos [Array(Integer, Integer), Wx::Point]  Window position.
+    # @param size [Array(Integer, Integer), Wx::Size]  Window size. If the {Wx::DEFAULT_SIZE} is specified then the window is sized appropriately.
+    # @param style [Integer]  Window style. See {Wx::HyperlinkCtrl}.
+    # @param name [String]  Window name.
+    # @return [true,false]
+    def create(parent, id, label, url, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::HL_DEFAULT_STYLE, name=Wx::HyperlinkCtrlNameStr) end
+    
+    # Returns the colour used to print the label of the hyperlink when the mouse is over the control.
+    # @return [Wx::Colour]
+    def get_hover_colour; end
+    alias_method :hover_colour, :get_hover_colour
+    
+    # Returns the colour used to print the label when the link has never been clicked before (i.e. the link has not been visited) and the mouse is not over the control.
+    # @return [Wx::Colour]
+    def get_normal_colour; end
+    alias_method :normal_colour, :get_normal_colour
+    
+    # Returns the URL associated with the hyperlink.
+    # @return [String]
+    def get_url; end
+    alias_method :url, :get_url
+    
+    # Returns true if the hyperlink has already been clicked by the user at least one time.
+    # @return [true,false]
+    def get_visited; end
+    alias_method :visited, :get_visited
+    
+    # Returns the colour used to print the label when the mouse is not over the control and the link has already been clicked before (i.e. the link has been visited).
+    # @return [Wx::Colour]
+    def get_visited_colour; end
+    alias_method :visited_colour, :get_visited_colour
+    
+    # Sets the colour used to print the label of the hyperlink when the mouse is over the control.
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_hover_colour(colour) end
+    alias_method :hover_colour=, :set_hover_colour
+    
+    # Sets the colour used to print the label when the link has never been clicked before (i.e. the link has not been visited) and the mouse is not over the control.
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_normal_colour(colour) end
+    alias_method :normal_colour=, :set_normal_colour
+    
+    # Sets the URL associated with the hyperlink.
+    # @param url [String] 
+    # @return [void]
+    def set_url(url) end
+    alias_method :url=, :set_url
+    
+    # Marks the hyperlink as visited (see {Wx::HyperlinkCtrl#set_visited_colour}).
+    # @param visited [true,false] 
+    # @return [void]
+    def set_visited(visited=true) end
+    alias_method :visited=, :set_visited
+    
+    # Sets the colour used to print the label when the mouse is not over the control and the link has already been clicked before (i.e. the link has been visited).
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_visited_colour(colour) end
+    alias_method :visited_colour=, :set_visited_colour
+    
+  end # HyperlinkCtrl
+  
+
+end

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

@@ -0,0 +1,43 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # This event class is used for the events generated by {Wx::HyperlinkCtrl}.
+  # === Events using this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::HyperlinkEvent} events.
+  # Event handler methods:
+  # - {Wx::EvtHandler#evt_hyperlink}(id, meth = nil, &block): User clicked on a hyperlink. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Events}
+  # 
+  class HyperlinkEvent < CommandEvent
+  
+    # The constructor is not normally used by the user code.
+    # @param generator [Wx::Object] 
+    # @param id [Integer] 
+    # @param url [String] 
+    # @return [HyperlinkEvent]
+    def initialize(generator, id, url) end
+    
+    # Returns the URL of the hyperlink where the user has just clicked.
+    # @return [String]
+    def get_url; end
+    alias_method :url, :get_url
+    
+    # Sets the URL associated with the event.
+    # @param url [String] 
+    # @return [void]
+    def set_url(url) end
+    alias_method :url=, :set_url
+    
+  end # HyperlinkEvent
+  
+
+end

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

@@ -32,6 +32,8 @@ module Wx
   # @see  Wx::Cursor 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Icon < GDIObject
   
     # @overload initialize()
@@ -149,6 +151,8 @@ module Wx
   # Category:  Graphics Device Interface (GDI)
   # Predefined objects/pointers: {Wx::NULL_ICON_BUNDLE}
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class IconBundle < GDIObject
   
     # Return invalid icon if exact size is not found.
@@ -231,7 +235,9 @@ module Wx
     #   @return [Wx::Icon]
     # @overload get_icon(size=Wx::DEFAULT_COORD, flags=Wx::IconBundle::FALLBACK_SYSTEM)
     #   Same as.
-    #   GetIcon( wxSize( size, size ) ) 
+    #   ```
+    #     GetIcon( wxSize( size, size ) ) 
+    #   ```
     #   .
     #   @param size [Integer] 
     #   @param flags [Integer] 

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

@@ -16,6 +16,8 @@ module Wx
   # @see  Wx::FileType::GetIcon 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class IconLocation < ::Object
   
     # Returns true if the object is valid, i.e. was properly initialized, and false otherwise.

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

@@ -456,7 +456,7 @@ module Wx
     # It should be noted that although using {Wx::ImageResizeQuality::IMAGE_QUALITY_HIGH} produces much nicer looking results it is a slower method. Downsampling will use the box averaging method which seems to operate very fast. If you are upsampling larger images using this method you will most likely notice that it is a bit slower and in extreme cases it will be quite substantially slower as the bicubic algorithm has to process a lot of data.
     # It should also be noted that the high quality scaling may not work as expected when using a single mask colour for transparency, as the scaling will blur the image and will therefore remove the mask partially. Using the alpha channel will work.
     # Example: 
-    # 
+    # ```
     #   // get the bitmap from somewhere
     #   wxBitmap bmp = ...;
     #   
@@ -470,6 +470,7 @@ module Wx
     #       image.Rescale(32, 32);
     #       bmp = image;
     #   }
+    # ```
     # 
     # The algorithm used for the default (normal) quality value doesn't work with images larger than 65536 (2^16) pixels in either dimension for 32-bit programs. For 64-bit programs the limit is 2^48 and so not relevant in practice.
     # @see Wx::Image#rescale 
@@ -549,6 +550,7 @@ module Wx
     # Computes the histogram of the image.
     # histogram is a reference to {Wx::ImageHistogram} object. {Wx::ImageHistogram} is a specialization of {Wx::HashMap} "template" and is defined as follows:
     # 
+    # ```
     #   class WXDLLEXPORT wxImageHistogramEntry
     #   {
     #   public:
@@ -560,6 +562,7 @@ module Wx
     #   WX_DECLARE_EXPORTED_HASH_MAP(unsigned long, wxImageHistogramEntry,
     #                               wxIntegerHash, wxIntegerEqual,
     #                               wxImageHistogram);
+    # ```
     # 
     # Returns number of colours in the histogram.
     # @param histogram [Wx::ImageHistogram] 
@@ -703,7 +706,7 @@ module Wx
     # Returns the palette associated with the image.
     # Currently the palette is only used when converting to {Wx::Bitmap} under Windows.
     # Some of the {Wx::Image} handlers have been modified to set the palette if one exists in the image file (usually 256 or less colour images in GIF or PNG format).
-    # @return [void]
+    # @return [Wx::Palette]
     def get_palette; end
     alias_method :palette, :get_palette
     
@@ -764,9 +767,10 @@ module Wx
     #   Depending on how wxWidgets has been configured, not all formats may be available.
     #   
     #   You can use {Wx::Image#get_option_int} to get the hotspot when loading cursor files: 
-    #   
+    #   ```
     #     int hotspot_x = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
     #     int hotspot_y = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
+    #   ```
     #   @see Wx::Image#save_file 
     #   @param stream [IO,Wx::InputStream]  Opened input stream from which to load the image. Currently, the stream must support seeking.
     #   @param type [BitmapType]  May be one of the following: 
@@ -816,9 +820,10 @@ module Wx
     #   Depending on how wxWidgets has been configured, not all formats may be available.
     #   
     #   You can use {Wx::Image#set_option} to set the hotspot when saving an image into a cursor file (default hotspot is in the centre of the image): 
-    #   
+    #   ```
     #     image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotspotX);
     #     image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotspotY);
+    #   ```
     #   @see Wx::Image#load_file 
     #   @param stream [IO,Wx::OutputStream]  Opened output stream to save the image to.
     #   @param mimetype [String]  MIME type.
@@ -889,10 +894,11 @@ module Wx
     # Sets the flags used for loading image files by this object.
     # The flags will affect any future calls to {Wx::Image#load_file} for this object. To change the flags for all image objects, call {Wx::Image.set_default_load_flags} before creating any of them.
     # Currently the only defined flag is Load_Verbose which determines if the non-fatal (i.e. not preventing the file from being loaded completely) problems should result in the calls to {log_warning} function. It is recommended to customize handling of these warnings by e.g. defining a custom log target (see Logging Overview), but if such warnings should be completely suppressed, clearing this flag provides a simple way to do it, for example: 
-    # 
+    # ```
     #   wxImage image;
     #   image.SetLoadFlags(image.GetLoadFlags() & ~wxImage::Load_Verbose);
     #   image.LoadFile(...);
+    # ```
     # @see Wx::Image#load_file
     # @see  Wx::Image#set_load_flags
     # @see  Wx::Image#get_load_flags
@@ -1057,7 +1063,6 @@ module Wx
     #   @return [Image]
     # @overload initialize(xpmData)
     #   Creates an image from XPM data.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}. 
     #   This constructor has become explicit in wxWidgets 3.1.6.
     #   @param xpmData [char]  A pointer to XPM image data.
     #   @return [Image]
@@ -1066,9 +1071,10 @@ module Wx
     #   Depending on how wxWidgets has been configured and by which handlers have been loaded, not all formats may be available. Any handler other than BMP must be previously initialized with {Wx::Image.add_handler} or {init_all_image_handlers}.
     #   
     #   You can use {Wx::Image#get_option_int} to get the hotspot when loading cursor files: 
-    #   
+    #   ```
     #     int hotspot_x = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
     #     int hotspot_y = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
+    #   ```
     #   @see Wx::Image#load_file 
     #   @param name [String]  Name of the file from which to load the image.
     #   @param type [BitmapType]  May be one of the following: 
@@ -1120,10 +1126,11 @@ module Wx
     
     # Iterates all registered {Wx::ImageHandler} objects, and returns a string containing file extension masks suitable for passing to file open/save dialog boxes.
     # The format of the returned string is <code>"(*.ext1;*.ext2)|*.ext1;*.ext2"</code>. It is usually a good idea to prepend a description before passing the result to the dialog. Example: 
-    # 
+    # ```
     #   wxFileDialog FileDlg( this, "Choose Image", ::wxGetCwd(), "",
     #                         _("Image Files ") + wxImage::GetImageExtWildcard(),
     #                         wxFD_OPEN );
+    # ```
     # @see Wx::ImageHandler 
     # @return [String]
     def self.get_image_ext_wildcard; end

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

@@ -16,6 +16,8 @@ module Wx
   # @see  Wx::MouseState 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class KeyboardState < ::Object
   
     # Constructor initializes the modifier key settings.
@@ -31,13 +33,17 @@ module Wx
     # The return value is a combination of {Wx::KeyModifier::MOD_ALT}, {Wx::KeyModifier::MOD_CONTROL}, {Wx::KeyModifier::MOD_SHIFT} and {Wx::KeyModifier::MOD_META} bit masks. Additionally, {Wx::KeyModifier::MOD_NONE} is defined as 0, i.e. corresponds to no modifiers (see {Wx::KeyboardState#has_any_modifiers}) and {Wx::KeyModifier::MOD_CMD} is either {Wx::KeyModifier::MOD_CONTROL} (MSW and Unix) or {Wx::KeyModifier::MOD_META} (Mac), see {Wx::KeyboardState#cmd_down}. See {Wx::KeyModifier} for the full list of modifiers.
     # Notice that this function is easier to use correctly than, for example, {Wx::KeyboardState#control_down} because when using the latter you also have to remember to test that none of the other modifiers is pressed:
     # 
+    # ```
     #   if ( ControlDown() && !AltDown() && !ShiftDown() && !MetaDown() )
     #       ... handle Ctrl-XXX ...
+    # ```
     # 
     # and forgetting to do it can result in serious program bugs (e.g. program not working with European keyboard layout where AltGr key which is seen by the program as combination of CTRL and ALT is used). On the other hand, you can simply write:
     # 
+    # ```
     #   if ( GetModifiers() == wxMOD_CONTROL )
     #       ... handle Ctrl-XXX ...
+    # ```
     # 
     # with this function.
     # @return [Integer]

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

@@ -77,7 +77,6 @@ module Wx
     #   @return [ListBox]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ListBoxNameStr)
     #   Constructor, creating and showing a list box.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}.
     #   @param parent [Wx::Window]  The parent window.
     #   @param id [Integer]  The ID of this control. A value of {Wx::StandardID::ID_ANY} indicates a default value.
     #   @param pos [Array(Integer, Integer), Wx::Point]  The initial position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
@@ -90,7 +89,6 @@ module Wx
     # @overload initialize(parent, id, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ListBoxNameStr)
     #   Constructor, creating and showing a list box.
     #   See the other {Wx::ListBox#list_box} constructor; the only difference is that this overload takes a {Wx::ArrayString} instead of a pointer to an array of {Wx::String}.
-    #   <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
     #   @param pos [Array(Integer, Integer), Wx::Point] 
@@ -141,8 +139,6 @@ module Wx
     # The number of selections.
     # 
     # Use this with a multiple selection listbox.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and return the selected items as a list.
     # @see Wx::ControlWithItems::GetSelection
     # @see  Wx::ControlWithItems::GetStringSelection
     # @see  Wx::ControlWithItems::SetSelection 
@@ -165,7 +161,6 @@ module Wx
     def hit_test(*args) end
     
     # Insert the given number of strings before the specified position.
-    # <b>{Wx::Perl} Note:</b> Use an array reference for the items parameter.
     # @param items [Array<String>]  Labels of items to be inserted
     # @param pos [Integer]  Position before which to insert the items: if pos is 0 the items will be inserted in the beginning of the listbox
     # @return [void]
@@ -195,12 +190,6 @@ module Wx
     # @return [void]
     def ensure_visible(n) end
     
-    # Return true if the listbox has {Wx::LB_SORT} style.
-    # This method is mostly meant for internal use only.
-    # @return [true,false]
-    def is_sorted; end
-    alias_method :sorted?, :is_sorted
-    
     # Return the number of items that can fit vertically in the visible area of the listbox.
     # Returns -1 if the number of items per page couldn't be determined. On {Wx::GTK} this method can only determine the number of items per page if there is at least one item in the listbox.
     # @return [void]