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

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

@@ -101,6 +101,8 @@ module Wx
   # @see  Wx::DC#set_brush 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Brush < GDIObject
   
     # @overload set_colour(colour)

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

@@ -7,52 +7,55 @@
 module Wx
 
   # This class makes it easy to tell your user that the program is temporarily busy.
-  # Normally the main thread should always return to the main loop to continue dispatching events as quickly as possible, hence this class shouldn't be needed. However if the main thread does need to block, this class provides a simple way to at least show this to the user: just create a {Wx::BusyInfo} object on the stack, and within the current scope, a message window will be shown.
+  # Normally the main thread should always return to the main loop to continue dispatching events as quickly as possible,
+  # hence this class shouldn't be needed. However if the main thread does need to block, this class provides a simple
+  # way to at least show this to the user: just call {Wx::BusyInfo.busy} with a block and for the duration of the
+  # execution of the block a message window will be shown.
   # For example:
+  # ```ruby
+  #   BusyInfo.busy('Working, please wait...') do
+  #     100000.times { do_a_calculation }
+  #   end
+  # ```
   # 
-  #   wxBusyInfo wait("Please wait, working...");
-  #   
-  #   for (int i = 0; i < 100000; i++)
-  #   {
-  #       DoACalculation();
-  #   }
+  # The displayed window is rather plain by default but can be customized by passing {Wx::BusyInfo.busy} an object of
+  # {Wx::BusyInfoFlags} class instead of a simple message. Here is an example:
   # 
-  # It works by creating a window in the constructor, and deleting it in the destructor.
-  # This window is rather plain by default but can be customized by passing {Wx::BusyInfo} constructor an object of {Wx::BusyInfoFlags} class instead of a simple message. Here is an example from the dialogs sample:
-  # 
-  #   wxBusyInfo info
-  #       (
-  #           wxBusyInfoFlags()
-  #               .Parent(this)
-  #               .Icon(wxArtProvider::GetIcon(wxART_PRINT,
-  #                                            wxART_OTHER, wxSize(128, 128)))
-  #               .Title("<b>Printing your document</b>")
-  #               .Text("Please wait...")
-  #               .Foreground(*wxWHITE)
-  #               .Background(*wxBLACK)
-  #               .Transparency(4*wxALPHA_OPAQUE/5)
-  #       );
+  # ```ruby
+  #   Wx::BusyInfo.busy(
+  #     Wx::BusyInfoFlags.new
+  #       .parent(self)
+  #       .icon(Wx::ArtProvider.get_icon(Wx::ART_PRINT,Wx::ART_OTHER, [128, 128]))
+  #       .title("<b>Printing your document</b>")
+  #       .text("Please wait...")
+  #       .foreground(Wx::WHITE)
+  #       .background(Wx::BLACK)
+  #       .transparency(4*Wx::ALPHA_OPAQUE/5)) do |bi|
+  #   end
+  # ```
   # 
   # This shows that separate title and text can be set, and that simple markup ({Wx::Control#set_label_markup}) can be used in them, and that it's also possible to add an icon and customize the colours and transparency of the window.
-  # You may also want to call {Wx::TheApp}->Yield() to refresh the window periodically (in case it had been obscured by other windows, for example) like this:
-  # 
-  #   wxWindowDisabler disableAll;
-  #   wxBusyInfo wait("Please wait, working...");
-  #   
-  #   for (int i = 0; i < 100000; i++)
-  #   {
-  #       DoACalculation();
-  #   
-  #       if ( !(i % 1000) )
-  #           wxTheApp->Yield();
-  #   }
+  # You may also want to call `Wx.get_app.yield` to refresh the window periodically (in case it had been obscured by other windows, for example) like this:
+  # ```ruby
+  #   Wx::WindowDisabler.disable do
+  #     BusyInfo.busy('Working, please wait...') do
+  #       100000.times do |i| 
+  #         do_a_calculation }
+  #         Wx.get_app.yield if (i % 1000) == 0
+  #       end
+  #     end
+  #   end
+  # ```
   # 
