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

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

@@ -9,17 +9,17 @@ module Wx
   # This function shows the standard about dialog containing the information specified in info.
   # If the current platform has a native about dialog which is capable of showing all the fields in info, the native dialog is used, otherwise the function falls back to the generic wxWidgets version of the dialog, i.e. does the same thing as {generic_about_box}.
   # Here is an example of how this function may be used:
-  # 
-  #   void MyFrame::ShowSimpleAboutDialog(wxCommandEvent& WXUNUSED(event))
-  #   {
-  #       wxAboutDialogInfo info;
-  #       info.SetName(_("My Program"));
-  #       info.SetVersion(_("1.2.3 Beta"));
-  #       info.SetDescription(_("This program does something great."));
-  #       info.SetCopyright(wxT("(C) 2007 Me <my@email.addre.ss>"));
-  #   
-  #       wxAboutBox(info);
-  #   }
+  # ```ruby
+  #   def show_simple_about_dialog(event)
+  #     info = Wx::AboutDialogInfo.new
+  #     info.name = 'My Program'
+  #     info.version = '1.2.3 Beta'
+  #     info.description = 'This program does something great.'
+  #     info.copyright = '(C) 2007 Me <my@email.addre.ss>'
+  #        
+  #     Wx.about_box(info)
+  #   end
+  # ```
   # 
   # Please see the Dialogs Sample for more examples of using this function and {Wx::AboutDialogInfo} for the description of the information which can be shown in the about dialog.
   # @param info [Wx::AboutDialogInfo] 
@@ -39,20 +39,21 @@ module Wx
   # {Wx::AboutDialogInfo} contains information shown in the standard About dialog displayed by the {about_box} function.
   # This class contains the general information about the program, such as its name, version, copyright and so on, as well as lists of the program developers, documentation writers, artists and translators. The simple properties from the former group are represented as a string with the exception of the program icon and the program web site, while the lists from the latter group are stored as {Wx::ArrayString} and can be either set entirely at once using {Wx::AboutDialogInfo#set_developers} and similar functions or built one by one using {Wx::AboutDialogInfo#add_developer} etc.
   # Please also notice that while all the main platforms have the native implementation of the about dialog, they are often more limited than the generic version provided by wxWidgets and so the generic version is used if {Wx::AboutDialogInfo} has any fields not supported by the native version. Currently GTK+ version supports all the possible fields natively but MSW and Mac versions don't support URLs, licence text nor custom icons in the about dialog and if either of those is used, {about_box} will automatically use the generic version so you should avoid specifying these fields to achieve more native look and feel.
-  # Example of usage: 
   # 
-  #   void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
-  #   {
-  #       wxAboutDialogInfo aboutInfo;
-  #       aboutInfo.SetName("MyApp");
-  #       aboutInfo.SetVersion(MY_APP_VERSION_STRING);
-  #       aboutInfo.SetDescription(_("My wxWidgets-based application!"));
-  #       aboutInfo.SetCopyright("(C) 1992-2023");
-  #       aboutInfo.SetWebSite("http://myapp.org");
-  #       aboutInfo.AddDeveloper("My Self");
-  #   
-  #       wxAboutBox(aboutInfo);
-  #   }
+  # Example of usage:
+  # 
+  # ```ruby
+  #   def on_about(event)
+  #     info = Wx::AboutDialogInfo.new
+  #     info.name = 'MyApp'
+  #     info.version = MY_APP_VERSION_STRING
+  #     info.description = 'My wxWidgets-based application!'
+  #     info.copyright = '(C) 1992-2023'
+  #     info.add_developer('My Self')
+  #        
+  #     Wx.about_box(info)
+  #   end
+  # ```
   # 
   # === 
   # 
@@ -60,6 +61,8 @@ module Wx
   # @see Wx::AboutDialogInfo#set_artists 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class AboutDialogInfo < ::Object
   
     # Default constructor leaves all fields are initially uninitialized, in general you should call at least {Wx::AboutDialogInfo#set_version}, {Wx::AboutDialogInfo#set_copyright} and {Wx::AboutDialogInfo#set_description}.

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

@@ -55,7 +55,7 @@ module Wx
     # @overload initialize(flags=0, keyCode=0, cmd=0, item=nil)
     #   Constructor.
     #   @param flags [Integer]  A combination of the {Wx::AcceleratorEntryFlags} values, which indicates which modifier keys are held down.
