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

data/lib/wx/doc/event_blocker.rb

@@ -0,0 +1,27 @@
+
+module Wx
+
+  class EventBlocker
+
+    class << self
+
+      # Constructs the blocker for the given window and for the given event type and passes the blocker to the
+      # given block. The blocker is destroyed after the block returns.
+      #
+      # If type is Wx::EVT_ANY, then all events for that window are blocked. You can call #block after creation to
+      # add other event types to the list of events to block.
+      #
+      # @note Note that the win window must remain alive until the given block returns (i.e. until Wx::EventBlocker's
+      # object destruction).
+      # @param [Wx::Window] win the window to block events for
+      # @param [Integer] evt_type the event type to block
+      # @yieldparam [Wx::EventBlocker] blkr the blocker object
+      # @return [Object] the value returned by the block
+      def blocked_for(win, evt_type=Wx::EVT_ANY) end
+      alias :block_for :blocked_for
+
+    end
+
+  end
+
+end

data/lib/wx/doc/evthandler.rb

@@ -3,6 +3,10 @@
 
 class Wx::EvtHandler
 
+  # Removes all (Ruby) installed EventFilter-s.
+  # @return [void]
+  def self.clear_filters; end
+
   # Public method to register the mapping of a custom event type
   # +konstant+ (which should be a unique integer; one will be created if
   # not supplied) to a custom event class +klass+. If +meth+ and +arity+

data/lib/wx/doc/extra/02_lifecycles.md

@@ -114,3 +114,52 @@ destroy these on a regular basis when not used (closed) possibly re-creating the
 
 Dialogs are special cases of toplevel windows which are not automatically destroyed when closed. The wxRuby library
 therefor provides special support to ease handling the destruction of these. See [here](03_dialogs.md) for more details.
+
+## Object identities
+
+One of the trickier things to handle correctly in the kind of native extensions like wxRuby is maintaining object 
+identities i.e. keeping native instances synced with their Ruby wrapper counter parts.
+
+Whenever a native extension is allowed to call back into Ruby space we encounter the problem the we need to map any 
+native object data provided for the call to the right Ruby types and when necessary to the right Ruby instance (object
+identity).
+
+Objects that are considered POD types (*plain old data* types) like numerics, booleans, strings, arrays and hashes do
+not require maintaining *object identity*. For these objects it is enough to map them to the right Ruby type before
+passing them on to Ruby space.
+
+For a lot of other objects though it is essential to not only map to the right **most derived** class type but also to
+the exact Ruby instance which was originally instantiated as wrapper for the native object if any exists (in case no
+Ruby instance existed yet a new instance of the correct **most derived** class should be instantiated at that point). 
+The reason this is important is 1. because the Ruby instance may have been used to identify, link to or otherwise 
+reference other data and/or functionality related to that specific Ruby/native pair and 2. the Ruby instance could 
+contain data elements (instance variables) related to that specific Ruby/native pair.<br>
+In the case of wxRuby Window instance for example it is common to derive custom Window classes with custom behaviour and
+corresponding instance variables that drive that behaviour. When an event handler or an overloaded native method is passed
+a native window object we absolutely need to be able to map that native object to the correct Ruby wrapper instance so
+all information stays in sync.
+
+For this purpose wxRuby uses *object tracking* i.e. maintaining hash tables mapping native object pointers to Ruby object 
+values. Whenever a tracked object is instantiated it is registered and can from than on be resolved whenever needed to map
+from native object to Ruby object.<br>
+Of course this also means wxRuby has to track object destruction so mappings can be removed when a native object is 
+destructed.<br>
+Additionally the tracking tables are also used to mark Ruby objects during the GC marking phase so they do not get garbage
+collected whenever they are not referenced in Ruby space anymore but still functioning in native space (this is for example
+a common situation for many child windows created but not permanently referenced in Ruby space).
+
+Tracking and resolving mappings from tracking tables produces a certain computing overhead but testing has shown this to be
+absolutely acceptable for normal applications.
+
+There are however quite a lot of wrapped native objects in wxRuby for which *object identity* is not essential. For these
+object tracking has been disabled for their classes. This means these kind of classes/object should **not** be derived from
+(if even possible and/or useful) to add functionality/information or their identity used as key to link other information.<br>
+These classes include:
+- classes considered POD types like Wx::Size, Wx::Point, Wx::RealPoint, Wx::Rect, Wx::GBSpan, Wx::GBPosition, Wx::BusyInfoFlags,
+Wx::AboutDialogInfo
+- final non-instantiatable classes like the Wx::DC (Device Context) class family, Wx::GraphicsContext, Wx::WindowsDisabler,
+Wx::EventBlocker, Wx::BusyInfo
+- classes with native singleton objects like Wx::Clipboard
+- the reference counted GDI objects like Wx::Pen, Wx::Brush, Wx::Colour, Wx::Cursor, Wx::Bitmap, Wx::Icon
+
+The reference documentation will note untracked object classes.