-  # but take care to not cause undesirable reentrancies when doing it (see {Wx::App::Yield} for more details). The simplest way to do it is to use {Wx::WindowDisabler} class as illustrated in the above example.
+  # but take care to not cause undesirable re-entrance when doing it (see {Wx::App#yield} for more details). The simplest way to do it is to use {Wx::WindowDisabler} class as illustrated in the above example.
   # Note that a {Wx::BusyInfo} is always built with the {Wx::STAY_ON_TOP} window style (see {Wx::Frame} window styles for more info).
-  # === 
+  # 
+  # ===
   # 
   # Category:  Common Dialogs
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class BusyInfo < ::Object
   
     # Update the information text.
@@ -71,18 +74,21 @@ module Wx
   # Parameters for {Wx::BusyInfo}.
   # This class exists only in order to make passing attributes to {Wx::BusyInfo} constructor easier and the code doing it more readable.
   # All methods of this class return the reference to the object on which they are called, making it possible to chain them together, e.g. typically you would just create a temporary {Wx::BusyInfoFlags} object and then call the methods corresponding to the attributes you want to set, before finally passing the result to {Wx::BusyInfo} constructor, e.g.: 
+  # ```ruby
+  #   Wx::BusyInfo.busy(
+  #     Wx::BusyInfoFlags.new
+  #       .parent(self)
+  #       .icon(Wx::ArtProvider.get_icon(Wx::ART_PRINT,Wx::ART_OTHER, [128, 128]))
+  #       .title("<b>Printing your document</b>")
+  #       .text("Please wait...")
+  #       .foreground(Wx::WHITE)
+  #       .background(Wx::BLACK)
+  #       .transparency(4*Wx::ALPHA_OPAQUE/5)) do |bi|
+  #   end
+  # ```
   # 
-  #   wxBusyInfo info
-  #       (
-  #           wxBusyInfoFlags()
-  #               .Parent(window)
-  #               .Icon(icon)
-  #               .Title("Some text")
-  #               .Text("Some more text")
-  #               .Foreground(wxColour(...))
-  #               .Background(wxColour(...))
-  #       );
   # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class BusyInfoFlags < ::Object
   
     # Default constructor initializes all attributes to default values.

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

@@ -33,15 +33,11 @@ module Wx
     def create(window, size) end
     
     # Get the caret position (in pixels).
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} there are two methods instead of a single overloaded method:
-    # - {Wx::Caret#get_position}: returns a Wx::Point object.- GetPositionXY(): returns a 2-element list (x, y).
     # @return [Wx::Point]
     def get_position; end
     alias_method :position, :get_position
     
     # Get the caret size.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} there are two methods instead of a single overloaded method:
-    # - {Wx::Caret#get_size}: returns a Wx::Size object.- GetSizeWH(): returns a 2-element list (width, height).
     # @return [Wx::Size]
     def get_size; end
     alias_method :size, :get_size

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

@@ -31,7 +31,6 @@ module Wx
   
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=("listBox"))
     #   Constructor, creating and showing a list box.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}.
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
     #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} 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.
@@ -43,7 +42,6 @@ module Wx
     #   @return [CheckListBox]
     # @overload initialize(parent, id, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=("listBox"))
     #   Constructor, creating and showing a list box.
-    #   <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
     #   @param id [Integer]  Window identifier. The value {Wx::StandardID::ID_ANY} indicates a default value.
     #   @param pos [Array(Integer, Integer), Wx::Point]  Window position.

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

@@ -54,7 +54,7 @@ module Wx
     #   @return [Choice]
     # @overload initialize(parent, id, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ChoiceNameStr)
     #   Constructor, creating and showing a choice.
-    #   <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
+    #   
     #   @see Wx::Choice#create
     #   @see  Wx::Validator
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -87,10 +87,6 @@ module Wx
     def set_columns(n=1) end
     alias_method :columns=, :set_columns
     
