wxruby3 0.9.0.pre.beta.13-x64-mingw-ucrt → 0.9.0.pre.rc.1-x64-mingw-ucrt

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

@@ -0,0 +1,157 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A combobox that displays bitmap in front of the list items.
+  # It currently only allows using bitmaps of one size, and resizes itself so that a bitmap can be shown next to the text field.
+  # While {Wx::BitmapComboBox} contains the {Wx::ComboBox} API, but it might not actually be derived from that class. In fact, if the platform does not have a native implementation, {Wx::BitmapComboBox} will inherit from {Wx::OwnerDrawnComboBox}. You can determine if the implementation is generic by checking whether {Wx::GENERIC_BITMAPCOMBOBOX} is defined. Currently {Wx::BitmapComboBox} is implemented natively for MSW and GTK+.
+  # 
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::CB_READONLY}: Creates a combobox without a text editor. On some platforms the control may appear very different when this style is used. 
+  # - {Wx::CB_SORT}: Sorts the entries in the list alphabetically. 
+  # - {Wx::TE_PROCESS_ENTER}: The control will generate the event {Wx::EVT_TEXT_ENTER} (otherwise pressing Enter key is either processed internally by the control or used for navigation between dialog controls). Windows only. 
+  # 
+  # Todocreate {Wx::CB_PROCESS_ENTER} rather than reusing {Wx::TE_PROCESS_ENTER}!
+  # 
+  # === Events emitted by this class
+  # 
+  # The following event-handler methods redirect the events to member method or handler blocks for {Wx::CommandEvent} events.
+  # Event handler methods for events emitted by this class:
+  # - {Wx::EvtHandler#evt_combobox}(id, meth = nil, &block): Process a {Wx::EVT_COMBOBOX} event, when an item on the list is selected. 
+  # - {Wx::EvtHandler#evt_text}(id, meth = nil, &block): Process a {Wx::EVT_TEXT} event, when the combobox text changes. 
+  # - {Wx::EvtHandler#evt_text_enter}(id, meth = nil, &block): Process a {Wx::EVT_TEXT_ENTER} event, when RETURN is pressed in the combobox. 
+  # 
+  # === 
+  # 
+  # 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::ComboBox
+  # @see  Wx::Choice
+  # @see  Wx::OwnerDrawnComboBox
+  # @see  Wx::CommandEvent 
+  # 
+  # 
+  class BitmapComboBox < ComboBox
+  
+    # @overload initialize()
+    #   Default ctor.
+    #   @return [BitmapComboBox]
+    # @overload initialize(parent, id=Wx::StandardID::ID_ANY, value=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
+    #   Constructor, creating and showing a combobox.
+    #   
+    #   @see Wx::BitmapComboBox#create
+    #   @see  Wx::Validator 
+    #   @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 value [String]  Initial selection string. An empty string indicates no selection.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Initial position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Initial size.
+    #   @param choices [Array<String>]  An array of strings with which to initialise the control.
+    #   @param style [Integer]  The window style, see {Wx::CB_}* flags.
+    #   @param validator [Wx::Validator]  Validator which can be used for additional data checks.
+    #   @param name [String]  Control name.
+    #   @return [BitmapComboBox]
+    # @overload initialize(parent, id, value, pos, size, choices, style, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
+    #   Constructor, creating and showing a combobox.
+    #   
+    #   @see Wx::BitmapComboBox#create
+    #   @see  Wx::Validator 
+    #   @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 value [String]  Initial selection string. An empty string indicates no selection.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Initial position.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Initial size.
+    #   @param choices [Array<String>]  A {Wx::ArrayString} with which to initialise the control.
+    #   @param style [Integer]  The window style, see {Wx::CB_}* flags.
+    #   @param validator [Wx::Validator]  Validator which can be used for additional data checks.
+    #   @param name [String]  Control name.
+    #   @return [BitmapComboBox]
+    def initialize(*args) end
+    
+    # @overload append(item, bitmap=Wx::NULL_BITMAP)
+    #   Adds the item to the end of the combo box.
+    #   @param item [String] 
+    #   @param bitmap [Wx::Bitmap] 
+    #   @return [Integer]
+    # @overload append(item, bitmap, clientData)
+    #   Adds the item to the end of the combo box, associating the given untyped, client data pointer clientData with the item.
+    #   @param item [String] 
+    #   @param bitmap [Wx::Bitmap] 
+    #   @param clientData [Object] 
+    #   @return [Integer]
+    def append(*args) end
+    
+    # @overload create(parent, id, value, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
+    #   Creates the combobox for two-step construction.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param value [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param choices [Array<String>] 
+    #   @param style [Integer] 
+    #   @param validator [Wx::Validator] 
+    #   @param name [String] 
+    #   @return [true,false]
+    # @overload create(parent, id, value, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BitmapComboBoxNameStr)
+    #   Creates the combobox for two-step construction.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param value [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param choices [Array<String>] 
+    #   @param style [Integer] 
+    #   @param validator [Wx::Validator] 
+    #   @param name [String] 
+    #   @return [true,false]
+    def create(*args) end
+    
+    # Returns the size of the bitmaps used in the combo box.
+    # If the combo box is empty, then {Wx::DEFAULT_SIZE} is returned.
+    # @return [Wx::Size]
+    def get_bitmap_size; end
+    alias_method :bitmap_size, :get_bitmap_size
+    
+    # Returns the bitmap of the item with the given index.
+    # @param n [Integer] 
+    # @return [Wx::Bitmap]
+    def get_item_bitmap(n) end
+    alias_method :item_bitmap, :get_item_bitmap
+    
+    # @overload insert(item, bitmap, pos)
+    #   Inserts the item into the list before pos.
+    #   Not valid for {Wx::CB_SORT} style, use {Wx::BitmapComboBox#append} instead.
+    #   @param item [String] 
+    #   @param bitmap [Wx::Bitmap] 
+    #   @param pos [Integer] 
+    #   @return [Integer]
+    # @overload insert(item, bitmap, pos, clientData)
+    #   Inserts the item into the list before pos, associating the given untyped, client data pointer with the item.
+    #   Not valid for {Wx::CB_SORT} style, use {Wx::BitmapComboBox#append} instead.
+    #   @param item [String] 
+    #   @param bitmap [Wx::Bitmap] 
+    #   @param pos [Integer] 
+    #   @param clientData [Object] 
+    #   @return [Integer]
+    def insert(*args) end
+    
+    # Sets the bitmap for the given item.
+    # @param n [Integer] 
+    # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
+    # @return [void]
+    def set_item_bitmap(n, bitmap) end
+    
+  end # BitmapComboBox
+  
+
+end

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

@@ -25,15 +25,13 @@ module Wx
     
     # Adds non-stretchable space to the main orientation of the sizer only.
     # More readable way of calling: 
-    # 
-    #   if ( wxBoxSizer::IsVertical() )
-    #   {
-    #       wxBoxSizer::Add(0, size, 0).
-    #   }
+    # ```ruby
+    #   if box_sizer.vertical?
+    #     box_sizer.add(0, size, 0)
     #   else
-    #   {
-    #       wxBoxSizer::Add(size, 0, 0).
-    #   }
+    #     box_size.add(size, 0, 0)
+    #   end
+    # ```
     # @param size [Integer] 
     # @return [Wx::SizerItem]
     def add_spacer(size) end

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