data/lib/wx/doc/extra/10_art.md

@@ -3,7 +3,7 @@
 # @title 10. wxRuby Locating and loading art
 -->
 
-# 9. wxRuby Locating and loading art
+# 10. wxRuby Locating and loading art
 
 ## Introduction
 

data/lib/wx/doc/extra/11_drawing_and_dc.md

@@ -0,0 +1,62 @@
+<!--
+# @markup markdown
+# @title 11. wxRuby Drawing and Device Contexts
+-->
+
+# 11. wxRuby Drawing and Device Contexts (DC)
+
+In wxRuby the Wx::DC class family provides functionality for drawing to windows, bitmaps, printers etc.
+
+What most of these classes have in common is that actual drawing output is buffered until the time the 
+device context object is destroyed.
+For this reason the common practice in wxWidgets C++ code would be to create temporary DC objects on the
+stack and draw on them while they are in scope (for several classes it is even strongly advised to never create
+them any other way and to never keep objects alive out of scope). When leaving the scope these object would than be 
+automatically destroyed and the any buffered output flushed to the final target.
+
+In Ruby this approach is impossible as Ruby is a purely dynamic language and does not **this kind** of scope bound
+life cycles. Any DC object created would have to be dynamically created and due to the properties of the GC driven
+life cycles could well be kept alive beyond the scope of it's creation. This will not always cause problems but could
+and does not really have an upside.
+
+To prevent confusion and potential problems wxRuby defines all `Wx::DC` derived classes to be abstract classes that
+cannot be instantiated using `new`. Rather all `Wx::DC` derived classes provide `::draw_on` factory methods to create 
+temporary dc objects that will be passed on to blocks given and will only exist for the duration of the execution of
+the block. This will guarantee proper DC cleanup when leaving it's usage scope.
+
+> Note that it is a **BAD** idea to think about storing the dc reference provide to the block for later access!
+
+A typical usage of a `::draw_on` method would be:
+
+```ruby
+    myTestBitmap1x = Wx::Bitmap.new(60, 15, 32)
+    Wx::MemoryDC.draw_on(myTestBitmap1x) do |mdc|
+      mdc.set_background(Wx::WHITE_BRUSH)
+      mdc.clear
+      mdc.set_pen(Wx::BLACK_PEN)
+      mdc.set_brush(Wx::WHITE_BRUSH)
+      mdc.draw_rectangle(0, 0, 60, 15)
+      mdc.draw_line(0, 0, 59, 14)
+      mdc.set_text_foreground(Wx::BLACK)
+      mdc.draw_text("x1", 0, 0)
+    end
+```
+
+## Windows, Wx::PaintDC and Wx::AutoBufferedPaintDC
+
+The `Wx::PaintDC` and `Wx::AutoBufferedPaintDC` classes provide `::draw_on` methods just like all other DC classes but
+this is mostly to be consistent.
+
+In this case it is recommended to instead use the `Wx::Window#paint` or `Wx::Window#paint_buffered` methods as these
+provide some optimizations with regard to automatically detecting is the methods are called inside `Wx::EVT_PAINT` 
+handlers (which should normally be the case) or not.
+
+So the typical way to do buffered painting inside a windows `Wx::EVT_PAINT` handler would be something like:
+
+```ruby
+  def on_paint(_event)
+    self.paint_buffered do |dc|
+      # ... do some drawing ...
+    end
+  end
+```

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/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/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()