-    # @return [true,false]
-    def is_sorted; end
-    alias_method :sorted?, :is_sorted
-    
     # Returns the number of items in the control.
     # 
     # @see Wx::Choice#is_empty 

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

@@ -8,18 +8,17 @@ module Wx
 
   # {Wx::ClientDC} is primarily useful for obtaining information about the window from outside EVT_PAINT() handler.
   # Typical use of this class is to obtain the extent of some text string in order to allocate enough size for a window, e.g. 
-  # 
-  #       // Create the initially empty label with the size big enough to show
-  #       // the given string.
-  #       wxClientDC dc(this);
-  #       wxStaticText* text = new wxStaticText
-  #           (
-  #               this, wxID_ANY, "",
-  #               wxPoint(),
-  #               dc.GetTextExtent("String of max length"),
-  #               wxST_NO_AUTORESIZE
-  #           );
-  #   }
+  # ```ruby
+  #    # Create the initially empty label with the size big enough to show
+  #    # the given string.
+  #    text = Wx::ClientDC.draw_on(self) do |dc|
+  #              Wx::StaticText.new(
+  #                      self, Wx::ID_ANY, "",
+  #                      Wx::Point.new,
+  #                      dc.get_text_extent("String of max length"),
+  #                      Wx::ST_NO_AUTORESIZE)
+  #           end
+  # ```
   # 
   # While {Wx::ClientDC} may also be used for drawing on the client area of a window from outside an EVT_PAINT() handler in some ports, this does not work on all platforms (neither {Wx::OSX} nor {Wx::GTK} with GTK 3 Wayland backend support this, so drawing using {Wx::ClientDC} simply doesn't have any effect there) and the only portable way of drawing is via {Wx::PaintDC}. To redraw a small part of the window, use {Wx::Window#refresh_rect} to invalidate just this part and check {Wx::Window#get_update_region} in the paint event handler to redraw this part only.
   # 
@@ -35,14 +34,10 @@ module Wx
   # @see  Wx::ScreenDC 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class ClientDC < WindowDC
   
-    # Constructor.
-    # Pass a pointer to the window on which you wish to paint.
-    # @param window [Wx::Window] 
-    # @return [ClientDC]
-    def initialize(window) end
-    
   end # ClientDC
   
 

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

@@ -7,42 +7,45 @@
 module Wx
 
   # A class for manipulating the clipboard.
-  # To use the clipboard, you call member functions of the global {Wx::TheClipboard} object.
-  # See the wxDataObject Overview for further information.
-  # Call {Wx::Clipboard#open} to get ownership of the clipboard. If this operation returns true, you now own the clipboard. Call {Wx::Clipboard#set_data} to put data on the clipboard, or {Wx::Clipboard#get_data} to retrieve data from the clipboard. Call {Wx::Clipboard#close} to close the clipboard and relinquish ownership. You should keep the clipboard open only momentarily.
+  # To use the clipboard, you call member functions of the global {Wx::Clipboard} object passed to the block for {Wx::Clipboard.open}.
+  # See the {Wx::DataObject} Overview for further information.
+  # Call {Wx::Clipboard.open} to get ownership of the (global) clipboard and execute the given block. You now 
+  # own the clipboard passed to the given block. Call {Wx::Clipboard#set_data} to put data on the clipboard, or 
+  # {Wx::Clipboard#get_data} to retrieve data from the clipboard. The clipboard is closed and ownership 
+  # relinquished when the block returns. You should keep the clipboard open only momentarily.
   # For example:
   # 