-    #   @param keyCode [Integer]  The keycode to be detected. See {Wx::KeyCode} for a full list of keycodes.
+    #   @param keyCode [Integer,String]  The keycode (or character) to be detected. See {Wx::KeyCode} for a full list of keycodes.
     #   @param cmd [Integer]  The menu or control command identifier (ID).
     #   @param item [Wx::MenuItem]  The menu item associated with this accelerator.
     #   @return [AcceleratorEntry]
@@ -87,7 +87,7 @@ module Wx
     
     # Sets the accelerator entry parameters.
     # @param flags [Integer]  A combination of the {Wx::AcceleratorEntryFlags} values, which indicates which modifier keys are held down.
-    # @param keyCode [Integer]  The keycode to be detected. See {Wx::KeyCode} for a full list of keycodes.
+    # @param keyCode [Integer,String]  The keycode to be detected. See {Wx::KeyCode} for a full list of keycodes.
     # @param cmd [Integer]  The menu or control command identifier (ID).
     # @param item [Wx::MenuItem]  The menu item associated with this accelerator.
     # @return [void]
@@ -124,15 +124,15 @@ module Wx
   # An accelerator table allows the application to specify a table of keyboard shortcuts for menu or button commands.
   # The object {Wx::NULL_ACCELERATOR_TABLE} is defined to be a table with no data, and is the initial accelerator table for a window.
   # Example:
-  # 
-  #   wxAcceleratorEntry entries[4];
-  #   entries[0].Set(wxACCEL_CTRL, (int) 'N', ID_NEW_WINDOW);
-  #   entries[1].Set(wxACCEL_CTRL, (int) 'X', wxID_EXIT);
-  #   entries[2].Set(wxACCEL_SHIFT, (int) 'A', ID_ABOUT);
-  #   entries[3].Set(wxACCEL_NORMAL, WXK_DELETE, wxID_CUT);
-  #   
-  #   wxAcceleratorTable accel(4, entries);
-  #   frame->SetAcceleratorTable(accel);
+  # ```ruby
+  #   entries = [
+  #       Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'N', ID_NEW_WINDOW),
+  #       Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'X', Wx::ID_EXIT),
+  #       Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'A', Wx::ID_ABOUT),
+  #       Wx::AcceleratorEntry.new(Wx::ACCEL_CTRL, 'N', Wx::ID_CUT)
+  #     ]
+  #   frame.accelerator_table = Wx::AcceleratorTable[entries]
+  # ```
   # 
   # An accelerator takes precedence over normal processing and can be a convenient way to program some event handling. For example, you can use an accelerator table to enable a dialog with a multi-line text control to accept CTRL-Enter as meaning 'OK'.
   # 
@@ -151,7 +151,6 @@ module Wx
     #   @return [AcceleratorTable]
     # @overload initialize(entries)
     #   Initializes the accelerator table from an array of {Wx::AcceleratorEntry}.
-    #   <b>{Wx::Perl} Note:</b> The {Wx::Perl} constructor accepts a list of either Wx::AcceleratorEntry objects or references to 3-element arrays [flags, keyCode, cmd] , like the parameters of Wx::AcceleratorEntry::new.
     #   @param entries [Array<Wx::AcceleratorEntry>]  The array of entries.
     #   @return [AcceleratorTable]
     # @overload initialize(resource)

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

