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

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

@@ -456,7 +456,7 @@ module Wx
     # It should be noted that although using {Wx::ImageResizeQuality::IMAGE_QUALITY_HIGH} produces much nicer looking results it is a slower method. Downsampling will use the box averaging method which seems to operate very fast. If you are upsampling larger images using this method you will most likely notice that it is a bit slower and in extreme cases it will be quite substantially slower as the bicubic algorithm has to process a lot of data.
     # It should also be noted that the high quality scaling may not work as expected when using a single mask colour for transparency, as the scaling will blur the image and will therefore remove the mask partially. Using the alpha channel will work.
     # Example: 
-    # 
+    # ```
     #   // get the bitmap from somewhere
     #   wxBitmap bmp = ...;
     #   
@@ -470,6 +470,7 @@ module Wx
     #       image.Rescale(32, 32);
     #       bmp = image;
     #   }
+    # ```
     # 
     # The algorithm used for the default (normal) quality value doesn't work with images larger than 65536 (2^16) pixels in either dimension for 32-bit programs. For 64-bit programs the limit is 2^48 and so not relevant in practice.
     # @see Wx::Image#rescale 
@@ -549,6 +550,7 @@ module Wx
     # Computes the histogram of the image.
     # histogram is a reference to {Wx::ImageHistogram} object. {Wx::ImageHistogram} is a specialization of {Wx::HashMap} "template" and is defined as follows:
     # 
+    # ```
     #   class WXDLLEXPORT wxImageHistogramEntry
     #   {
     #   public:
@@ -560,6 +562,7 @@ module Wx
     #   WX_DECLARE_EXPORTED_HASH_MAP(unsigned long, wxImageHistogramEntry,
     #                               wxIntegerHash, wxIntegerEqual,
     #                               wxImageHistogram);
+    # ```
     # 
     # Returns number of colours in the histogram.
     # @param histogram [Wx::ImageHistogram] 
@@ -703,7 +706,7 @@ module Wx
     # Returns the palette associated with the image.
     # Currently the palette is only used when converting to {Wx::Bitmap} under Windows.
     # Some of the {Wx::Image} handlers have been modified to set the palette if one exists in the image file (usually 256 or less colour images in GIF or PNG format).
-    # @return [void]
+    # @return [Wx::Palette]
     def get_palette; end
     alias_method :palette, :get_palette
     
@@ -764,9 +767,10 @@ module Wx
     #   Depending on how wxWidgets has been configured, not all formats may be available.
     #   
     #   You can use {Wx::Image#get_option_int} to get the hotspot when loading cursor files: 
-    #   
+    #   ```
     #     int hotspot_x = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
     #     int hotspot_y = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
+    #   ```
     #   @see Wx::Image#save_file 
     #   @param stream [IO,Wx::InputStream]  Opened input stream from which to load the image. Currently, the stream must support seeking.
     #   @param type [BitmapType]  May be one of the following: 
@@ -816,9 +820,10 @@ module Wx
     #   Depending on how wxWidgets has been configured, not all formats may be available.
     #   
     #   You can use {Wx::Image#set_option} to set the hotspot when saving an image into a cursor file (default hotspot is in the centre of the image): 
-    #   
+    #   ```
     #     image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotspotX);
     #     image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotspotY);
+    #   ```
     #   @see Wx::Image#load_file 
     #   @param stream [IO,Wx::OutputStream]  Opened output stream to save the image to.
     #   @param mimetype [String]  MIME type.
@@ -889,10 +894,11 @@ module Wx
     # Sets the flags used for loading image files by this object.
     # The flags will affect any future calls to {Wx::Image#load_file} for this object. To change the flags for all image objects, call {Wx::Image.set_default_load_flags} before creating any of them.
     # Currently the only defined flag is Load_Verbose which determines if the non-fatal (i.e. not preventing the file from being loaded completely) problems should result in the calls to {log_warning} function. It is recommended to customize handling of these warnings by e.g. defining a custom log target (see Logging Overview), but if such warnings should be completely suppressed, clearing this flag provides a simple way to do it, for example: 
-    # 
+    # ```
     #   wxImage image;
     #   image.SetLoadFlags(image.GetLoadFlags() & ~wxImage::Load_Verbose);
     #   image.LoadFile(...);
