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

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

@@ -522,33 +522,40 @@ module Wx
   # In either case, if the style doesn't specify some of the attributes (for example you only want to set the text colour but without changing the font nor the text background), the values of the default style will be used for them. If there is no default style, the attributes of the text control itself are used.
   # So the following code correctly describes what it does: the second call to {Wx::TextCtrl#set_default_style} doesn't change the text foreground colour (which stays red) while the last one doesn't change the background colour (which stays grey):
   # 
+  # ```
   #   text->SetDefaultStyle(wxTextAttr(*wxRED));
   #   text->AppendText("Red text\n");
   #   text->SetDefaultStyle(wxTextAttr(wxNullColour, *wxLIGHT_GREY));
   #   text->AppendText("Red on grey text\n");
   #   text->SetDefaultStyle(wxTextAttr(*wxBLUE));
   #   text->AppendText("Blue on grey text\n");
+  # ```
   # 
   # == wxTextCtrl and C++ Streams
   # 
   # This class multiply-inherits from std::streambuf (except for some really old compilers using non-standard iostream library), allowing code such as the following:
   # 
+  # ```
   #   wxTextCtrl *control = new wxTextCtrl(...);
   #   
   #   ostream stream(control)
   #   
   #   stream << 123.456 << " some text\n";
   #   stream.flush();
+  # ```
   # 
   # Note that even if your build of wxWidgets doesn't support this (the symbol {Wx::HAS_TEXT_WINDOW_STREAM} has value of 0 then) you can still use {Wx::TextCtrl} itself in a stream-like manner:
   # 
+  # ```
   #   wxTextCtrl *control = new wxTextCtrl(...);
   #   
   #   *control << 123.456 << " some text\n";
+  # ```
   # 
   # However the possibility to create a std::ostream associated with {Wx::TextCtrl} may be useful if you need to redirect the output of a function taking a std::ostream as parameter to a text control.
   # Another commonly requested need is to redirect std::cout to the text control. This may be done in the following way:
   # 
+  # ```
   #   #include <iostream>
   #   
   #   wxTextCtrl *control = new wxTextCtrl(...);
@@ -560,9 +567,11 @@ module Wx
   #   ...
   #   
   #   std::cout.rdbuf(sbOld);
+  # ```
   # 
   # But wxWidgets provides a convenient class to make it even simpler so instead you may just do
   # 
+  # ```
   #   #include <iostream>
   #   
   #   wxTextCtrl *control = new wxTextCtrl(...);
@@ -571,6 +580,7 @@ module Wx
   #   
   #   // all output to cout goes into the text control until the exit from
   #   // current scope
+  # ```
   # 
   # See {Wx::StreamToTextRedirector} for more details.
   # 
@@ -708,7 +718,6 @@ module Wx
     # Finds the row and column of the character at the specified point.
     # If the return code is not {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} the row and column of the character closest to this position are returned, otherwise the output parameters are not modified.
     # Please note that this function is currently only implemented in {Wx::Univ}, {Wx::MSW} and {Wx::GTK} ports and always returns {Wx::TextCtrlHitTestResult::TE_HT_UNKNOWN} in the other ports.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pt argument and returns a 3-element list (result, col, row).
     # @see Wx::TextCtrl#position_to_xy
     # @see  Wx::TextCtrl#xy_to_position 
     # @param pt [Array(Integer, Integer), Wx::Point]  The position of the point to check, in window device coordinates.
@@ -765,8 +774,6 @@ module Wx
     
     # Converts given position to a zero-based column, line number pair.
     # true on success, false on failure (most likely due to a too large position parameter).
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this function takes only the pos argument and returns a 2-element list (x, y).
     # @see Wx::TextCtrl#xy_to_position 
     # @param pos [Integer]  Position.
     # @return [Array(Integer, Integer), nil]

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

@@ -135,6 +135,7 @@ module Wx
     # Notice that insertion position is, in general, different from the index of the character the cursor position at in the string returned by {Wx::TextEntry#get_value}. While this is always the case for the single line controls, multi-line controls can use two characters <code>"\\r\\n"</code> as line separator (this is notably the case under MSW) meaning that indices in the control and its string value are offset by 1 for every line.
     # Hence to correctly get the character at the current cursor position, taking into account that there can be none if the cursor is at the end of the string, you could do the following:
     # 