-  #   // Write some text to the clipboard
-  #   if (wxTheClipboard->Open())
-  #   {
-  #       // This data objects are held by the clipboard,
-  #       // so do not delete them in the app.
-  #       wxTheClipboard->SetData( new wxTextDataObject("Some text") );
-  #       wxTheClipboard->Close();
-  #   }
-  #   
-  #   // Read some text
-  #   if (wxTheClipboard->Open())
-  #   {
-  #       if (wxTheClipboard->IsSupported( wxDF_TEXT ))
-  #       {
-  #           wxTextDataObject data;
-  #           wxTheClipboard->GetData( data );
-  #           wxMessageBox( data.GetText() );
-  #       }
-  #       wxTheClipboard->Close();
-  #   }
+  # ```ruby
+  #   # Write some text to the clipboard
+  #   Wx::Clipboard.open do |clip|
+  #     # This data object is held by the clipboard
+  #     clip.place(Wx::TextDataObject.new("Some text"))
+  #     # or alternatively
+  #     # clip.set_data(Wx::TextDataObject.new("Some text"))
+  #   end
   # 
-  # On GTK, the clipboard behavior can vary depending on the configuration of the end-user's machine. In order for the clipboard data to persist after the window closes, a clipboard manager must be installed. Some clipboard managers will automatically flush the clipboard after each new piece of data is added, while others will not. The {Wx::Clipboard#flush} function will force the clipboard manager to flush the data.
+  #   # Read some text
+  #   data = Wx::TextDataObject.new
+  #   Wx::Clipboard.open do |clip|
+  #      if clip.supported?(Wx::DF_TEXT)
+  #        clip.fetch(data) # or clip.get_data(data)
+  #      end
+  #   end
+  #   Wx.message_box(data.get_text)
+  # ```
+  # 
+  # On GTK, the clipboard behavior can vary depending on the configuration of the end-user's machine. In order 
+  # for the clipboard data to persist after the window closes, a clipboard manager must be installed. Some 
+  # clipboard managers will automatically flush the clipboard after each new piece of data is added, while others 
+  # will not. The {Wx::Clipboard#flush} function will force the clipboard manager to flush the data.
   # 
   # === 
   # 
   # Category:  Clipboard and Drag & Drop
-  # @see Drag and Drop Overview
-  # @see  wxDataObject Overview
-  # @see  Wx::DataObject 
+  # @see  Wx::DataObject
   # 
   # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Clipboard < Object
   
     # Default constructor.

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

@@ -21,17 +21,19 @@ module Wx
   # Note that because of its nature of control which can dynamically (and drastically) change its size at run-time under user-input, when putting {Wx::CollapsiblePane} inside a {Wx::Sizer} you should be careful to add it with a proportion value of zero; this is because otherwise all other windows with non-null proportion values will automatically resize each time the user expands or collapse the pane window usually resulting in a weird, flickering effect.
   # Usage sample:
   # 
-  #   wxCollapsiblePane *collpane = new wxCollapsiblePane(this, wxID_ANY, "Details:");
+  # ```ruby
+  #   collpane = Wx::CollapsiblePane.new(self, Wx::ID_ANY, "Details:")
   #   
-  #   // add the pane with a zero proportion value to the 'sz' sizer which contains it
-  #   sz->Add(collpane, 0, wxGROW|wxALL, 5);
+  #   # add the pane with a zero proportion value to the 'sz' sizer which contains it
+  #   sz.add(collpane, 0, Wx::GROW|Wx::ALL, 5)
   #   
-  #   // now add a test label in the collapsible pane using a sizer to layout it:
-  #   wxWindow *win = collpane->GetPane();
-  #   wxSizer *paneSz = new wxBoxSizer(wxVERTICAL);
-  #   paneSz->Add(new wxStaticText(win, wxID_ANY, "test!"), 1, wxGROW|wxALL, 2);
-  #   win->SetSizer(paneSz);
-  #   paneSz->SetSizeHints(win);
+  #   #/ now add a test label in the collapsible pane using a sizer to layout it:
+  #   win = collpane.get_pane
+  #   pane_sz = Wx::VBoxSizer
+  #   pane_sz.add(Wx::StaticText.new(win, Wx::ID_ANY, "test!"), 1, Wx::GROW|Wx::ALL, 2)
+  #   win.set_sizer(pane_sz)
+  #   pane_sz.set_size_hints(win)
+  # ```
   # 
   # It is only available if {Wx::Setup::USE_COLLPANE} is set to 1 (the default).
   # === Styles

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