@@ -0,0 +1,65 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Small control showing an animation indicating that the program is currently busy performing some background task.
+  # === 
+  # 
+  # 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>
+  # 
+  class ActivityIndicator < Control
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   Use {Wx::ActivityIndicator#create} to really create the control after using this constructor.
+    #   @return [ActivityIndicator]
+    # @overload initialize(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=("activityindicator"))
+    #   Constructor fully creating the control.
+    #   The arguments have the usual meanings and only parent is typically required.
+    #   @param parent [Wx::Window] 
+    #   @param winid [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [ActivityIndicator]
+    def initialize(*args) end
+    
+    # Create the control initialized using the default constructor.
+    # This method can be used to finish the control creation if it hadn't been done already by using the non-default constructor.
+    # @param parent [Wx::Window] 
+    # @param winid [Integer] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    def create(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=("activityindicator")) end
+    
+    # Starts animation of the indicator.
+    # Does nothing if the indicator is already running.
+    # @return [void]
+    def start; end
+    
+    # Stops the animation of the indicator.
+    # Notice that the animation is stopped even if {Wx::ActivityIndicator#start} had been called multiple times before, i.e. the calls are not cumulative.
+    # @return [void]
+    def stop; end
+    
+    # Returns true if the control is currently showing activity.
+    # Returns false initially, true once {Wx::ActivityIndicator#start} is called and false again after calling {Wx::ActivityIndicator#stop}.
+    # @return [true,false]
+    def is_running; end
+    alias_method :running?, :is_running
+    
+  end # ActivityIndicator
+  
+
+end

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

@@ -172,8 +172,9 @@ module Wx
     # Sets the 'top' window.
     # You can call this from within {Wx::App#on_init} to let wxWidgets know which is the main window. You don't have to set the top window; it is only a convenience so that (for example) certain dialogs without parents can use a specific window as the top window.
     # If no top window is specified by the application, wxWidgets just uses the first frame or dialog (or better, any {Wx::TopLevelWindow}) in its top-level window list, when it needs to use the top window. If you previously called {Wx::App#set_top_window} and now you need to restore this automatic behaviour you can call 
-    # 
+    # ```
     #   wxApp::SetTopWindow(NULL) 
+    # ```
     # .
     # @see Wx::App#get_top_window
     # @see  Wx::App#on_init 
@@ -342,12 +343,14 @@ module Wx
     # Sets the C locale to the default locale for the current environment.
     # It is advised to call this to ensure that the underlying toolkit uses the locale in which the numbers and monetary amounts are shown in the format expected by user and so on.
     # Calling this function is roughly equivalent to calling 
-    # 
+    # ```
     #   setlocale(LC_ALL, "");
+    # ```
     #  but performs additional toolkit-specific tasks under some platforms and so should be used instead of <code>setlocale()</code> itself. Alternatively, you can use {Wx::Locale} to change the locale with more control.
     # Notice that this does not change the global C++ locale, you need to do it explicitly if you want, e.g. 
-    # 
+    # ```
     #   std::locale::global(std::locale(""));
+    # ```
     #  but be warned that locale support in C++ standard library can be poor or worse under some platforms.
     # @return [void]
     def set_c_locale; end

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

@@ -270,28 +270,19 @@ module Wx
   # When wxWidgets needs to display an icon or a bitmap (e.g. in the standard file dialog), it does not use a hard-coded resource but asks {Wx::ArtProvider} for it instead. This way users can plug in their own {Wx::ArtProvider} class and easily replace standard art with their own version.
   # All that is needed is to derive a class from {Wx::ArtProvider}, override either its {Wx::ArtProvider#create_bitmap} and/or its {Wx::ArtProvider#create_icon_bundle} methods and register the provider with {Wx::ArtProvider.push}:
   # 
-  #   class MyProvider : public wxArtProvider
-  #   {
-  #   protected:
-  #     // Override this method to return a bundle containing the required
-  #     // bitmap in all available sizes.
-  #     wxBitmapBundle CreateBitmapBundle(const wxArtID& id,
-  #                                       const wxArtClient& client,
-  #                                       const wxSize& size) override;
-  #   
-  #     // If all bitmaps are available in a single size only, it may be
-  #     // simpler to override just this one.
-  #     wxBitmap CreateBitmap(const wxArtID& id,
-  #                           const wxArtClient& client,
-  #                           const wxSize& size) override;
-  #   
-  #     // optionally override this one as well
-  #     wxIconBundle CreateIconBundle(const wxArtID& id,
-  #                                   const wxArtClient& client) override;
-  #     { ... }
-  #   };
-  #   ...
-  #   wxArtProvider::Push(new MyProvider);
+  # Example:
+  # 
+  # ```ruby
+  #   class MyArtProvider < Wx::ArtProvider
+  #     
+  #     def create_bitmap(id, client, size)
+  #       # ... create and return bitmap
+  #     end
+  # 
+  #   end
+  # 
+  #   Wx::ArtProvider.push(MyArtProvider.new)
+  # ```
   # 
   # If you need bitmap images (of the same artwork) that should be displayed at different sizes you should probably consider overriding {Wx::ArtProvider#create_icon_bundle} and supplying icon bundles that contain different bitmap sizes.
   # There's another way of taking advantage of this class: you can use it in your code and use platform native icons as provided by {Wx::ArtProvider.get_bitmap_bundle} or {Wx::ArtProvider.get_icon}.
@@ -359,14 +350,12 @@ module Wx
   # - {Wx::ART_REMOVABLE} 
   # - {Wx::ART_WX_LOGO} (since 3.1.6)  
   # 
-  # When building with {Wx::NO_IMPLICIT_WXSTRING_ENCODING} defined (see wxString Overview for more details), you need to explicitly use {ascii_str} around these constants.
-  # 
-  # Additionally, any string recognized by custom art providers registered using {Wx::ArtProvider.push} may be used.
   # When running under GTK+ 2, GTK+ stock item IDs (e.g. <code>"gtk-cdrom"</code>) may be used as well: 
-  # 
-  #   #ifdef __WXGTK__
-  #       wxBitmap bmp = wxArtProvider::GetBitmap("gtk-cdrom", wxART_MENU);
-  #   #endif
+  # ```ruby
+  #   if Wx::PLATFORM == 'WXGTK'
+  #     bmp = Wx::ArtProvider.get_bitmap("gtk-cdrom", Wx::ART_MENU)
+  #   end
+  # ```
   #  For a list of the GTK+ stock items please refer to the GTK+ documentation page. It is also possible to load icons from the current icon theme by specifying their name (without extension and directory components). Icon themes recognized by GTK+ follow the freedesktop.org Icon Themes specification. Note that themes are not guaranteed to contain all icons, so {Wx::ArtProvider} may return {Wx::NULL_BITMAP} or {Wx::NULL_ICON}. The default theme is typically installed in <code>/usr/share/icons/hicolor</code>.
   # 
   # == Clients
@@ -491,6 +480,41 @@ module Wx
     # @return [Wx::Icon]
     def self.get_message_box_icon(flags) end
     
+    
+    protected
+    
+    # Derived art provider classes may override this method to return the size of the images used by this provider.
+    # Note that the returned size should be in DPI-independent pixels, i.e. DIPs. The default implementation returns the result of {Wx::ArtProvider.get_native_dip_size_hint}.
+    # @param client [Wx::ArtClient] 
+    # @return [Wx::Size]
+    def do_get_size_hint(client) end
+    
+    # Derived art provider classes may override this method to create requested art resource.
+    # For bitmaps available in more than one size, {Wx::ArtProvider#create_bitmap_bundle} should be overridden instead.
+    # Note that returned bitmaps are cached by {Wx::ArtProvider} and it is therefore not necessary to optimize {Wx::ArtProvider#create_bitmap} for speed (e.g. you may create {Wx::Bitmap} objects from XPMs here).
+    # 
+    # This is not part of {Wx::ArtProvider}'s public API, use {Wx::ArtProvider.get_bitmap} or {Wx::ArtProvider.get_icon_bundle} or {Wx::ArtProvider.get_icon} to query {Wx::ArtProvider} for a resource.
+    # @see Wx::ArtProvider#create_icon_bundle 
+    # @param id [Wx::ArtID]  {Wx::ArtID} unique identifier of the bitmap.
+    # @param client [Wx::ArtClient]  {Wx::ArtClient} identifier of the client (i.e. who is asking for the bitmap). This only serves as a hint.
+    # @param size [Array(Integer, Integer), Wx::Size]  Preferred size of the bitmap. The function may return a bitmap of different dimensions, it will be automatically rescaled to meet client's request.
+    # @return [Wx::Bitmap]
+    def create_bitmap(id, client, size) end
+    
+    # Override this method to create the requested art resources available in more than one size.
+    # Unlike {Wx::ArtProvider#create_bitmap}, this method can be overridden to return the same bitmap in several (or all, if {Wx::BitmapBundle.from_svg} is used) sizes at once, which will allow selecting the size best suited for the current display resolution automatically.
+    # @param id [Wx::ArtID]  {Wx::ArtID} unique identifier of the bitmap.
+    # @param client [Wx::ArtClient]  {Wx::ArtClient} identifier of the client (i.e. who is asking for the bitmap). This only serves as a hint.
+    # @param size [Array(Integer, Integer), Wx::Size]  Default size of the bitmaps returned by the bundle.
+    # @return [Wx::BitmapBundle]
+    def create_bitmap_bundle(id, client, size) end
+    
+    # This method is similar to {Wx::ArtProvider#create_bitmap} but can be used when a bitmap (or an icon) exists in several sizes.
+    # @param id [Wx::ArtID] 
+    # @param client [Wx::ArtClient] 
+    # @return [Wx::IconBundle]
+    def create_icon_bundle(id, client) end
+    
   end # ArtProvider
   
 

data/lib/wx/doc/gen/aui/aui_manager.rb

@@ -12,15 +12,19 @@ module Wx::AUI
   # {Wx::AUI::AuiManager} works as follows: the programmer adds panes to the class, or makes changes to existing pane properties (dock position, floating state, show state, etc.). To apply these changes, {Wx::AUI::AuiManager}'s {Wx::AUI::AuiManager#update} function is called. This batch processing can be used to avoid flicker, by modifying more than one pane at a time, and then "committing" all of the changes at once by calling {Wx::AUI::AuiManager#update}.
   # Panes can be added quite easily:
   # 
+  # ```
   #   wxTextCtrl* text1 = new wxTextCtrl(this, -1);
   #   wxTextCtrl* text2 = new wxTextCtrl(this, -1);
   #   m_mgr.AddPane(text1, wxLEFT, "Pane Caption");
   #   m_mgr.AddPane(text2, wxBOTTOM, "Pane Caption");
   #   m_mgr.Update();
+  # ```
   # 
   # Later on, the positions can be modified easily. The following will float an existing pane in a tool window:
   # 
+  # ```
   #   m_mgr.GetPane(text1).Float();
+  # ```
   # 
   # == Layers, Rows and Directions, Positions
   # 

data/lib/wx/doc/gen/aui/aui_mdi_child_frame.rb

@@ -57,7 +57,7 @@ module Wx::AUI
     def set_icons(icons) end
     alias_method :icons=, :set_icons
     
-    # @return [void]
+    # @return [Wx::IconBundle]
     def get_icons; end
     alias_method :icons, :get_icons
     

data/lib/wx/doc/gen/aui/aui_pane_info.rb

@@ -128,6 +128,8 @@ module Wx::AUI
   # @see  Wx::AUI::AuiDockArt 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class AuiPaneInfo < ::Object
   
     # name of the pane

data/lib/wx/doc/gen/aui/aui_tab_ctrl.rb

@@ -139,6 +139,8 @@ module Wx::AUI
   # 
   # Category:  Window Docking (wxAUI)
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class AuiTabContainerButton < ::Object
   
   end # AuiTabContainerButton

data/lib/wx/doc/gen/aui/aui_tool_bar.rb

@@ -415,8 +415,8 @@ module Wx::AUI
     # If there are custom items set, then the overflow menu will be displayed even if there are no items from the main toolbar that overflow.
     # 
     # The toolbar must have the {Wx::AUI::AuiToolBarStyle::AUI_TB_OVERFLOW} style.
-    # @param prepend [Wx::AuiToolBarItemArray]  are the items to show before any overflow items
-    # @param append [Wx::AuiToolBarItemArray]  are the items to show after any overflow items
+    # @param prepend [Array<Wx::AUI::AuiToolbarItem>,nil]  are the items to show before any overflow items
+    # @param append [Array<Wx::AUI::AuiToolbarItem>,nil]  are the items to show after any overflow items
     # @return [void]
     def set_custom_overflow_items(prepend, append) end
     

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

@@ -34,6 +34,8 @@ module Wx
   # @see  Wx::PixelData 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class Bitmap < GDIObject
   
     # @overload initialize()
@@ -43,9 +45,10 @@ module Wx
     # @overload initialize(bitmap)
     #   Copy constructor, uses reference counting.
     #   To make a real copy, you can use:
-    #   
-    #     wxBitmap newBitmap = oldBitmap.GetSubBitmap(
-    #                          wxRect(0, 0, oldBitmap.GetWidth(), oldBitmap.GetHeight()));
+    #   ```ruby
+    #     newBitmap = oldBitmap.get_sub_bitmap(
+    #                     Wx::Rect.new(0, 0, oldBitmap.width, oldBitmap.height))
+    #   ```
     #   @param bitmap [Wx::Bitmap] 
     #   @return [Bitmap]
     # @overload initialize(width, height, depth=Wx::BITMAP_SCREEN_DEPTH)
@@ -350,37 +353,34 @@ module Wx
   # - A custom bitmap source using {Wx::BitmapBundleImpl}.
   # - A single {Wx::Bitmap} or {Wx::Image} for backwards compatibility.
   #  Objects of {Wx::BitmapBundle} class have value-like semantics, i.e. they can be copied around freely (and cheaply) and don't need to be allocated on the heap. However they usually are created using static factory functions (known as "pseudo-constructors") such as {Wx::BitmapBundle.from_bitmaps} instead of using the real constructors.
-  # Example of using this class to initialize a toolbar in a frame constructor: 
-  # 
-  #   MyFrame::MyFrame()
-  #       : wxFrame(nullptr, wxID_ANY, "My frame")
-  #   {
-  #       ...
-  #       wxToolBar* toolBar = CreateToolBar();
-  #   
-  #       wxVector<wxBitmap> bitmaps;
-  #       bitmaps.push_back(wxBITMAP_PNG(open_32x32));
-  #       bitmaps.push_back(wxBITMAP_PNG(open_48x48));
-  #       bitmaps.push_back(wxBITMAP_PNG(open_64x64));
-  #   
-  #       toolBar->AddTool(wxID_OPEN, "Open", wxBitmapBundle::FromBitmaps(bitmaps));
-  #   }
+  # ```ruby
+  #   class MyFrame < Wx::Frame
+  #     
+  #     def initialize
+  #       super(nil, Wx::ID_ANY, "My frame")
+  #       # ...
+  #       tool_bar = create_toolBar
+  #    
+  #       bitmaps = [
+  #           Wx::Bitmap(:open_32x32, Wx::BitmapType::BITMAP_TYPE_PNG),
+  #           Wx::Bitmap(:open_48x48, Wx::BitmapType::BITMAP_TYPE_PNG),
+  #           Wx::Bitmap(:open_64x64, Wx::BitmapType::BITMAP_TYPE_PNG)
+  #         ]
+  #  
+  #       tool_bar.add_tool(Wx::ID_OPEN, "Open", Wx::BitmapBundle.from_bitmaps(bitmaps))
+  #     end
+  # ```
   # 
   # The code shown above will use 32 pixel bitmap in normal DPI, 64 pixel bitmap in "high DPI", i.e. pixel-doubling or 200% resolution, and 48 pixel bitmap in 150% resolution. For all the other resolutions, the bitmap with the "best" matching size will be used, where "best" is deemed to be the bitmap with the closest size if it can be used without scaling (so that in this example the 64px bitmap will be used at 175% resolution because it typically looks much better than either downscaling it or upscaling the 48px bitmap to 56px) or, if there is no bitmap with close enough size, a bitmap upscaled by an integer scaling factor is used. Note that custom bitmap bundles can use a different algorithm for selecting the best match by overriding Wx::BitmapBundleImpl#get_preferred_bitmap_size_at_scale.
   # Of course, this code relies on actually having the resources with the corresponding names (i.e. open_NxN) in MSW .rc file or Mac application bundle and open_NxN_png arrays being defined in the program code, e.g. by including a file generated with bin2c (see {bitmap_png_from_data}), on the other platforms.
-  # For the platforms with resources support, you can also create the bundle from the bitmaps defined in the resources, which has the advantage of not having to explicitly list all the bitmaps, e.g. the code above becomes 
   # 
-  #   #ifdef wxHAS_IMAGE_RESOURCES
-  #       toolBar->AddTool(wxID_OPEN, "Open", wxBitmapBundle::FromResources("open"));
-  #   #else
-  #       ... same code as shown above ...
-  #   #endif
-  #  and will load all resources called open, open_2x, open_1_5x etc (at least the first one of them must be available). See also {bitmap_bundle_2} macro which can avoid the need to check for {Wx::HAS_IMAGE_RESOURCES} explicitly in the code in a common case of having only 2 embedded resources (for standard and high DPI). See also {Wx::BitmapBundle.from_svg_resource}.
   # Also note that the existing code using {Wx::Bitmap} is compatible with the functions taking {Wx::BitmapBundle} in wxWidgets 3.1.6 and later because bitmaps are implicitly convertible to the objects of this class, so just passing {Wx::Bitmap} to the functions taking {Wx::BitmapBundle} continues to work and if high resolution versions of bitmap are not (yet) available for the other toolbar tools, single bitmaps can continue to be used instead.
   # === 
   # 
   # Category:  Graphics Device Interface (GDI)
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class BitmapBundle < ::Object
   
     # @overload initialize()

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