+    # ```
     #   wxString GetCurrentChar(wxTextCtrl *tc)
     #   {
     #       long pos = tc->GetInsertionPoint();
@@ -143,6 +144,7 @@ module Wx
     #   
     #       return tc->GetRange(pos, pos + 1);
     #   }
+    # ```
     # @return [Integer]
     def get_insertion_point; end
     alias_method :insertion_point, :get_insertion_point
@@ -162,8 +164,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::TextEntry#get_value} for multiline controls under Windows (at least,) you should use {Wx::TextEntry#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_selection; end
     alias_method :selection, :get_selection
@@ -317,6 +317,8 @@ module Wx
   # Custom completer objects used with {Wx::TextEntry#auto_complete} must derive from this class and implement its pure virtual method returning the completions. You would typically use a custom completer when the total number of completions is too big for performance to be acceptable if all of them need to be returned at once but if they can be generated hierarchically, i.e. only the first component initially, then the second one after the user finished entering the first one and so on.
   # When inheriting from this class you need to implement its two pure virtual methods. This allows returning the results incrementally and may or not be convenient depending on where do they come from. If you prefer to return all the completions at once, you should inherit from {Wx::TextCompleterSimple} instead.
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class TextCompleter < ::Object
   
     # Function called to start iteration over the completions for the given prefix.
@@ -341,7 +343,7 @@ module Wx
   # A simpler base class for custom completer objects.
   # This class may be simpler to use than the base {Wx::TextCompleter} as it allows to implement only a single virtual method instead of two of them (at the price of storing all completions in a temporary array).
   # Here is a simple example of a custom completer that completes the names of some chess pieces. Of course, as the total list here has only four items it would have been much simpler to just specify the array containing all the completions in this example but the same approach could be used when the total number of completions is much higher provided the number of possibilities for each word is still relatively small: 
-  # 
+  # ```
   #   class MyTextCompleter : public wxTextCompleterSimple
   #   {
   #   public:
@@ -368,9 +370,12 @@ module Wx
   #   ...
   #   wxTextCtrl *text = ...;
   #   text->AutoComplete(new MyTextCompleter);
+  # ```
   # 
   # ===
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class TextCompleterSimple < TextCompleter
   
     # Pure virtual method returning all possible completions for the given prefix.

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

@@ -53,7 +53,7 @@ module Wx
     # @overload set_text_validator(validator)
     #   Associate a validator with the text control used by the dialog.
     #   These methods can be used to limit the user entry to only some characters, e.g. 
-    #   
+    #   ```
     #     wxTextEntryDialog dlg(this, ...);
     #     dlg.SetTextValidator(wxFILTER_ALPHA);
     #     if ( dlg.ShowModal() == wxID_OK )
@@ -61,6 +61,7 @@ module Wx
     #         // We can be certain that this string contains letters only.
     #         wxString value = dlg.GetValue();
     #     }
+    #   ```
     #   
     #   The first overload uses the provided validator which can be of a custom class derived from {Wx::TextValidator} while the second one creates a {Wx::TextValidator} with the specified style.
     #   @param validator [Wx::TextValidator] 
@@ -68,7 +69,7 @@ module Wx
     # @overload set_text_validator(style=Wx::TextValidatorStyle::FILTER_NONE)
     #   Associate a validator with the text control used by the dialog.
     #   These methods can be used to limit the user entry to only some characters, e.g. 
-    #   
+    #   ```
     #     wxTextEntryDialog dlg(this, ...);
     #     dlg.SetTextValidator(wxFILTER_ALPHA);
     #     if ( dlg.ShowModal() == wxID_OK )
@@ -76,6 +77,7 @@ module Wx
     #         // We can be certain that this string contains letters only.
     #         wxString value = dlg.GetValue();
     #     }
+    #   ```
     #   
     #   The first overload uses the provided validator which can be of a custom class derived from {Wx::TextValidator} while the second one creates a {Wx::TextValidator} with the specified style.
     #   @param style [TextValidatorStyle] 

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