@@ -66,6 +66,8 @@ module Wx
   # @see  Wx::SystemSettings 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Colour < Object
   
     # Sets the RGB or RGBA colour values from a single 32 bit value.
@@ -111,11 +113,11 @@ module Wx
     #   @param blue [Integer] 
     #   @param alpha [Integer] 
     #   @return [void]
-    # @overload set(RGB)
+    # @overload set(rGB)
     #   Sets the RGB intensity values using the given values (first overload), extracting them from the packed long (second overload), using the given string (third overload).
     #   When using third form, {Wx::Colour#set} accepts: colour names (those listed in {Wx::ColourDatabase}), the CSS-like <code>"rgb(r,g,b)"</code> or <code>"rgba(r,g,b,a)"</code> syntax (case insensitive) and the HTML-like syntax: <code>"#"</code> followed by 6 hexadecimal digits for red, green, blue components.
     #   Returns true if the conversion was successful, false otherwise.
-    #   @param RGB [Integer] 
+    #   @param rGB [Integer] 
     #   @return [void]
     # @overload set(str)
     #   Sets the RGB intensity values using the given values (first overload), extracting them from the packed long (second overload), using the given string (third overload).
@@ -185,8 +187,9 @@ module Wx
     
     # Return the perceived brightness of the colour.
     # This value is computed using the simple 
-    # 
+    # ```
     #   0.299*R + 0.587*G + 0.114*B 
+    # ```
     #  formula with the coefficients taken from the RGB to YIQ conversion formula and R, G and B being the values of the corresponding colour channels normalized to 0..1 range, so that the return value is 0 for black and 1 for white.
     # @return [Float]
     def get_luminance; end

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

@@ -21,30 +21,30 @@ module Wx
   # This class represents the colour chooser dialog.
   # Starting from wxWidgets 3.1.3 and currently in the MSW port only, this dialog generates {Wx::EVT_COLOUR_CHANGED} events while it is being shown, i.e. from inside its {Wx::ColourDialog#show_modal} method, that notify the program about the change of the currently selected colour and allow it to e.g. preview the effect of selecting this colour. Note that if you react to this event, you should also correctly revert to the previously selected colour if the dialog is cancelled by the user.
   # Example of using this class with dynamic feedback for the selected colour: 
+  # ```ruby
+  #   # Some function for redrawing using the given colour. Ideally, it
+  #   # shouldn't do anything if the colour is the same as the one used
+  #   # before.
+  #   # def redraw(colour) ... end
   # 
-  #   // Some function for redrawing using the given colour. Ideally, it
-  #   // shouldn't do anything if the colour is the same as the one used
-  #   // before.
-  #   void Redraw(const wxColour& colour);
-  #   
-  #   wxColourData data;
-  #   data.SetColour(initialColourToUse);
-  #   wxColourData dlg(this, &data);
-  #   dlg.Bind(wxEVT_COLOUR_CHANGED, [](wxColourDialogEvent& event) {
-  #               Redraw(event.GetColour());
-  #            });
-  #   if ( dlg.ShowModal() == wxID_OK ) {
-  #       // Colour did change.
-  #   } else {
-  #       // Colour didn't change.
-  #   }
-  #   
-  #   // This call is unnecessary under platforms generating
-  #   // wxEVT_COLOUR_CHANGED if the dialog was accepted and unnecessary
-  #   // under the platforms not generating this event if it was cancelled,
-  #   // so we could check for the different cases explicitly to avoid it,
-  #   // but it's simpler to just always call it.
-  #   Redraw(data.GetColour());
+  #   data = Wx::ColourData.new
+  #   data.set_colour(initialColourToUse)
+  #   Wx::ColourDialog(self, data) do |dlg|
+  #     dlg.evt_colour_changed { |event| redraw(event.get_colour) }
+  #     if dlg.show_modal == Wx::ID_OK
+  #        # Colour did change.
+  #     else
+  #        # Colour didn't change.
+  #     end
+  #   end
+  # 
+  #   # This call is unnecessary under platforms generating
+  #   # Wx::EVT_COLOUR_CHANGED if the dialog was accepted and unnecessary
+  #   # under the platforms not generating this event if it was cancelled,
+  #   # so we could check for the different cases explicitly to avoid it,
+  #   # but it's simpler to just always call it.
+  #   redraw(data.get_colour)
+  # ```
   # 
   # === 
   # 