+    # ```
     # @see Wx::Image#load_file
     # @see  Wx::Image#set_load_flags
     # @see  Wx::Image#get_load_flags
@@ -1057,7 +1063,6 @@ module Wx
     #   @return [Image]
     # @overload initialize(xpmData)
     #   Creates an image from XPM data.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}. 
     #   This constructor has become explicit in wxWidgets 3.1.6.
     #   @param xpmData [char]  A pointer to XPM image data.
     #   @return [Image]
@@ -1066,9 +1071,10 @@ module Wx
     #   Depending on how wxWidgets has been configured and by which handlers have been loaded, not all formats may be available. Any handler other than BMP must be previously initialized with {Wx::Image.add_handler} or {init_all_image_handlers}.
     #   
     #   You can use {Wx::Image#get_option_int} to get the hotspot when loading cursor files: 
-    #   
+    #   ```
     #     int hotspot_x = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
     #     int hotspot_y = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
+    #   ```
     #   @see Wx::Image#load_file 
     #   @param name [String]  Name of the file from which to load the image.
     #   @param type [BitmapType]  May be one of the following: 
@@ -1120,10 +1126,11 @@ module Wx
     
     # Iterates all registered {Wx::ImageHandler} objects, and returns a string containing file extension masks suitable for passing to file open/save dialog boxes.
     # The format of the returned string is <code>"(*.ext1;*.ext2)|*.ext1;*.ext2"</code>. It is usually a good idea to prepend a description before passing the result to the dialog. Example: 
-    # 
+    # ```
     #   wxFileDialog FileDlg( this, "Choose Image", ::wxGetCwd(), "",
     #                         _("Image Files ") + wxImage::GetImageExtWildcard(),
     #                         wxFD_OPEN );
+    # ```
     # @see Wx::ImageHandler 
     # @return [String]
     def self.get_image_ext_wildcard; end

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

@@ -16,6 +16,8 @@ module Wx
   # @see  Wx::MouseState 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class KeyboardState < ::Object
   
     # Constructor initializes the modifier key settings.
@@ -31,13 +33,17 @@ module Wx
     # The return value is a combination of {Wx::KeyModifier::MOD_ALT}, {Wx::KeyModifier::MOD_CONTROL}, {Wx::KeyModifier::MOD_SHIFT} and {Wx::KeyModifier::MOD_META} bit masks. Additionally, {Wx::KeyModifier::MOD_NONE} is defined as 0, i.e. corresponds to no modifiers (see {Wx::KeyboardState#has_any_modifiers}) and {Wx::KeyModifier::MOD_CMD} is either {Wx::KeyModifier::MOD_CONTROL} (MSW and Unix) or {Wx::KeyModifier::MOD_META} (Mac), see {Wx::KeyboardState#cmd_down}. See {Wx::KeyModifier} for the full list of modifiers.
     # Notice that this function is easier to use correctly than, for example, {Wx::KeyboardState#control_down} because when using the latter you also have to remember to test that none of the other modifiers is pressed:
     # 
+    # ```
     #   if ( ControlDown() && !AltDown() && !ShiftDown() && !MetaDown() )
     #       ... handle Ctrl-XXX ...
+    # ```
     # 
     # and forgetting to do it can result in serious program bugs (e.g. program not working with European keyboard layout where AltGr key which is seen by the program as combination of CTRL and ALT is used). On the other hand, you can simply write:
     # 
+    # ```
     #   if ( GetModifiers() == wxMOD_CONTROL )
     #       ... handle Ctrl-XXX ...
+    # ```
     # 
     # with this function.
     # @return [Integer]

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

@@ -77,7 +77,6 @@ module Wx
     #   @return [ListBox]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, choices=nil, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ListBoxNameStr)
     #   Constructor, creating and showing a list box.
-    #   <b>{Wx::Perl} Note:</b> Not supported by {Wx::Perl}.
     #   @param parent [Wx::Window]  The parent window.
     #   @param id [Integer]  The ID of this control. A value of {Wx::StandardID::ID_ANY} indicates a default value.
     #   @param pos [Array(Integer, Integer), Wx::Point]  The initial position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
@@ -90,7 +89,6 @@ module Wx
     # @overload initialize(parent, id, pos, size, choices, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::ListBoxNameStr)
     #   Constructor, creating and showing a list box.
     #   See the other {Wx::ListBox#list_box} constructor; the only difference is that this overload takes a {Wx::ArrayString} instead of a pointer to an array of {Wx::String}.