@@ -19,6 +19,7 @@ module Wx
   # {Wx::TimerEvent} object is passed to the event handler of timer events (see {Wx::Timer#set_owner}).
   # For example:
   # 
+  # ```
   #   class MyFrame : public wxFrame
   #   {
   #   public:
@@ -44,6 +45,7 @@ module Wx
   #   {
   #       // do whatever you want to do every second here
   #   }
+  # ```
   # 
   # === 
   # 

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

@@ -96,14 +96,17 @@ module Wx
   # Note that many methods in {Wx::ToolBar} such as {Wx::ToolBar#add_tool} return a <code>wxToolBarToolBase*</code> object. This should be regarded as an opaque handle representing the newly added toolbar item, providing access to its id and position within the toolbar. Changes to the item's state should be made through calls to {Wx::ToolBar} methods, for example {Wx::ToolBar#enable_tool}. Calls to {Wx::ToolBarToolBase} methods (undocumented by purpose) will not change the visible state of the item within the tool bar.
   # After you have added all the tools you need, you must call {Wx::ToolBar#realize} to effectively construct and display the toolbar.
   # <b>{Wx::MSW} note</b>: Note that under {Wx::MSW} toolbar paints tools to reflect system-wide colours. If you use more than 16 colours in your tool bitmaps, you may wish to suppress this behaviour, otherwise system colours in your bitmaps will inadvertently be mapped to system colours. To do this, set the msw.remap system option before creating the toolbar: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption("msw.remap", 0);
+  # ```
   #  If you wish to use 32-bit images (which include an alpha channel for transparency) use: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption("msw.remap", 2);
+  # ```
   #  Then colour remapping is switched off, and a transparent background used. But only use this option under Windows XP with true colour: 
-  # 
+  # ```
   #   if (wxTheApp->GetComCtl32Version() >= 600 && ::wxDisplayDepth() >= 32)
+  # ```
   # 
   # === Styles
   # 
@@ -506,11 +509,12 @@ module Wx
     # It is usually unnecessary to call this function, as the tools will always be made big enough to fit the size of the bitmaps used in them. Moreover, calling it forces {Wx::ToolBar} to scale its images in high DPI using the provided size, instead of letting {Wx::BitmapBundle} used for the tool bitmaps determine the best suitable bitmap size, which may result in suboptimal appearance.
     # If you do call it, it must be done before toolbar is {Wx::ToolBar#realize}'d.
     # Example of using this function to force the bitmaps to be at least 32 pixels wide and tall (at normal DPI): 
-    # 
+    # ```
     #   toolbar->SetToolBitmapSize(FromDIP(wxSize(32, 32)));
     #   toolbar->AddTool(wxID_NEW, "New", wxBitmapBundle::FromXXX(...));
     #   ...
     #   toolbar->Realize();
+    # ```
     # @see Wx::ToolBar#get_tool_bitmap_size
     # @see  Wx::ToolBar#get_tool_size 
     # @param size [Array(Integer, Integer), Wx::Size]  The size of the bitmaps in the toolbar in logical pixels.

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

@@ -164,7 +164,7 @@ module Wx
     # Returns all icons associated with the window, there will be none of them if neither {Wx::TopLevelWindow#set_icon} nor {Wx::TopLevelWindow#set_icons} had been called before.
     # Use {Wx::TopLevelWindow#get_icon} to get the main icon of the window.
     # @see Wx::IconBundle 
-    # @return [void]
+    # @return [Wx::IconBundle]
     def get_icons; end
     alias_method :icons, :get_icons
     
@@ -239,8 +239,9 @@ module Wx
     # Notice that because of the native system limitations the identifiers of the items added to the system menu must be multiples of 16, otherwise no events will be generated for them.
     # The returned pointer must not be deleted, it is owned by the window and will be only deleted when the window itself is destroyed.
     # This function is not available in the other ports by design, any occurrences of it in the portable code must be guarded by 
-    # 
+    # ```
     #   #ifdef __WXMSW__ 