@@ -79,5 +79,93 @@ module Wx
     
   end # ColourDialog
   
+  # This class holds a variety of information related to colour dialogs.
+  # === 
+  # 
+  # Category:  Common Dialogs, Data Structures
+  # @see Wx::Colour
+  # @see  Wx::ColourDialog
+  # @see  wxColourDialog Overview 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class ColourData < Object
+  
+    # 
+    # 
+    NUM_CUSTOM = 16
+    
+    # Constructor.
+    # Initializes the custom colours to {Wx::NULL_COLOUR}, the data colour setting to black, and the choose full setting to true.
+    # @return [ColourData]
+    def initialize; end
+    
+    # Under Windows, determines whether the Windows colour dialog will display the full dialog with custom colour selection controls.
+    # Has no meaning under other platforms.
+    # The default value is true.
+    # @return [true,false]
+    def get_choose_full; end
+    alias_method :choose_full, :get_choose_full
+    
+    # Indicates whether the colour dialog will display alpha values and an opacity selector.
+    # It is meaningful under {Wx::GTK}, {Wx::OSX} and with regards to generic colour dialog.
+    # The default value is false, except {Wx::OSX} where it is true (for the sake of backward compatibility).
+    # @return [true,false]
+    def get_choose_alpha; end
+    alias_method :choose_alpha, :get_choose_alpha
+    
+    # Gets the current colour associated with the colour dialog.
+    # The default colour is black.
+    # @return [Wx::Colour]
+    def get_colour; end
+    alias_method :colour, :get_colour
+    
+    # Returns custom colours associated with the colour dialog.
+    # @param i [Integer]  An integer between 0 and 15, being any of the 15 custom colours that the user has saved. The default custom colours are invalid colours.
+    # @return [Wx::Colour]
+    def get_custom_colour(i) end
+    alias_method :custom_colour, :get_custom_colour
+    
+    # Under Windows, tells the Windows colour dialog to display the full dialog with custom colour selection controls.
+    # Under other platforms, has no effect.
+    # The default value is true.
+    # @param flag [true,false] 
+    # @return [void]
+    def set_choose_full(flag) end
+    alias_method :choose_full=, :set_choose_full
+    
+    # Tells the colour dialog to show alpha values and an opacity selector (slider).
+    # Currently it has effect under {Wx::GTK}, {Wx::OSX} and for generic colour dialog.
+    # The default value is false, except {Wx::OSX} where it is true for backward compatibility.
+    # @param flag [true,false] 
+    # @return [void]
+    def set_choose_alpha(flag) end
+    alias_method :choose_alpha=, :set_choose_alpha
+    
+    # Sets the default colour for the colour dialog.
+    # The default colour is black.
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_colour(colour) end
+    alias_method :colour=, :set_colour
+    
+    # Sets custom colours for the colour dialog.
+    # @param i [Integer]  An integer between 0 and 15 for whatever custom colour you want to set. The default custom colours are invalid colours.
+    # @param colour [Wx::Colour,String,Symbol]  The colour to set
+    # @return [void]
+    def set_custom_colour(i, colour) end
+    
+    # Converts the colours saved in this class in a string form, separating the various colours with a comma.
+    # @return [String]
+    def to_string; end
+    
+    # Decodes the given string, which should be in the same format returned by {Wx::ColourData#to_string}, and sets the internal colours.
+    # @param str [String] 
+    # @return [true,false]
+    def from_string(str) end
+    
+  end # ColourData
+  
 
 end

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