-    #   <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
     #   @param pos [Array(Integer, Integer), Wx::Point] 
@@ -141,8 +139,6 @@ module Wx
     # The number of selections.
     # 
     # Use this with a multiple selection listbox.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes no parameters and return the selected items as a list.
     # @see Wx::ControlWithItems::GetSelection
     # @see  Wx::ControlWithItems::GetStringSelection
     # @see  Wx::ControlWithItems::SetSelection 
@@ -165,7 +161,6 @@ module Wx
     def hit_test(*args) end
     
     # Insert the given number of strings before the specified position.
-    # <b>{Wx::Perl} Note:</b> Use an array reference for the items parameter.
     # @param items [Array<String>]  Labels of items to be inserted
     # @param pos [Integer]  Position before which to insert the items: if pos is 0 the items will be inserted in the beginning of the listbox
     # @return [void]
@@ -195,12 +190,6 @@ module Wx
     # @return [void]
     def ensure_visible(n) end
     
-    # Return true if the listbox has {Wx::LB_SORT} style.
-    # This method is mostly meant for internal use only.
-    # @return [true,false]
-    def is_sorted; end
-    alias_method :sorted?, :is_sorted
-    
     # Return the number of items that can fit vertically in the visible area of the listbox.
     # Returns -1 if the number of items per page couldn't be determined. On {Wx::GTK} this method can only determine the number of items per page if there is at least one item in the listbox.
     # @return [void]

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

@@ -328,7 +328,7 @@ module Wx
   # All the other functions still work with the column indices, i.e. the visual positioning of the columns on screen doesn't affect the code setting or getting their values for example.
   # 
   # Example of reordering columns: 
-  # 
+  # ```
   #   wxListCtrl *list = new wxListCtrl(...);
   #   for ( int i = 0; i < 3; i++ )
   #       list->InsertColumn(i, wxString::Format("Column %d", i));
@@ -343,6 +343,7 @@ module Wx
   #   // list->GetColumnIndexFromOrder(n) will return order[n] and
   #   // list->GetColumnOrder() will return 1, 2 and 0 for the column 0,
   #   // 1 and 2 respectively
+  # ```
   # 
   # === Styles
   # 
@@ -524,14 +525,12 @@ module Wx
     #   @return [Integer]
     # @overload find_item(start, data)
     #   Find an item whose data matches this data, starting from start or the beginning if 'start' is <code>-1</code>.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method is implemented as FindItemData(start, data). 
     #   The next matching item if any or <code>-1</code> ({Wx::NOT_FOUND}) otherwise.
     #   @param start [Integer] 
     #   @param data [Integer] 
     #   @return [Integer]
     # @overload find_item(start, pt, direction)
     #   Find an item nearest this position in the specified direction, starting from start or the beginning if start is -1.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method is implemented as FindItemAtPos(start, pt, direction). 
     #   The next matching item if any or <code>-1</code> ({Wx::NOT_FOUND}) otherwise.
     #   @param start [Integer] 
     #   @param pt [Array(Integer, Integer), Wx::Point] 
@@ -541,7 +540,6 @@ module Wx
     
     # Gets information about this column.
     # See {Wx::ListCtrl#set_item} for more information.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes only the col parameter and returns a Wx::ListItem (or undef).
     # @param col [Integer] 
     # @param item [Wx::ListItem] 
     # @return [true,false]
@@ -628,7 +626,6 @@ module Wx
     alias_method :item_font, :get_item_font
     
     # Returns the position of the item, in icon or small icon view.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes only the item parameter and returns a Wx::Point (or undef).
     # @param item [Integer] 
     # @param pos [Array(Integer, Integer), Wx::Point] 
     # @return [true,false]
@@ -637,7 +634,6 @@ module Wx
     
     # Returns the rectangle representing the item's size and position, in physical coordinates.
     # code is one of {Wx::LIST_RECT_BOUNDS}, {Wx::LIST_RECT_ICON}, {Wx::LIST_RECT_LABEL}.
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes only the item and code parameters and returns a Wx::Rect (or undef).
     # @param item [Integer] 
     # @param code [Integer] 
     # @return [Array(true,false,Wx::Rect)]