+    # ```
     #  preprocessor guards.
     # @return [Wx::Menu]
     def msw_get_system_menu; end
@@ -434,9 +435,11 @@ module Wx
     # This method is specific to {Wx::Universal} port.
     # Use native or custom-drawn decorations for this window only. Notice that to have any effect this method must be called before really creating the window, i.e. two step creation must be used:
     # 
+    # ```
     #   MyFrame *frame = new MyFrame;       // use default ctor
     #   frame->UseNativeDecorations(false); // change from default "true"
     #   frame->Create(parent, title, ...);  // really create the frame
+    # ```
     # @see Wx::TopLevelWindow#use_native_decorations_by_default
     # @see  Wx::TopLevelWindow#is_using_native_decorations 
     # @param native [true,false] 

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

@@ -437,7 +437,6 @@ module Wx
     # If textOnly is true, only the rectangle around the item's label will be returned, otherwise the item's image is also taken into account.
     # The return value is true if the rectangle was successfully retrieved or <code></code> false if it was not (in this case rect is not changed)  for example, if the item is currently invisible.
     # Notice that the rectangle coordinates are logical, not physical ones. So, for example, the x coordinate may be negative if the tree has a horizontal scrollbar and its position is not 0.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method only takes the item and textOnly parameters and returns a Wx::Rect (or undef).
     # @param item [Wx::TreeItemId] 
     # @param rect [Wx::Rect] 
     # @param textOnly [true,false] 
@@ -504,7 +503,6 @@ module Wx
     alias_method :item_background_colour, :get_item_background_colour
     
     # Returns the tree item data associated with the item.
-    # <b>{Wx::Perl} Note:</b> {Wx::Perl} provides the following shortcut method:
     # - GetPlData(item): returns the Perl data associated with the Wx::TreeItemData. It is just the same as tree->GetItemData(item)->GetData().
     # @see Wx::TreeItemData
     # @param item [Wx::TreeItemId] 
@@ -619,8 +617,6 @@ module Wx
     # flags is a bitlist of the following:
     # 
     # - {Wx::TREE_HITTEST_ABOVE}: Above the client area.- {Wx::TREE_HITTEST_BELOW}: Below the client area.- {Wx::TREE_HITTEST_NOWHERE}: In the client area but below the last item.- {Wx::TREE_HITTEST_ONITEMBUTTON}: On the button associated with an item.- {Wx::TREE_HITTEST_ONITEMICON}: On the bitmap associated with an item.- {Wx::TREE_HITTEST_ONITEMINDENT}: In the indentation associated with an item.- {Wx::TREE_HITTEST_ONITEMLABEL}: On the label (string) associated with an item.- {Wx::TREE_HITTEST_ONITEMRIGHT}: In the area to the right of an item.- {Wx::TREE_HITTEST_ONITEMSTATEICON}: On the state icon for a tree view item that is in a user-defined state.- {Wx::TREE_HITTEST_TOLEFT}: To the right of the client area.- {Wx::TREE_HITTEST_TORIGHT}: To the left of the client area.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method only takes the point parameter and returns a 2-element list (item, flags).
     # @param point [Array(Integer, Integer), Wx::Point] 
     # @return [Array(Wx::TreeItemId,Integer)]
     def hit_test(point) end
@@ -736,8 +732,6 @@ module Wx
     
     # Sets the item client data.
     # Notice that the client data previously associated with the item (if any) is not freed by this function and so calling this function multiple times for the same item will result in memory leaks unless you delete the old item data pointer yourself.
-    # <b>{Wx::Perl} Note:</b> {Wx::Perl} provides the following shortcut method:
-    # - SetPlData(item, data): sets the Perl data associated with the Wx::TreeItemData. It is just the same as tree->GetItemData(item)->SetData(data).
     # @param item [Wx::TreeItemId] 
     # @param data [Object] 
     # @return [void]

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

