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

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]
@@ -203,12 +201,6 @@ module Wx
     # @return [void]
     def set_menu_label(pos, label) end
     
-    # Returns the Apple menu.
-    # This is the leftmost menu with application's name as its title. You shouldn't remove any items from it, but it is safe to insert extra menu items or submenus into it.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @return [Wx::Menu]
-    def osx_get_apple_menu; end
-    
     # @return [Wx::Frame]
     def get_frame; end
     alias_method :frame, :get_frame

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

@@ -212,19 +212,21 @@ module Wx
     # The label string for the normal menu items (not separators) may include the accelerator which can be used to activate the menu item from keyboard. An accelerator key can be specified using the ampersand <code>&</code> character. In order to embed an ampersand character in the menu item text, the ampersand must be doubled.
     # Optionally you can specify also an accelerator string appending a tab character <code>\t</code> followed by a valid key combination (e.g. <code>CTRL+V</code>). Its general syntax is any combination of <code>"CTRL"</code>, <code>"RAWCTRL"</code>, <code>"ALT"</code> and <code>"SHIFT"</code> strings (case doesn't matter) separated by either <code>'-'</code> or <code>'+'</code> characters and followed by the accelerator itself. Notice that CTRL corresponds to the "Ctrl" key on most platforms but not under macOS where it is mapped to "Cmd" key on Mac keyboard. Usually this is exactly what you want in portable code but if you really need to use the (rarely used for this purpose) "Ctrl" key even under Mac, you may use RAWCTRL to prevent this mapping. Under the other platforms RAWCTRL is the same as plain CTRL.
     # The accelerator may be any alphanumeric character, any function key (from F1 to F12), any numpad digit key using KP_ prefix (i.e. from KP_0 to KP_9) or one of the special strings listed below (again, case doesn't matter) corresponding to the specified key code:
-    # - Del or Delete: WXK_DELETE- Back: WXK_BACK- Ins or Insert: WXK_INSERT- Enter or Return: WXK_RETURN- PgUp or PageUp: WXK_PAGEUP- PgDn or PageDown: WXK_PAGEDOWN- Left: WXK_LEFT- Right: WXK_RIGHT- Up: WXK_UP- Down: WXK_DOWN- Home: WXK_HOME- End: WXK_END- Space: WXK_SPACE- Tab: WXK_TAB- Esc or Escape: WXK_ESCAPE- Cancel: WXK_CANCEL- Clear: WXK_CLEAR- Menu: WXK_MENU- Pause: WXK_PAUSE- Capital: WXK_CAPITAL- Select: WXK_SELECT- Print: WXK_PRINT- Execute: WXK_EXECUTE- Snapshot: WXK_SNAPSHOT- Help: WXK_HELP- Add: WXK_ADD- Separator: WXK_SEPARATOR- Subtract: WXK_SUBTRACT- Decimal: WXK_DECIMAL- Divide: WXK_DIVIDE- Num_lock: WXK_NUMLOCK- Scroll_lock: WXK_SCROLL- KP_Space: WXK_NUMPAD_SPACE- KP_Tab: WXK_NUMPAD_TAB- KP_Enter: WXK_NUMPAD_ENTER- KP_Home: WXK_NUMPAD_HOME- KP_Left: WXK_NUMPAD_LEFT- KP_Up: WXK_NUMPAD_UP- KP_Right: WXK_NUMPAD_RIGHT- KP_Down: WXK_NUMPAD_DOWN- KP_PageUp: WXK_NUMPAD_PAGEUP- KP_PageDown: WXK_NUMPAD_PAGEDOWN- KP_Prior: WXK_NUMPAD_PAGEUP- KP_Next: WXK_NUMPAD_PAGEDOWN- KP_End: WXK_NUMPAD_END- KP_Begin: WXK_NUMPAD_BEGIN- KP_Insert: WXK_NUMPAD_INSERT- KP_Delete: WXK_NUMPAD_DELETE- KP_Equal: WXK_NUMPAD_EQUAL- KP_Multiply: WXK_NUMPAD_MULTIPLY- KP_Add: WXK_NUMPAD_ADD- KP_Separator: WXK_NUMPAD_SEPARATOR- KP_Subtract: WXK_NUMPAD_SUBTRACT- KP_Decimal: WXK_NUMPAD_DECIMAL- KP_Divide: WXK_NUMPAD_DIVIDE- Windows_Left: WXK_WINDOWS_LEFT- Windows_Right: WXK_WINDOWS_RIGHT- Windows_Menu: WXK_WINDOWS_MENU- Command: WXK_COMMAND
+    # - Del or Delete: {Wx::K_DELETE}- Back: {Wx::K_BACK}- Ins or Insert: {Wx::K_INSERT}- Enter or Return: {Wx::K_RETURN}- PgUp or PageUp: {Wx::K_PAGEUP}- PgDn or PageDown: {Wx::K_PAGEDOWN}- Left: {Wx::K_LEFT}- Right: {Wx::K_RIGHT}- Up: {Wx::K_UP}- Down: {Wx::K_DOWN}- Home: {Wx::K_HOME}- End: {Wx::K_END}- Space: {Wx::K_SPACE}- Tab: {Wx::K_TAB}- Esc or Escape: {Wx::K_ESCAPE}- Cancel: {Wx::K_CANCEL}- Clear: {Wx::K_CLEAR}- Menu: {Wx::K_MENU}- Pause: {Wx::K_PAUSE}- Capital: {Wx::K_CAPITAL}- Select: {Wx::K_SELECT}- Print: {Wx::K_PRINT}- Execute: {Wx::K_EXECUTE}- Snapshot: {Wx::K_SNAPSHOT}- Help: {Wx::K_HELP}- Add: {Wx::K_ADD}- Separator: {Wx::K_SEPARATOR}- Subtract: {Wx::K_SUBTRACT}- Decimal: {Wx::K_DECIMAL}- Divide: {Wx::K_DIVIDE}- Num_lock: {Wx::K_NUMLOCK}- Scroll_lock: {Wx::K_SCROLL}- KP_Space: {Wx::K_NUMPAD}_SPACE- KP_Tab: {Wx::K_NUMPAD}_TAB- KP_Enter: {Wx::K_NUMPAD}_ENTER- KP_Home: {Wx::K_NUMPAD}_HOME- KP_Left: {Wx::K_NUMPAD}_LEFT- KP_Up: {Wx::K_NUMPAD}_UP- KP_Right: {Wx::K_NUMPAD}_RIGHT- KP_Down: {Wx::K_NUMPAD}_DOWN- KP_PageUp: {Wx::K_NUMPAD}_PAGEUP- KP_PageDown: {Wx::K_NUMPAD}_PAGEDOWN- KP_Prior: {Wx::K_NUMPAD}_PAGEUP- KP_Next: {Wx::K_NUMPAD}_PAGEDOWN- KP_End: {Wx::K_NUMPAD}_END- KP_Begin: {Wx::K_NUMPAD}_BEGIN- KP_Insert: {Wx::K_NUMPAD}_INSERT- KP_Delete: {Wx::K_NUMPAD}_DELETE- KP_Equal: {Wx::K_NUMPAD}_EQUAL- KP_Multiply: {Wx::K_NUMPAD}_MULTIPLY- KP_Add: {Wx::K_NUMPAD}_ADD- KP_Separator: {Wx::K_NUMPAD}_SEPARATOR- KP_Subtract: {Wx::K_NUMPAD}_SUBTRACT- KP_Decimal: {Wx::K_NUMPAD}_DECIMAL- KP_Divide: {Wx::K_NUMPAD}_DIVIDE- Windows_Left: {Wx::K_WINDOWS}_LEFT- Windows_Right: {Wx::K_WINDOWS}_RIGHT- Windows_Menu: {Wx::K_WINDOWS}_MENU- Command: {Wx::K_COMMAND}
     # 
     # Examples:
     # 
+    # ```
     #   m_pMyMenuItem->SetItemLabel("My &item\tCTRL+I");
     #   m_pMyMenuItem2->SetItemLabel("Clean && build\tF7");
     #   m_pMyMenuItem3->SetItemLabel("Simple item");
     #   m_pMyMenuItem4->SetItemLabel("Item with &accelerator");
+    # ```
     # 
     # In {Wx::GTK} using <code>"SHIFT"</code> with non-alphabetic characters currently doesn't work, even in combination with other modifiers, due to GTK+ limitation. E.g. <code>Shift+Ctrl+A</code> works but <code>Shift+Ctrl+1</code> or <code>Shift+/</code> do not, so avoid using accelerators of this form in portable code.
     # 
     # In {Wx::GTk}, the left/right/up/down arrow keys do not work as accelerator keys for a menu item unless a modifier key is used. Additionally, the following keycodes are not supported as menu accelerator keys:
-    # - WXK_COMMAND/WXK_CONTROL- WXK_SHIFT- WXK_ALT- WXK_SCROLL- WXK_CAPITAL- WXK_NUMLOCK- WXK_NUMPAD_TAB- WXK_TAB- WXK_WINDOWS_LEFT- WXK_WINDOWS_RIGHT- WXK_ADD- WXK_SEPARATOR- WXK_SUBTRACT- WXK_DECIMAL- WXK_DIVIDE- WXK_SNAPSHOT
+    # - {Wx::K_COMMAND}/{Wx::K_CONTROL}- {Wx::K_SHIFT}- {Wx::K_ALT}- {Wx::K_SCROLL}- {Wx::K_CAPITAL}- {Wx::K_NUMLOCK}- {Wx::K_NUMPAD}_TAB- {Wx::K_TAB}- {Wx::K_WINDOWS}_LEFT- {Wx::K_WINDOWS}_RIGHT- {Wx::K_ADD}- {Wx::K_SEPARATOR}- {Wx::K_SUBTRACT}- {Wx::K_DECIMAL}- {Wx::K_DIVIDE}- {Wx::K_SNAPSHOT}
     # @see Wx::MenuItem#get_item_label
     # @see  Wx::MenuItem#get_item_label_text 
     # @param label [String] 
@@ -266,7 +268,7 @@ module Wx
     
     # Add an extra accelerator for this menu item.
     # Additional accelerators are not shown in the item's label, but still will trigger the menu command when pressed.
-    # They can be useful to let multiple keys be used as accelerators for the same command, e.g. WXK_ADD and WXK_NUMPAD_ADD.
+    # They can be useful to let multiple keys be used as accelerators for the same command, e.g. {Wx::K_ADD} and {Wx::K_NUMPAD}_ADD.
     # Availability:  only available for the {Wx::MSW}, {Wx::GTK} ports.  {Wx::msw},{Wx::gtk}
     # @param accel [Wx::AcceleratorEntry] 
     # @return [void]
@@ -283,6 +285,7 @@ module Wx
     # For the custom (non-stock) menu items, text must be specified and while helpString may be left empty, it's recommended to pass the item description (which is automatically shown by the library in the status bar when the menu item is selected) in this parameter.
     # Finally note that you can e.g. use a stock menu label without using its stock help string:
     # 
+    # ```
     #   // use all stock properties:
     #   helpMenu->Append(wxID_ABOUT);
     #   
@@ -293,6 +296,7 @@ module Wx
     #   wxMenuItem *mymenu = new wxMenuItem(helpMenu, wxID_ABOUT);
     #   mymenu->SetBitmap(wxArtProvider::GetBitmap(wxART_WARNING));
     #   helpMenu->Append(mymenu);
+    # ```
     # 
     # that is, stock properties are set independently one from the other.
     # @param parentMenu [Wx::Menu]  Menu that the menu item belongs to. Can be NULL if the item is going to be added to the menu later.
@@ -318,7 +322,9 @@ module Wx
     # Strips all accelerator characters and mnemonics from the given text.
     # For example:
     # 
+    # ```
     #   wxMenuItem::GetLabelText("&Hello\tCtrl-h");
+    # ```
     # 
     # will return just <code>"Hello"</code>.
     # @see Wx::MenuItem#get_item_label_text

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

@@ -14,11 +14,12 @@ module Wx
   # This is a convenient function which is usually used instead of using {Wx::MessageDialog} directly. Notice however that some of the features, such as extended text and custom labels for the message box buttons, are not provided by this function but only by {Wx::MessageDialog}.
   # The return value is one of: {Wx::YES}, {Wx::NO}, {Wx::CANCEL}, {Wx::OK} or {Wx::HELP} (notice that this return value is <b>different</b> from the return value of {Wx::MessageDialog#show_modal}).
   # For example: 
-  # 
+  # ```
   #   int answer = wxMessageBox("Quit program?", "Confirm",
   #                             wxYES_NO | wxCANCEL, main_frame);
   #   if (answer == wxYES)
   #       main_frame->Close();
+  # ```
   # 
   # message may contain newline characters, in which case the message will be split into separate lines, to cater for large messages.
   # @param message [String]  Message to show in the dialog.
@@ -121,18 +122,20 @@ module Wx
     
     # Overrides the default labels of the Yes and No buttons.
     # The arguments of this function can be either strings or one of the standard identifiers, such as {Wx::StandardID::ID_APPLY} or {Wx::StandardID::ID_OPEN}. Notice that even if the label is specified as an identifier, the return value of the dialog {Wx::MessageDialog#show_modal} method still remains one of {Wx::StandardID::ID_OK}, {Wx::StandardID::ID_CANCEL}, {Wx::StandardID::ID_YES} or {Wx::StandardID::ID_NO} values, i.e. this identifier changes only the label appearance but not the return code generated by the button. It is possible to mix stock identifiers and string labels in the same function call, for example: 