@@ -674,6 +670,7 @@ module Wx
     # Searches for an item with the given geometry or state, starting from item but excluding the item itself.
     # If item is -1, the first item that matches the specified flags will be returned. Returns the first item with given state following item or -1 if no such item found. This function may be used to find all selected items in the control like this:
     # 
+    # ```
     #   long item = -1;
     #   for ( ;; )
     #   {
@@ -686,6 +683,7 @@ module Wx
     #       // this item is selected - do whatever is needed with it
     #       wxLogMessage("Item %ld is selected.", item);
     #   }
+    # ```
     # 
     # geometry can be one of:
     # - {Wx::LIST_NEXT_ABOVE}: Searches for an item above the specified item.- {Wx::LIST_NEXT_ALL}: Searches for subsequent item by index.- {Wx::LIST_NEXT_BELOW}: Searches for an item below the specified item.- {Wx::LIST_NEXT_LEFT}: Searches for an item to the left of the specified item.- {Wx::LIST_NEXT_RIGHT}: Searches for an item to the right of the specified item.
@@ -756,7 +754,6 @@ module Wx
     # - {Wx::LIST_HITTEST_ABOVE}: Above the control's client area.- {Wx::LIST_HITTEST_BELOW}: Below the control's client area.- {Wx::LIST_HITTEST_TOLEFT}: To the left of the control's client area.- {Wx::LIST_HITTEST_TORIGHT}: To the right of the control's client area.- {Wx::LIST_HITTEST_NOWHERE}: Inside the control's client area but not over an item.- {Wx::LIST_HITTEST_ONITEMICON}: Over an item's icon.- {Wx::LIST_HITTEST_ONITEMLABEL}: Over an item's text.- {Wx::LIST_HITTEST_ONITEMSTATEICON}: Over the checkbox of an item.- {Wx::LIST_HITTEST_ONITEM}: Combination of {Wx::LIST_HITTEST_ONITEMICON}, {Wx::LIST_HITTEST_ONITEMLABEL}, {Wx::LIST_HITTEST_ONITEMSTATEICON}.
     # 
     # If ptrSubItem is not NULL and the {Wx::ListCtrl} is in the report mode the subitem (or column) number will also be provided. This feature is only available in version 2.7.0 or higher and is currently only implemented under {Wx::MSW} and requires at least comctl32.dll of version 4.70 on the host system or the value stored in ptrSubItem will be always -1. To compile this feature into wxWidgets library you need to have access to commctrl.h of version 4.70 that is provided by Microsoft.
-    # <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(Integer,Integer)]
     def hit_test(point) end
@@ -790,19 +787,16 @@ module Wx
     #   @return [Integer]
     # @overload insert_item(index, label)
     #   Insert a string item.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method is implemented as InsertStringItem(index, label).
     #   @param index [Integer]  Index of the new item, supplied by the application
     #   @param label [String]  String label
     #   @return [Integer]
     # @overload insert_item(index, imageIndex)
     #   Insert an image item.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method is implemented as InsertImageItem(index, imageIndex).
     #   @param index [Integer]  Index of the new item, supplied by the application
     #   @param imageIndex [Integer]  Index into the image list associated with this control and view style
     #   @return [Integer]
     # @overload insert_item(index, label, imageIndex)
     #   Insert an image/string item.
-    #   <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method is implemented as InsertImageStringItem(index, label, imageIndex).
     #   @param index [Integer]  Index of the new item, supplied by the application
     #   @param label [String]  String label
     #   @param imageIndex [Integer]  Index into the image list associated with this control and view style
@@ -985,11 +979,13 @@ module Wx
     # Sets the item state.
     # The stateMask is a combination of {Wx::LIST_STATE_XXX} constants described in {Wx::ListItem} documentation. For each of the bits specified in stateMask, the corresponding state is set or cleared depending on whether state argument contains the same bit or not.
     # So to select an item you can use 
-    # 
+    # ```
     #   list->SetItemState(item, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+    # ```
     #  while to deselect it you should use 
-    # 
+    # ```
     #   list->SetItemState(item, 0, wxLIST_STATE_SELECTED);
+    # ```
     # 
     # Consider using {Wx::ListView} if possible to avoid dealing with this error-prone and confusing method.
     # Also notice that contrary to the usual rule that only user actions generate events, this method does generate {Wx::EVT_LIST_ITEM_SELECTED} event when it is used to select an item.