@@ -80,7 +80,7 @@ module Wx
     #   @return [ComboBox]
     # @overload initialize(parent, id, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr)
     #   Constructor, creating and showing a combobox.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}.
+    #   
     #   @see Wx::ComboBox#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -95,7 +95,7 @@ module Wx
     #   @return [ComboBox]
     # @overload initialize(parent, id, value, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ComboBoxNameStr)
     #   Constructor, creating and showing a combobox.
-    #   <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
+    #   
     #   @see Wx::ComboBox#create
     #   @see  Wx::Validator 
     #   @param parent [Wx::Window]  Parent window. Must not be NULL.
@@ -180,8 +180,6 @@ module Wx
     
     # Gets the current selection span.
     # If the returned values are equal, there was no selection. Please note that the indices returned may be used with the other {Wx::TextCtrl} methods but don't necessarily represent the correct indices into the string returned by {Wx::ComboBox#get_value} for multiline controls under Windows (at least,) you should use {Wx::ComboBox#get_string_selection} to get the selected text.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and returns a 2-element list (from, to).
     # @return [Array(Integer,Integer)]
     def get_text_selection_range; end
     alias_method :text_selection_range, :get_text_selection_range

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

@@ -30,5 +30,53 @@ module Wx
     
   end # ContextHelpButton
   
+  # This class changes the cursor to a query and puts the application into a 'context-sensitive help mode'.
+  # When the user left-clicks on a window within the specified window, a {Wx::EVT_HELP} event is sent to that control, and the application may respond to it by popping up some help.
+  # For example: 
+  # ```ruby
+  #   # puts the application into a 'context-sensitive help mode' for my_window
+  #   context_help = Wx::ContextHelp.new(my_window)
+  #   ...
+  #   ...
+  #   # ends the 'context-sensitive help mode' for my_window
+  #   context_help.end_context_help            
+  # ```
+  # 
+  # There are a couple of ways to invoke this behaviour implicitly:
+  # 
+  # - Use the {Wx::DIALOG_EX_CONTEXTHELP} style for a dialog (Windows only). This will put a question mark in the titlebar, and Windows will put the application into context-sensitive help mode automatically, with further programming.- Create a {Wx::ContextHelpButton}, whose predefined behaviour is to create a context help object. Normally you will write your application so that this button is only added to a dialog for non-Windows platforms (use {Wx::DIALOG_EX_CONTEXTHELP} on Windows).
+  # 
+  # Note that on macOS, the cursor does not change when in context-sensitive help mode.
+  # === 
+  # 
+  # Category:  {Wx::HELP}
+  # @see Wx::HelpEvent
+  # @see  Wx::HelpController
+  # @see  Wx::ContextHelpButton 
+  # 
+  # 
+  class ContextHelp < Object
+  
+    # Constructs a context help object, calling {Wx::ContextHelp#begin_context_help} if doNow is true (the default).
+    # If window is NULL, the top window is used.
+    # @param window [Wx::Window] 
+    # @param doNow [true,false] 
+    # @return [ContextHelp]
+    def initialize(window=nil, doNow=true) end
+    
+    # Puts the application into context-sensitive help mode.
+    # window is the window which will be used to catch events; if NULL, the top window will be used.
+    # Returns true if the application was successfully put into context-sensitive help mode. This function only returns when the event loop has finished.
+    # @param window [Wx::Window] 
+    # @return [true,false]
+    def begin_context_help(window) end
+    
+    # Ends context-sensitive help mode.
+    # Not normally called by the application.
+    # @return [true,false]
+    def end_context_help; end
+    
+  end # ContextHelp
+  
 
 end