@@ -0,0 +1,100 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # {Wx::UIActionSimulator} is a class used to simulate user interface actions such as a mouse click or a key press.
+  # Common usage for this class would be to provide playback and record (aka macro recording) functionality for users, or to drive unit tests by simulating user sessions.
+  # See the wxUIActionSimulator Sample for an example of using this class.
+  # 
+  # ===
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class UIActionSimulator < ::Object
+  
+    # Default constructor.
+    # @return [UIActionSimulator]
+    def initialize; end
+    
+    # @overload mouse_move(x, y)
+    #   Move the mouse to the specified coordinates.
+    #   @param x [Integer]  x coordinate to move to, in screen coordinates.
+    #   @param y [Integer]  y coordinate to move to, in screen coordinates.
+    #   @return [true,false]
+    # @overload mouse_move(point)
+    #   Move the mouse to the specified coordinates.
+    #   @param point [Array(Integer, Integer), Wx::Point]  Point to move to, in screen coordinates.
+    #   @return [true,false]
+    def mouse_move(*args) end
+    
+    # Press a mouse button.
+    # @param button [Integer]  Button to press. Valid constants are {Wx::MOUSE_BTN_LEFT}, {Wx::MOUSE_BTN_MIDDLE}, and {Wx::MOUSE_BTN_RIGHT}.
+    # @return [true,false]
+    def mouse_down(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Release a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_up(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Click a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_click(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Double-click a mouse button.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_dbl_click(button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Perform a drag and drop operation.
+    # @param x1 [Integer]  x start coordinate, in screen coordinates.
+    # @param y1 [Integer]  y start coordinate, in screen coordinates.
+    # @param x2 [Integer]  x destination coordinate, in screen coordinates.
+    # @param y2 [Integer]  y destination coordinate, in screen coordinates.
+    # @param button [Integer]  Button to press. See {Wx::UIActionSimulator#mouse_down} for a list of valid constants.
+    # @return [true,false]
+    def mouse_drag_drop(x1, y1, x2, y2, button=Wx::MOUSE_BTN_LEFT) end
+    
+    # Press a key.
+    # If you are using modifiers then it needs to be paired with an identical KeyUp or the modifiers will not be released (MSW and macOS).
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def key_down(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Release a key.
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def key_up(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Press and release a key.
+    # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
+    # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
+    # @return [true,false]
+    def char(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
+    
+    # Simulate selection of an item with the given text.
+    # This method selects an item in the currently focused {Wx::Choice}, {Wx::ComboBox}, {Wx::ListBox} and similar controls. It does it by simulating keyboard events, so the behaviour should be the same as if the item was really selected by the user.
+    # Notice that the implementation of this method uses {yield} and so events can be dispatched from it.
+    # 
+    # true if the item text was successfully selected or false if the currently focused window is not one of the controls allowing item selection or if the item with the given text was not found in it.
+    # @param text [String]  The text of the item to select.
+    # @return [true,false]
+    def select(text) end
+    
+    # Emulate typing in the keys representing the given string.
+    # Currently only the ASCII letters are universally supported. Digits and punctuation characters can be used with the standard QWERTY (US) keyboard layout but may not work with other layouts.
+    # @param text [String]  The string, containing only US ASCII characters, to type.
+    # @return [true,false]
+    def text(text) end
+    
+  end # UIActionSimulator
+  
+
+end

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

@@ -50,7 +50,7 @@ module Wx
   # For normal keys, returns true if the specified key is currently down.
   # For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns true if the key is toggled such that its LED indicator is lit. There is currently no way to test whether togglable keys are up or down.
   # Even though there are virtual key codes defined for mouse buttons, they cannot be used with this function currently.
-  # In {Wx::GTK}, this function can be only used with modifier keys (WXK_ALT, WXK_CONTROL and WXK_SHIFT) when not using X11 backend currently.
+  # In {Wx::GTK}, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
   # @param key [KeyCode] 
   # @return [true,false]
   def self.get_key_state(key) end

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

@@ -71,24 +71,6 @@ module Wx
     # @return [true,false]
     def deselect_all; end
     
-    # Returns the index of the first selected item in the listbox or {Wx::NOT_FOUND} if no items are currently selected.
-    # cookie is an opaque parameter which should be passed to the subsequent calls to {Wx::VListBox#get_next_selected}. It is needed in order to allow parallel iterations over the selected items.
-    # Here is a typical example of using these functions:
-    # 
-    #   unsigned long cookie;
-    #   int item = hlbox->GetFirstSelected(cookie);
-    #   while ( item != wxNOT_FOUND )
-    #   {
-    #       // ... process item ...
-    #       item = hlbox->GetNextSelected(cookie);
-    #   }
-    # 
-    # This method is only valid for multi selection listboxes.
-    # @param cookie [unsigned long] 
-    # @return [Integer]
-    def get_first_selected(cookie) end
-    alias_method :first_selected, :get_first_selected
-    
     # Get the number of items in the control.
     # 
     # @see Wx::VListBox#set_item_count 
@@ -110,14 +92,6 @@ module Wx
     def get_item_rect(item) end
     alias_method :item_rect, :get_item_rect
     
-    # Returns the index of the next selected item or {Wx::NOT_FOUND} if there are no more.
-    # This method is only valid for multi selection listboxes.
-    # @see Wx::VListBox#get_first_selected 
-    # @param cookie [unsigned long] 
-    # @return [Integer]
-    def get_next_selected(cookie) end
-    alias_method :next_selected, :get_next_selected
-    
     # Returns the number of the items currently selected.
     # It is valid for both single and multi selection controls. In the former case it may only return 0 or 1 however.
     # @see Wx::VListBox#is_selected
@@ -218,6 +192,42 @@ module Wx
     # @return [void]
     def toggle(item) end
     
+    
+    protected
+    
+    # The derived class must implement this function to actually draw the item with the given index on the provided DC.
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC]  The device context to use for drawing.
+    # @param rect [Wx::Rect]  The bounding rectangle for the item being drawn (DC clipping region is set to this rectangle before calling this function).
+    # @param n [Integer]  The index of the item to be drawn.
+    # @return [void]
+    def on_draw_item(dc, rect, n) end
+    
+    # This method is used to draw the item's background and, maybe, a border around it.
+    # The base class version implements a reasonable default behaviour which consists in drawing the selected item with the standard background colour and drawing a border around the item if it is either selected or current.
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC] 
+    # @param rect [Wx::Rect] 
+    # @param n [Integer] 
+    # @return [void]
+    def on_draw_background(dc, rect, n) end
+    
+    # This method may be used to draw separators between the lines.
+    # The rectangle passed to it may be modified, typically to deflate it a bit before passing to {Wx::VListBox#on_draw_item}.
+    # The base class version of this method doesn't do anything.
+    # 
+    # TodoChange this function signature to non-const.
+    # @param dc [Wx::DC]  The device context to use for drawing.
+    # @param rect [Wx::Rect]  The bounding rectangle for the item.
+    # @param n [Integer]  The index of the item.
+    # @return [void]
+    def on_draw_separator(dc, rect, n) end
+    
+    # The derived class must implement this method to return the height of the specified item (in pixels).
+    # @param n [Integer] 
+    # @return [Integer]
+    def on_measure_item(n) end
+    
   end # VListBox
   
 

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

@@ -43,9 +43,10 @@ module Wx
     # Associates a window with the validator.
     # This function is automatically called by wxWidgets when creating a {Wx::Window}-derived class instance which takes a {Wx::Validator} reference. Since wxWidgets 3.1.1, it can be overridden in custom validators in order to perform any one-time initialization or checks of the window when the validator is associated with it.
     # E.g. 
-    # 
+    # ```
     #   new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
     #                  wxTextValidator(wxFILTER_ALPHA, &g_data.m_string));
+    # ```
     #  will automatically link the {Wx::TextValidator} instance with the {Wx::TextCtrl} instance and call {Wx::Validator#set_window} method on the {Wx::TextValidator} object.
     # @param window [Wx::Window] 
     # @return [void]

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

@@ -17,6 +17,7 @@ module Wx
   # An optional name member is associated with a {Wx::Variant}. This might be used, for example, in CORBA or OLE automation classes, where named parameters are required.
   # Note that as of wxWidgets 2.7.1, {Wx::Variant} is reference counted. Additionally, the convenience macros DECLARE_VARIANT_OBJECT() and IMPLEMENT_VARIANT_OBJECT() were added so that adding (limited) support for conversion to and from {Wx::Variant} can be very easily implemented without modifying either {Wx::Variant} or the class to be stored by {Wx::Variant}. Since assignment operators cannot be declared outside the class, the shift left operators are used like this:
   # 
+  # ```
   #   // in the header file
   #   DECLARE_VARIANT_OBJECT(MyClass)
   #   
@@ -30,13 +31,16 @@ module Wx
   #   
   #   // or
   #   value << variant;
+  # ```
   # 
   # For this to work, MyClass must derive from {Wx::Object}, implement the wxWidgets RTTI system and support the assignment operator and equality operator for itself. Ideally, it should also be reference counted to make copying operations cheap and fast. This can be most easily implemented using the reference counting support offered by {Wx::Object} itself. By default, wxWidgets already implements the shift operator conversion for a few of its drawing related classes:
   # 
+  # ```
   #   IMPLEMENT_VARIANT_OBJECT(wxColour)
   #   IMPLEMENT_VARIANT_OBJECT(wxImage)
   #   IMPLEMENT_VARIANT_OBJECT(wxIcon)
   #   IMPLEMENT_VARIANT_OBJECT(wxBitmap)
+  # ```
   # 
   # Note that as of wxWidgets 2.9.0, {Wx::VariantData} no longer inherits from {Wx::Object} and {Wx::Variant} no longer uses the type-unsafe {Wx::List} class for list operations but the type-safe {Wx::VariantList} class. Also, {Wx::VariantData} now supports the Wx::VariantData#clone function for implementing the {Wx::Variant#unshare} function. Wx::VariantData#clone is implemented automatically by IMPLEMENT_VARIANT_OBJECT().
   # Since {Wx::VariantData} no longer derives from {Wx::Object}, any code that tests the type of the data using {dynamic_cast} will require adjustment. You can use the macro {dynamic_cast_variant_data} with the same arguments as {dynamic_cast}, to use C++ RTTI type information instead of wxWidgets RTTI.
@@ -46,6 +50,7 @@ module Wx
   # {Wx::GRID::GridCellAttr::AttrKind::Any} is a more modern, template-based variant class. It is not directly compatible with {Wx::Variant}, but there is a transparent conversion layer.
   # Following is an example how to use these conversions with {Wx::PG::PropertyGrid}'s property class {Wx::PG::PGProperty} (which currently uses {Wx::Variants} both internally and in the public API):
   # 
+  # ```
   #   // Get property value as wxAny instead of wxVariant
   #   wxAny value = property->GetValue();
   #   
@@ -55,6 +60,7 @@ module Wx
   #   // Write back new value to property
   #   value = "New Value";
   #   property->SetValue(value);
+  # ```
   # 
   # Some caveats: 
   # - In {Wx::GRID::GridCellAttr::AttrKind::Any}, there are no separate types for handling integers of different sizes, so converting {Wx::GRID::GridCellAttr::AttrKind::Any} with 'long long' value will yield {Wx::Variant} of "long" type when the value is small enough to fit in without overflow. Otherwise, variant type "longlong" is used. Also note that {Wx::GRID::GridCellAttr::AttrKind::Any} holding unsigned integer will always be converted to "ulonglong" {Wx::Variant} type.
@@ -65,6 +71,7 @@ module Wx
   # 
   # Supplied conversion functions will automatically work with all built-in {Wx::Variant} types, and also with all user-specified types generated using IMPLEMENT_VARIANT_OBJECT(). For hand-built {Wx::VariantData} classes, you will need to use supplied macros in a following manner:
   # 
+  # ```
   #   // Declare wxVariantData for data type Foo
   #   class wxVariantDataFoo: public wxVariantData
   #   {
@@ -79,6 +86,7 @@ module Wx
   #   };
   #   
   #   IMPLEMENT_TRIVIAL_WXANY_CONVERSION(Foo, wxVariantDataFoo)
+  # ```
   # 
   # === 
   # 
@@ -87,6 +95,8 @@ module Wx
   # @see  Wx::GRID::GridCellAttr::AttrKind::Any 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Variant < Object
   
     # Appends a value to the list.