@@ -1092,7 +1088,7 @@ module Wx
     # Returns the new value to use for sort indicator after clicking a column.
     # This helper function can be useful in the EVT_LIST_COL_CLICK handler when it updates the sort indicator after the user clicked on a column.
     # For example: 
-    # 
+    # ```
     #   void MyListCtrl::OnColClick(wxListEvent& event)
     #   {
     #       int col = event.GetColumn();
@@ -1103,6 +1099,7 @@ module Wx
     #       SortItems(MyCompareFunction, ascending);
     #       ShowSortIndicator(col, ascending);
     #   }
+    # ```
     # @param col [Integer] 
     # @return [true,false]
     def get_updated_ascending_sort_indicator(col) end

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

@@ -3779,8 +3779,8 @@ module Wx
   # 
   # In wxWidgets this class manages current locale. It also initializes and activates {Wx::Translations} object that manages message catalogs.
   # For a list of the supported languages, please see {Wx::Language} enum values. These constants may be used to specify the language in {Wx::Locale#init} and are returned by {Wx::Locale.get_system_language}.
-  # <b>{Wx::Perl} Note:</b> In {Wx::Perl} you can't use the '_' function name, so the Wx::Locale module can export the gettext and gettext_noop under any given name.
   # 
+  # ```
   #   # this imports gettext ( equivalent to Wx::GetTranslation
   #   # and gettext_noop ( a noop )
   #   # into your module
@@ -3792,9 +3792,11 @@ module Wx
   #   print gettext( "Panic!" );
   #   
   #   button = Wx::Button-new( window, -1, gettext( "Label" ) );
+  # ```
   # 
   # If you need to translate a lot of strings, then adding gettext( ) around each one is a long task ( that is why _( ) was introduced ), so just choose a shorter name for gettext:
   # 
+  # ```
   #   use Wx::Locale 'gettext' = 't',
   #                  'gettext_noop' = 'gettext_noop';
   #   
@@ -3804,6 +3806,7 @@ module Wx
   #   print t( "Panic!!" );
   #   
   #   # ...
+  # ```
   #  
   # === 
   # 
@@ -4006,9 +4009,10 @@ module Wx
   end # Locale
   
   # Encapsulates a {Wx::Language} identifier together with OS-specific information related to that language.
-  # <b>{Wx::Perl} Note:</b> In {Wx::Perl} Wx::LanguageInfo has only one method:
-  # - Wx::LanguageInfo->new(language, canonicalName, WinLang, WinSubLang, Description)
   # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LanguageInfo < ::Object
   
     # Win32 language identifiers (LANG_xxxx, SUBLANG_xxxx).

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

@@ -162,8 +162,9 @@ module Wx
     
     # Sets the log level for the given component.
     # For example, to disable all but error messages from wxWidgets network classes you may use 
-    # 
+    # ```
     #   wxLog::SetComponentLevel("wx/net", wxLOG_Error);
+    # ```
     # 
     # {Wx::Log.set_log_level} may be used to set the global log level.
     # @param component [String]  Non-empty component name, possibly using slashes (<code>/</code>) to separate it into several parts.
@@ -248,7 +249,7 @@ module Wx
     # Log the given record.
     # This function should only be called from the DoLog() implementations in the derived classes if they need to call {Wx::Log#do_log_record} on another log object (they can, of course, just use {Wx::Log#do_log_record} call syntax to call it on the object itself). It should not be used for logging new messages which can be only sent to the currently active logger using OnLog() which also checks if the logging (for this level) is enabled while this method just directly calls DoLog().
     # Example of use of this class from {Wx::LogChain}: 
-    # 
+    # ```
     #   void wxLogChain::DoLogRecord(wxLogLevel level,
     #                                const wxString& msg,
     #                                const wxLogRecordInfo& info)
@@ -261,6 +262,7 @@ module Wx
     #       if ( m_logNew && m_logNew != this )
     #           m_logNew->LogRecord(level, msg, info);
     #   }
+    # ```
     # @param level [Wx::LogLevel] 
     # @param msg [String] 
     # @param info [Wx::LogRecordInfo] 
@@ -294,6 +296,7 @@ module Wx
   # It is especially useful when you want to divert the logs somewhere (for example to a file or a log window) but also keep showing the error messages using the standard dialogs as {Wx::LogGui} does by default.
   # Example of usage:
   # 