-    # 
+    # ```
     #   wxMessageDialog dlg(...);
     #   dlg.SetYesNoLabels(wxID_SAVE, _("&Don't save"));
+    # ```
     # 
     # Also notice that this function is not currently available on all platforms (although as of wxWidgets 2.9.0 it is implemented in all major ports), so it may return false to indicate that the labels couldn't be changed. If it returns true, the labels were set successfully.
     # Typically, if the function was used successfully, the main dialog message may need to be changed, e.g.: 
-    # 
+    # ```
     #   wxMessageDialog dlg(...);
     #   if ( dlg.SetYesNoLabels(_("&Quit"), _("&Don't quit")) )
     #       dlg.SetMessage(_("What do you want to do?"));
     #   else // buttons have standard "Yes"/"No" values, so rephrase the question
     #       dlg.SetMessage(_("Do you really want to quit?"));
+    # ```
     # @param yes [ButtonLabel] 
     # @param no [ButtonLabel] 
     # @return [true,false]

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

@@ -13,16 +13,10 @@ module Wx
   # 
   # Category:  Device Contexts
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class MirrorDC < DC
   
-    # Creates a (maybe) mirrored DC associated with the real dc.
-    # Everything drawn on {Wx::MirrorDC} will appear (and maybe mirrored) on dc.
-    # mirror specifies if we do mirror (if it is true) or not (if it is false).
-    # @param dc [Wx::DC] 
-    # @param mirror [true,false] 
-    # @return [MirrorDC]
-    def initialize(dc, mirror) end
-    
   end # MirrorDC
   
 

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

@@ -16,6 +16,8 @@ module Wx
   # @see  Wx::MouseEvent 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class MouseState < KeyboardState
   
     # Returns the physical mouse position.

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

@@ -26,8 +26,6 @@ module Wx
   
     # Constructor taking an array of {Wx::String} choices.
     # Use {Wx::MultiChoiceDialog#show_modal} to show the dialog.
-    # 
-    # <b>{Wx::Perl} Note:</b> Use an array reference for the choices parameter.
     # @param parent [Wx::Window]  Parent window.
     # @param message [String]  Message to show on the dialog.
     # @param caption [String]  The dialog caption.

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

@@ -26,12 +26,13 @@ module Wx
     #   Set the window shape to the given path.
     #   Set the window shape to the interior of the given path and also draw the window border along the specified path.
     #   For example, to make a clock-like circular window you could use 
-    #   
+    #   ```
     #     wxSize size = GetSize();
     #     wxGraphicsPath
     #         path = wxGraphicsRenderer::GetDefaultRenderer()->CreatePath();
     #     path.AddCircle(size.x/2, size.y/2, 30);
     #     SetShape(path);
+    #   ```
     #   
     #   Note that windows with non default shape have a fixed size and can't be resized using {Wx::NonOwnedWindow#set_size}.
     #   As the overload above, this method is not guaranteed to work on all platforms but currently does work in {Wx::MSW}, {Wx::OSX}/Cocoa and {Wx::GTK} (with the appropriate but almost always present X11 extensions) ports.

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

@@ -85,16 +85,18 @@ module Wx
   # 
   # On Windows, the default theme paints a background on the notebook's pages. If you wish to suppress this theme, for aesthetic or performance reasons, there are three ways of doing it. You can use {Wx::NB_NOPAGETHEME} to disable themed drawing for a particular notebook, you can call {Wx::SystemOptions.set_option} to disable it for the whole application, or you can disable it for individual pages by using {Wx::Notebook#set_background_colour}.
   # To disable themed pages globally: 
-  # 
+  # ```
   #   wxSystemOptions::SetOption("msw.notebook.themed-background", 0);
+  # ```
   # 
   # Set the value to 1 to enable it again. To give a single page a solid background that more or less fits in with the overall theme, use: 
-  # 
+  # ```
   #   wxColour col = notebook->GetThemeBackgroundColour();
   #   if (col.IsOk())
   #   {
   #       page->SetBackgroundColour(col);
   #   }
+  # ```
   # 
   # On platforms other than Windows, or if the application is not using Windows themes, {Wx::Notebook#get_theme_background_colour} will return an uninitialised colour object, and the above code will therefore work on all platforms.
   # ===