+  # ```
   #   wxLogChain *logChain = new wxLogChain(new wxLogStderr);
   #   
   #   // all the log messages are sent to stderr and also processed as usually
@@ -302,6 +305,7 @@ module Wx
   #   // don't delete logChain directly as this would leave a dangling
   #   // pointer as active log target, use SetActiveTarget() instead
   #   delete wxLog::SetActiveTarget(...something else or NULL...);
+  # ```
   # 
   # === 
   # 

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

@@ -112,8 +112,10 @@ module Wx
     # Override this to return a different kind of client window.
     # If you override this function, you must create your parent frame in two stages, or your function will never be called, due to the way C++ treats virtual functions called from constructors. For example:
     # 
+    # ```
     #   frame = new MyParentFrame;
     #   frame->Create(parent, myParentFrameId, "My Parent Frame");
+    # ```
     # 
     # You might wish to derive from {Wx::MDIClientWindow} in order to implement different erase behaviour, for example, such as painting a bitmap on the background.
     # Note that it is probably impossible to have a client window that scrolls as well as painting a bitmap or pattern, since in <b>OnScroll</b>, the scrollbar positions always return zero.

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

@@ -20,6 +20,7 @@ module Wx
   # When {Wx::MediaCtrl} plays a file, it plays until the stop position is reached (currently the end of the file/stream). Right before it hits the end of the stream, it fires off a EVT_MEDIA_STOP event to its parent window, at which point the event handler can choose to veto the event, preventing the stream from actually stopping.
   # Example:
   # 
+  # ```
   #   // bind the media event
   #   Bind(wxMY_ID, wxEVT_MEDIA_STOP, &MyFrame::OnMediaStop, this);
   #   
@@ -32,6 +33,7 @@ module Wx
   #           evt.Veto();
   #       }
   #   }
+  # ```
   # 
   # When {Wx::MediaCtrl} stops, either by the EVT_MEDIA_STOP not being vetoed, or by manually calling {Wx::MediaCtrl#stop}, where it actually stops is not at the beginning, rather, but at the beginning of the stream. That is, when it stops and play is called, playback is guaranteed to start at the beginning of the media. This is because some streams are not seekable, and when stop is called on them they return to the beginning, thus {Wx::MediaCtrl} tries to keep consistent for all types of media.
   # Note that when changing the state of the media through {Wx::MediaCtrl#play} and other methods, the media may not actually be in the {Wx::MediaState::MEDIASTATE_PLAYING}, for example. If you are relying on the media being in certain state, catch the event relevant to the state. See {Wx::MediaEvent} for the kinds of events that you can catch.

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

@@ -6,10 +6,26 @@
 
 module Wx
 
+  # 
+  BUFFER_VIRTUAL_AREA = 1
+  
+  # 
+  BUFFER_CLIENT_AREA = 2
+  
+  # 
+  BUFFER_USES_SHARED_BUFFER = 4
+  
+  # Check if the window is natively double buffered and will return a {Wx::PaintDC} if it is, a {Wx::BufferedPaintDC} otherwise.
+  # It is the caller's responsibility to delete the {Wx::DC} pointer when finished with it.
+  # @param window [Wx::Window] 
+  # @return [Wx::DC]
+  def self.auto_buffered_paint_dc_factory(window) end
+  
   # A memory device context provides a means to draw graphics onto a bitmap.
   # When drawing in to a mono-bitmap, using {Wx::WHITE}, {Wx::WHITE_PEN} and {Wx::WHITE_BRUSH} will draw the background colour (i.e. 0) whereas all other colours will draw the foreground colour (i.e. 1).
   # A bitmap must be selected into the new memory DC before it may be used for anything. Typical usage is as follows:
   # 
+  # ```
   #   // Create a memory DC
   #   wxMemoryDC temp_dc;
   #   temp_dc.SelectObject(test_bitmap);
@@ -17,15 +33,18 @@ module Wx
   #   // We can now draw into the memory DC...
   #   // Copy from this DC to another DC.
   #   old_dc.Blit(250, 50, BITMAP_WIDTH, BITMAP_HEIGHT, temp_dc, 0, 0);
+  # ```
   # 
   # Note that the memory DC must be deleted (or the bitmap selected out of it) before a bitmap can be reselected into another memory DC.
   # And, before performing any other operations on the bitmap data, the bitmap must be selected out of the memory DC:
   # 
+  # ```
   #   temp_dc.SelectObject(wxNullBitmap);
+  # ```
   # 
   # This happens automatically when {Wx::MemoryDC} object goes out of scope.
   # Note that the scaling factor of the bitmap determines the scaling factor used by this device context, so when using a memory device context as a back buffer for a window, you should typically create the bitmap using the same scale factor as used by the window, e.g. 
-  # 
+  # ```
   #   void MyWindow::OnPaint(wxPaintEvent&)
   #   {
   #       wxBitmap bmp;
@@ -38,6 +57,7 @@ module Wx
   #       wxPaintDC dc(this);
   #       dc.DrawBitmap(bmp, wxPoint(0, 0));
   #   }
+  # ```
   # 
   # === 
   # 
@@ -46,24 +66,10 @@ module Wx
   # @see  Wx::DC 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class MemoryDC < DC
   
-    # @overload initialize()
-    #   Constructs a new memory device context.
-    #   Use the {Wx::DC#is_ok} member to test whether the constructor was successful in creating a usable device context. Don't forget to select a bitmap into the DC before drawing on it.
-    #   @return [MemoryDC]
-    # @overload initialize(dc)
-    #   Constructs a new memory device context having the same characteristics as the given existing device context.
-    #   This constructor creates a memory device context compatible with dc in {Wx::MSW}, the argument is ignored in the other ports. If dc is NULL, a device context compatible with the screen is created, just as with the default constructor.
-    #   @param dc [Wx::DC] 
-    #   @return [MemoryDC]
-    # @overload initialize(bitmap)
-    #   Constructs a new memory device context and calls {Wx::MemoryDC#select_object} with the given bitmap.
-    #   Use the {Wx::DC#is_ok} member to test whether the constructor was successful in creating a usable device context.
-    #   @param bitmap [Wx::Bitmap] 
-    #   @return [MemoryDC]
-    def initialize(*args) end
-    
     # Allow using this device context object to modify the given bitmap contents.
     # Note that if you need to only use the existing bitmap contents instead of modifying it, you should use {Wx::MemoryDC#select_object_as_source} instead.
     # Before using the updated bitmap data, make sure to select it out of context first either by selecting {Wx::NULL_BITMAP} into the device context or destroying the device context entirely.
@@ -83,7 +89,7 @@ module Wx
     
     # @overload get_selected_bitmap()
     #   Get the selected bitmap.
-    #   @return [void]
+    #   @return [Wx::Bitmap]
     # @overload get_selected_bitmap()
     #   @return [Wx::Bitmap]
     def get_selected_bitmap(*args) end
@@ -91,5 +97,86 @@ module Wx
     
   end # MemoryDC
   
+  # This class provides a simple way to avoid flicker: when drawing on it, everything is in fact first drawn on an in-memory buffer (a {Wx::Bitmap}) and then copied to the screen, using the associated {Wx::DC}, only once, when this object is destroyed.
+  # {Wx::BufferedDC} itself is typically associated with {Wx::ClientDC}, if you want to use it in your EVT_PAINT handler, you should look at {Wx::BufferedPaintDC} instead.
+  # When used like this, a valid DC must be specified in the constructor while the buffer bitmap doesn't have to be explicitly provided, by default this class will allocate the bitmap of required size itself. However using a dedicated bitmap can speed up the redrawing process by eliminating the repeated creation and destruction of a possibly big bitmap. Otherwise, {Wx::BufferedDC} can be used in the same way as any other device context.
+  # Another possible use for {Wx::BufferedDC} is to use it to maintain a backing store for the window contents. In this case, the associated DC may be NULL but a valid backing store bitmap should be specified.
+  # Finally, please note that GTK+ 2.0 as well as macOS provide double buffering themselves natively. You can either use {Wx::Window#is_double_buffered} to determine whether you need to use buffering or not, or use {Wx::AutoBufferedPaintDC} to avoid needless double buffering on the systems which already do it automatically.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::MemoryDC
+  # @see  Wx::BufferedPaintDC
+  # @see  Wx::AutoBufferedPaintDC 
+  # 
+  # 
+  class BufferedDC < MemoryDC
+  
+    # @overload init(dc, area, style=Wx::BUFFER_CLIENT_AREA)
+    #   Initializes the object created using the default constructor.
+    #   Please see the constructors for parameter details.
+    #   @param dc [Wx::DC] 
+    #   @param area [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @return [void]
+    # @overload init(dc, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   Initializes the object created using the default constructor.
+    #   Please see the constructors for parameter details.
+    #   @param dc [Wx::DC] 
+    #   @param buffer [Wx::Bitmap] 
+    #   @param style [Integer] 
+    #   @return [void]
+    def init(*args) end
+    
+    # Blits the buffer to the dc, and detaches the dc from the buffer (so it can be effectively used once only).
+    # Usually only called in the destructor or by the destructor of derived classes if the BufferedDC must blit before the derived class (which may own the dc it's blitting to) is destroyed.
+    # @return [void]
+    def un_mask; end
+    
+    # Set the style.
+    # @param style [Integer] 
+    # @return [void]
+    def set_style(style) end
+    alias_method :style=, :set_style
+    
+    # Get the style.
+    # @return [Integer]
+    def get_style; end
+    alias_method :style, :get_style
+    
+  end # BufferedDC
+  
+  # This is a subclass of {Wx::BufferedDC} which can be used inside of an <code>EVT_PAINT()</code> event handler to achieve double-buffered drawing.
+  # Just use this class instead of {Wx::PaintDC} and make sure {Wx::Window#set_background_style} is called with {Wx::BackgroundStyle::BG_STYLE_PAINT} somewhere in the class initialization code, and that's all you have to do to (mostly) avoid flicker. The only thing to watch out for is that if you are using this class together with {Wx::Scrolled}, you probably do <b>not</b> want to call Wx::Scrolled#prepare_dc on it as it already does this internally for the real underlying {Wx::PaintDC}.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::BufferedDC
+  # @see  Wx::AutoBufferedPaintDC
+  # @see  Wx::PaintDC 
+  # 
+  # 
+  class BufferedPaintDC < BufferedDC
+  
+  end # BufferedPaintDC
+  
+  # This {Wx::DC} derivative can be used inside of an <code>EVT_PAINT()</code> event handler to achieve double-buffered drawing.
+  # Just use this class instead of {Wx::PaintDC} and make sure {Wx::Window#set_background_style} is called with {Wx::BackgroundStyle::BG_STYLE_PAINT} somewhere in the class initialization code, and that's all you have to do to (mostly) avoid flicker.
+  # The difference between {Wx::BufferedPaintDC} and this class is that this class won't double-buffer on platforms which have native double-buffering already, avoiding any unnecessary buffering to avoid flicker.
+  # {Wx::AutoBufferedPaintDC} is simply a typedef of {Wx::PaintDC} on platforms that have native double-buffering, otherwise, it is a typedef of {Wx::BufferedPaintDC}.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::DC
+  # @see  Wx::BufferedPaintDC
+  # @see  Wx::PaintDC 
+  # 
+  # 
+  class AutoBufferedPaintDC < BufferedPaintDC
+  
+  end # AutoBufferedPaintDC
+  
 
 end

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

@@ -55,11 +55,13 @@ module Wx
     # @overload append(id, item=(''), helpString=(''), kind=Wx::ItemKind::ITEM_NORMAL)
     #   Adds a menu item.
     #   Example: 
-    #   
+    #   ```
     #     m_pFileMenu->Append(ID_NEW_FILE, "&New file\tCTRL+N", "Creates a new XYZ document");
+    #   ```
     #    or even better for stock menu items (see {Wx::MenuItem::MenuItem}): 
-    #   
+    #   ```
     #     m_pFileMenu->Append(wxID_NEW, "", "Creates a new XYZ document");
+    #   ```
     #   
     #   This command can be used after the menu has been shown, as well as on initial creation of a menu or menubar.
     #   @see Wx::Menu#append_separator

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

@@ -62,8 +62,6 @@ module Wx
     
     # Finds the menu item object associated with the given menu item identifier.
     # The found menu item object, or NULL if one was not found.
-    # 
-    # <b>{Wx::Perl} Note:</b> In {Wx::Perl} this method takes just the id parameter; in scalar context it returns the associated Wx::MenuItem, in list context it returns a 2-element list (item, submenu).
     # @param id [Integer]  Menu item identifier.
     # @param menu [Wx::Menu]  If not NULL, menu will get set to the associated menu.
     # @return [Wx::MenuItem]