wxruby3 0.9.1-x64-mingw-ucrt → 0.9.2-x64-mingw-ucrt

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

@@ -11,15 +11,19 @@ module Wx
   # An MDI parent frame always has a {Wx::MDIClientWindow} associated with it, which is the parent for MDI child frames. In the simplest case, the client window takes up the entire parent frame area but it is also possible to resize it to be smaller in order to have other windows in the frame, a typical example is using a sidebar along one of the window edges.
   # The appearance of MDI applications differs between different ports. The classic MDI model, with child windows which can be independently moved, resized etc, is only available under MSW, which provides native support for it. In Mac ports, multiple top level windows are used for the MDI children too and the MDI parent frame itself is invisible, to accommodate the native look and feel requirements. In all the other ports, a tab-based MDI implementation (sometimes called TDI) is used and so at most one MDI child is visible at any moment (child frames are always maximized).
   # 
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>
+  # </p>
+  # </div>>
+  # 
   # Although it is possible to have multiple MDI parent frames, a typical MDI application has a single MDI parent frame window inside which multiple MDI child frames, i.e. objects of class {Wx::MDIChildFrame}, can be created.
-  # === Styles
+  # ### Styles
   # 
   # This class supports the following styles:
   # 
   # There are no special styles for this class, all {Wx::Frame} styles apply to it in the usual way. The only exception is that {Wx::HSCROLL} and {Wx::VSCROLL} styles apply not to the frame itself but to the client window, so that using them enables horizontal and vertical scrollbars for this window and not the frame.
   # 
-  # === 
-  # 
   # Category:  Managed Windows
   # @see Wx::MDIChildFrame
   # @see  Wx::MDIClientWindow
@@ -27,6 +31,7 @@ module Wx
   # @see  Wx::Dialog 
   # 
   # 
+  # @wxrb_require USE_MDI
   class MDIParentFrame < Frame
   
     # @overload initialize()
@@ -37,7 +42,13 @@ module Wx
     #   Constructor, creating the window.
     #   Notice that if you override virtual {Wx::MDIParentFrame#on_create_client} method you shouldn't be using this constructor but the default constructor and {Wx::MDIParentFrame#create} as otherwise your overridden method is never going to be called because of the usual C++ virtual call resolution rules.
     #   
-    #   Under wxMSW, the client window will automatically have a sunken border style when the active child is not maximized, and no border style when a child is maximized.
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>
+    #   </p>
+    #   </div>>
+    #   
+    #   Under WXMSW, the client window will automatically have a sunken border style when the active child is not maximized, and no border style when a child is maximized.
     #   @see Wx::MDIParentFrame#create
     #   @see  Wx::MDIParentFrame#on_create_client 
     #   @param parent [Wx::Window]  The window parent. Usually is NULL.
@@ -117,6 +128,12 @@ module Wx
     #   frame.create(parent, myParentFrameId, 'My Parent Frame')
     # ```
     # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>
+    # </p>
+    # </div>>
+    # 
     # 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.
     # @see Wx::MDIParentFrame#get_client_window
@@ -157,13 +174,16 @@ module Wx
   end # MDIParentFrame
   
   # An MDI child frame is a frame that can only exist inside a {Wx::MDIClientWindow}, which is itself a child of {Wx::MDIParentFrame}.
-  # === Styles
+  # ### Styles
   # 
   # This class supports the following styles:
   #  All of the standard {Wx::Frame} styles can be used but most of them are ignored by TDI-based MDI implementations. 
-  # Although internally an MDI child frame is a child of the MDI client window, in wxWidgets you create it as a child of {Wx::MDIParentFrame}. In fact, you can usually forget that the client window exists. MDI child frames are clipped to the area of the MDI client window, and may be iconized on the client window. You can associate a menubar with a child frame as usual, although an MDI child doesn't display its menubar under its own title bar. The MDI parent frame's menubar will be changed to reflect the currently active child frame. If there are currently no children, the parent frame's own menubar will be displayed.
   # 
-  # === 
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>Although internally an MDI child frame is a child of the MDI client window, in wxWidgets you create it as a child of {Wx::MDIParentFrame}. In fact, you can usually forget that the client window exists. MDI child frames are clipped to the area of the MDI client window, and may be iconized on the client window. You can associate a menubar with a child frame as usual, although an MDI child doesn't display its menubar under its own title bar. The MDI parent frame's menubar will be changed to reflect the currently active child frame. If there are currently no children, the parent frame's own menubar will be displayed.
+  # </p>
+  # </div>>
   # 
   # Category:  Managed Windows
   # @see Wx::MDIClientWindow
@@ -171,6 +191,7 @@ module Wx
   # @see  Wx::Frame 
   # 
   # 
+  # @wxrb_require USE_MDI
   class MDIChildFrame < Frame
   
     # @overload initialize()

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

@@ -9,13 +9,13 @@ module Wx
   # {Wx::MediaCtrl} is a class for displaying various types of media, such as videos, audio files, natively through native codecs.
   # {Wx::MediaCtrl} uses native backends to render media, for example on Windows there is a ActiveMovie/DirectShow backend, and on Macintosh there is a QuickTime backend.
   # 
-  # == Rendering media
+  # ## Rendering media
   # 
   # Depending upon the backend, {Wx::MediaCtrl} can render and display pretty much any kind of media that the native system can - such as an image, mpeg video, or mp3 (without license restrictions - since it relies on native system calls that may not technically have mp3 decoding available, for example, it falls outside the realm of licensing restrictions).
   # For general operation, all you need to do is call {Wx::MediaCtrl#load} to load the file you want to render, catch the EVT_MEDIA_LOADED event, and then call {Wx::MediaCtrl#play} to show the video/audio of the media in that event.
   # More complex operations are generally more heavily dependent on the capabilities of the backend. For example, QuickTime cannot set the playback rate of certain streaming media - while DirectShow is slightly more flexible in that regard.
   # 
-  # == Operation
+  # ## Operation
   # 
   # 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:
@@ -38,16 +38,16 @@ module Wx
   # 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.
   # 
-  # == Video size
+  # ## Video size
   # 
   # By default, {Wx::MediaCtrl} will scale the size of the video to the requested amount passed to either its constructor or {Wx::MediaCtrl#create}. After calling {Wx::MediaCtrl#load} or performing an equivalent operation, you can subsequently obtain the "real" size of the video (if there is any) by calling {Wx::MediaCtrl#get_best_size}. Note that the actual result on the display will be slightly different when {Wx::MediaCtrl#show_player_controls} is activated and the actual video size will be less than specified due to the extra controls provided by the native toolkit. In addition, the backend may modify {Wx::MediaCtrl#get_best_size} to include the size of the extra controls - so if you want the real size of the video just disable {Wx::MediaCtrl#show_player_controls}.
   # The idea with setting {Wx::MediaCtrl#get_best_size} to the size of the video is that {Wx::MediaCtrl#get_best_size} is a {Wx::Window}-derived function that is called when sizers on a window recalculate. What this means is that if you use sizers by default the video will show in its original size without any extra assistance needed from the user.
   # 
-  # == Player controls
+  # ## Player controls
   # 
   # Normally, when you use {Wx::MediaCtrl} it is just a window for the video to play in. However, some toolkits have their own media player interface. For example, QuickTime generally has a bar below the video with a slider. A special feature available to {Wx::MediaCtrl}, you can use the toolkits interface instead of making your own by using the {Wx::MediaCtrl#show_player_controls} function. There are several options for the flags parameter, with the two general flags being {Wx::MediaCtrlPlayerControls::MEDIACTRLPLAYERCONTROLS_NONE} which turns off the native interface, and {Wx::MediaCtrlPlayerControls::MEDIACTRLPLAYERCONTROLS_DEFAULT} which lets {Wx::MediaCtrl} decide what native controls on the interface. Be sure to review the caveats outlined in Video size before doing so.
   # 
-  # == Choosing a backend
+  # ## Choosing a backend
   # 
   # Generally, you should almost certainly leave this part up to {Wx::MediaCtrl} - but if you need a certain backend for a particular reason, such as QuickTime for playing .mov files, all you need to do to choose a specific backend is to pass the name of the backend class to {Wx::MediaCtrl#create}.
   # The following are valid backend identifiers:
@@ -57,24 +57,23 @@ module Wx
   # - <b>{Wx::MEDIABACKEND_GSTREAMER}</b>, Use GStreamer. Unix Only. Requires GStreamer 0.10 along with at the very least the xvimagesink, xoverlay and gst-play modules of gstreamer to function. You need the correct modules to play the relevant files, for example the mad module to play mp3s, etc.
   # - <b>{Wx::MEDIABACKEND_WMP10}</b>, Use Windows Media Player 10 (Windows only). Works on systems with either Windows Media Player 9 or 10 installed.
   # 
-  # == Creating a backend
+  # ## Creating a backend
   # 
   # Creating a backend for {Wx::MediaCtrl} is a rather simple process. Simply derive from {Wx::MediaBackendCommonBase} and implement the methods you want. The methods in {Wx::MediaBackend} correspond to those in {Wx::MediaCtrl} except for {Wx::MediaCtrl::CreateControl} which does the actual creation of the control, in cases where a custom control is not needed you may simply call {Wx::Control#create}.
   # You need to make sure to use the {Wx::DECLARE_CLASS} and {Wx::IMPLEMENT_CLASS} macros.
   # The only real tricky part is that you need to make sure the file in compiled in, which if there are just backends in there will not happen and you may need to use a force link hack (see {Wx::FORCE_LINK_MODULE} usage in the mediactrl sample).
   # There is a rather simple example of how to create a backend in the {Wx::ActiveXContainer} documentation.
-  # === Styles
+  # ### Styles
   # 
   # This class supports the following styles:
   # 
   # - {Wx::MC_NO_AUTORESIZE}: By default, the control will automatically adjust its size to exactly fit the size of a loaded video as soon as a video is loaded. If this flag is given, the control will not change its size automatically and it must be done manually (if desired) using {Wx::MediaCtrl#layout}. It is strongly recommended to use this flag and handle control resizing manually (note that this style is only available in wxWidgets 3.1.6, so it is only possible to do it when using this or later version). 
   # 
-  # === 
-  # 
   # Category:  {Wx::Multimedia}
   # @see Wx::MediaEvent 
   # 
   # 
+  # @wxrb_require USE_MEDIACTRL
   class MediaCtrl < Control
   
     # @overload initialize()
@@ -137,13 +136,17 @@ module Wx
     alias_method :state, :get_state
     
     # Gets the volume of the media from a 0.0 to 1.0 range.
-    # Due to rounding and other errors the value returned may not be the exact value sent to {Wx::MediaCtrl#set_volume}.
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Due to rounding and other errors the value returned may not be the exact value sent to {Wx::MediaCtrl#set_volume}. 
+    # </p>
+    # </div>
     # @return [Float]
     def get_volume; end
     alias_method :volume, :get_volume
     
     # Obtains the length - the total amount of time the media has in milliseconds.
-    # @return [Wx::FileOffset]
+    # @return [Integer]
     def length; end
     
     # @overload load(fileName)
@@ -154,13 +157,13 @@ module Wx
     # @overload load(uri)
     #   Loads the location that uri refers to.
     #   Note that this is very implementation-dependent, although HTTP URI/URLs are generally supported, for example. Returns false if loading fails.
-    #   @param uri [Wx::URI] 
+    #   @param uri [URI] 
     #   @return [Boolean]
     # @overload load(uri, proxy)
     #   Loads the location that uri refers to with the proxy proxy.
     #   Not implemented on most backends so it should be called with caution. Returns false if loading fails.
-    #   @param uri [Wx::URI] 
-    #   @param proxy [Wx::URI] 
+    #   @param uri [URI] 
+    #   @param proxy [URI] 
     #   @return [Boolean]
     def load(*args) end
     
@@ -187,9 +190,9 @@ module Wx
     
     # Seeks to a position within the media.
     # TodoDocument the {Wx::SeekMode} parameter mode, and perhaps also the {Wx::FileOffset} and {Wx::SeekMode} themselves.
-    # @param where [Wx::FileOffset] 
+    # @param where [Integer] 
     # @param mode [Wx::SeekMode] 
-    # @return [Wx::FileOffset]
+    # @return [Integer]
     def seek(where, mode=Wx::SeekMode::FromStart) end
     
     # Sets the playback rate, or speed of the media, to that referred by dRate.
@@ -201,7 +204,12 @@ module Wx
     
     # Sets the volume of the media from a 0.0 to 1.0 range to that referred by dVolume.
     # 1.0 represents full volume, while 0.5 represents half (50 percent) volume, for example.
-    # The volume may not be exact due to conversion and rounding errors, although setting the volume to full or none is always exact. Returns true if successful.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>The volume may not be exact due to conversion and rounding errors, although setting the volume to full or none is always exact. Returns true if successful. 
+    # </p>
+    # </div>
     # @param dVolume [Float] 
     # @return [Boolean]
     def set_volume(dVolume) end
@@ -221,7 +229,7 @@ module Wx
     def stop; end
     
     # Obtains the current position in time within the media in milliseconds.
-    # @return [Wx::FileOffset]
+    # @return [Integer]
     def tell; end
     
   end # MediaCtrl

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

@@ -15,6 +15,7 @@ module Wx
   # @see Wx::MediaCtrl#get_state 
   # 
   # 
+  # @wxrb_require USE_MEDIACTRL
   class MediaState < Wx::Enum
   
     # No media is being currently played.
@@ -35,6 +36,7 @@ module Wx
   # 
   # 
   # 
+  # @wxrb_require USE_MEDIACTRL
   class MediaCtrlPlayerControls < Wx::Enum
   
     # No controls.
@@ -80,7 +82,7 @@ module Wx
   EVT_MEDIA_PAUSE = 10327
   
   # Event {Wx::MediaCtrl} uses.
-  # === Events using this class
+  # ### Events using this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MediaEvent} events.
   # Event handler methods:
@@ -97,14 +99,13 @@ module Wx
   # 
   # - {Wx::EvtHandler#evt_media_pause}(id, meth = nil, &block): Sent when a media has switched to the {Wx::MediaState::MEDIASTATE_PAUSED} state. Processes a {Wx::EVT_MEDIA_PAUSE} event type. 
   # 
-  # === 
-  # 
   # Category:  {Wx::Events}
   # 
+  # @wxrb_require USE_MEDIACTRL
   class MediaEvent < NotifyEvent
   
     # Default ctor.
-    # @param commandType [Wx::CommandLinkButton::EventType] 
+    # @param commandType [Wx::Slider::EventType] 
     # @param winid [Integer] 
     # @return [Wx::MediaEvent]
     def initialize(commandType=Wx::EVT_NULL, winid=0) end

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

@@ -55,8 +55,6 @@ module Wx
   #   end
   # ```
   # 
-  # === 
-  # 
   # Category:  Device Contexts
   # @see Wx::Bitmap
   # @see  Wx::DC 
@@ -76,7 +74,12 @@ module Wx
     
     # Selects the given bitmap into the device context, to use as the memory bitmap.
     # Selecting the bitmap as source into a memory DC allows you to copy its contents to another device context using {Wx::DC#blit}. Note that using {Wx::DC#draw_bitmap} or {Wx::DC#draw_icon} is a simpler way to do the same thing.
-    # Modifying a bitmap selected only as a source may not work correctly and can notably modify the other bitmaps sharing the same data due to the use of reference counting (see Reference Counting).
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Modifying a bitmap selected only as a source may not work correctly and can notably modify the other bitmaps sharing the same data due to the use of reference counting (see Reference Counting).
+    # </p>
+    # </div>
     # 
     # If the argument is {Wx::NULL_BITMAP} (or some other uninitialised {Wx::Bitmap}) the current bitmap is selected out of the device context, allowing the current bitmap to be destroyed safely.
     # @param bitmap [Wx::Bitmap] 
@@ -95,7 +98,6 @@ module Wx
   # 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
@@ -142,7 +144,6 @@ module Wx
   
   # 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
@@ -159,7 +160,6 @@ module Wx
   # 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

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

@@ -9,23 +9,27 @@ module Wx
   # A menu is a popup (or pull down) list of items, one of which may be selected before the menu goes away (clicking elsewhere dismisses the menu).
   # Menus may be used to construct either menu bars or popup menus.
   # A menu item has an integer ID associated with it which can be used to identify the selection, or to change the menu item in some way. A menu item with a special identifier {Wx::StandardID::ID_SEPARATOR} is a separator item and doesn't have an associated command but just makes a separator line appear in the menu.
-  # Please note that {Wx::StandardID::ID_ABOUT} and {Wx::StandardID::ID_EXIT} are predefined by wxWidgets and have a special meaning since entries using these IDs will be taken out of the normal menus under macOS and will be inserted into the system menu (following the appropriate macOS interface guideline).
+  # 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>Please note that {Wx::StandardID::ID_ABOUT} and {Wx::StandardID::ID_EXIT} are predefined by wxWidgets and have a special meaning since entries using these IDs will be taken out of the normal menus under macOS and will be inserted into the system menu (following the appropriate macOS interface guideline).
+  # </p>
+  # </div>
   # 
   # Menu items may be either normal items, check items or radio items. Normal items don't have any special properties while the check items have a boolean flag associated to them and they show a checkmark in the menu when the flag is set. wxWidgets automatically toggles the flag value when the item is clicked and its value may be retrieved using either {Wx::Menu#is_checked} method of {Wx::Menu} or {Wx::MenuBar} itself or by using {Wx::Event::IsChecked} when you get the menu notification for the item in question.
   # The radio items are similar to the check items except that all the other items in the same radio group are unchecked when a radio item is checked. The radio group is formed by a contiguous range of radio items, i.e. it starts at the first item of this kind and ends with the first item of a different kind (or the end of the menu). Notice that because the radio groups are defined in terms of the item positions inserting or removing the items in the menu containing the radio items risks to not work correctly.
   # 
-  # == Allocation strategy
+  # ## Allocation strategy
   # 
   # All menus must be created on the <b>heap</b> because all menus attached to a menubar or to another menu will be deleted by their parent when it is deleted. The only exception to this rule are the popup menus (i.e. menus used with {Wx::Window#popup_menu}) as wxWidgets does not destroy them to allow reusing the same menu more than once. But the exception applies only to the menus themselves and not to any submenus of popup menus which are still destroyed by wxWidgets as usual and so must be heap-allocated.
   # As the frame menubar is deleted by the frame itself, it means that normally all menus used are deleted automatically.
   # 
-  # == Event handling
+  # ## Event handling
   # 
   # Event handlers for the commands generated by the menu items can be connected directly to the menu object itself using {Wx::EvtHandler#bind}. If this menu is a submenu of another one, the events from its items can also be processed in the parent menu and so on, recursively.
   # If the menu is part of a menu bar, then events can also be handled in {Wx::MenuBar} object.
   # Finally, menu events can also be handled in the associated window, which is either the {Wx::Frame} associated with the menu bar this menu belongs to or the window for which {Wx::Window#popup_menu} was called for the popup menus.
   # See Dynamic Event Handling for how to bind event handlers to the various objects.
-  # === 
   # 
   # Category:  {Wx::Menus}
   # @see Wx::MenuBar
@@ -34,6 +38,7 @@ module Wx
   # @see  wxFileHistory (most recently used files menu) 
   # 
   # 
+  # @wxrb_require USE_MENUS
   class Menu < EvtHandler
   
     # Returns the list of items in the menu.
@@ -48,7 +53,7 @@ module Wx
     # @overload initialize(title, style=0)
     #   Constructs a {Wx::Menu} object with a title.
     #   @param title [String]  Title at the top of the menu (not always supported).
-    #   @param style [Integer]  If set to {Wx::MENU_TEAROFF}, the menu will be detachable (wxGTK and {Wx::QT} only).
+    #   @param style [Integer]  If set to {Wx::MENU_TEAROFF}, the menu will be detachable (WXGTK and {Wx::QT} only).
     #   @return [Wx::Menu]
     def initialize(*args) end
     
@@ -63,7 +68,11 @@ module Wx
     #     file_menu.append(Wx::ID_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.
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>This command can be used after the menu has been shown, as well as on initial creation of a menu or menubar.
+    #   </p>
+    #   </div>>
     #   @see Wx::Menu#append_separator
     #   @see  Wx::Menu#append_check_item
     #   @see  Wx::Menu#append_radio_item
@@ -82,7 +91,11 @@ module Wx
     #   Adds a menu item object.
     #   This is the most generic variant of {Wx::Menu#append} method because it may be used for both items (including separators) and submenus and because you can also specify various extra properties of a menu item this way, such as bitmaps and fonts.
     #   
-    #   See the remarks for the other {Wx::Menu#append} overloads.
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>See the remarks for the other {Wx::Menu#append} overloads.
+    #   </p>
+    #   </div>>
     #   @see Wx::Menu#append_separator
     #   @see  Wx::Menu#append_check_item
     #   @see  Wx::Menu#append_radio_item
@@ -108,7 +121,12 @@ module Wx
     
     # Adds a radio item to the end of the menu.
     # All consequent radio items form a group and when an item in the group is checked, all the others are automatically unchecked.
-    # Radio items are not supported under {Wx::Motif}.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Radio items are not supported under {Wx::Motif}.
+    # </p>
+    # </div>
     # @see Wx::Menu#append
     # @see  Wx::Menu#insert_radio_item 
     # @param id [Integer] 
@@ -135,7 +153,7 @@ module Wx
     def append_sub_menu(submenu, text, help=('')) end
     
     # Inserts a break in a menu, causing the next appended item to appear in a new column.
-    # This function only actually inserts a break in wxMSW and does nothing under the other platforms.
+    # This function only actually inserts a break in WXMSW and does nothing under the other platforms.
     # @return [void]
     def break_; end
     
@@ -203,7 +221,11 @@ module Wx
     #   Finds the menu id for a menu item string.
     #   Menu item identifier, or {Wx::NOT_FOUND} if none is found.
     #   
-    #   Any special menu codes are stripped out of source and target strings before matching.
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>Any special menu codes are stripped out of source and target strings before matching. 
+    #   </p>
+    #   </div>>
     #   @param itemString [String]  Menu item string to find.
     #   @return [Integer]
     # @overload find_item(id, menu=nil)
@@ -336,18 +358,6 @@ module Wx
     def is_enabled(id) end
     alias_method :enabled?, :is_enabled
     
-    # Allows handling native MSW menu command messages.
-    # This is a low-level function which allows handling MSW WM_COMMAND messages generated when menu items are selected. It is particularly useful for the popup menus, as specific handling can then be defined in a {Wx::Menu}-derived class directly, instead of in the {Wx::Window}-derived owner class.
-    # The base class version of this function generates {Wx::EVT_MENU} command events.
-    # 
-    # true if the command was handled, false otherwise.
-    # 
-    # Availability:  only available for the wxMSW port.  {Wx::msw}
-    # @param param [WXUINT]  The MSW command parameter.
-    # @param id [WXWORD]  The id of the command.
-    # @return [Boolean]
-    def msw_command(param, id) end
-    
     # @overload prepend(item)
     #   Inserts the given item at position 0, i.e. before all the other existing items.
     #   
@@ -438,7 +448,11 @@ module Wx
     def set_label(id, label) end
     
     # Sets the title of the menu.
-    # Notice that you can only call this method directly for the popup menus, to change the title of a menu that is part of a menu bar you need to use {Wx::MenuBar#set_label_top}.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Notice that you can only call this method directly for the popup menus, to change the title of a menu that is part of a menu bar you need to use {Wx::MenuBar#set_label_top}.
+    # </p>
+    # </div>>
     # @see Wx::Menu#get_title 
     # @param title [String]  The title to set.
     # @return [void]

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

@@ -7,21 +7,25 @@
 module Wx
 
   # A menu bar is a series of menus accessible from the top of a frame.
-  # To respond to a menu selection, provide a handler for EVT_MENU, in the frame that contains the menu bar.
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>To respond to a menu selection, provide a handler for EVT_MENU, in the frame that contains the menu bar.
+  # </p>
+  # </div>>
   # 
   # If you have a toolbar which uses the same identifiers as your EVT_MENU entries, events from the toolbar will also be processed by your EVT_MENU event handlers.
   # Tip: under Windows, if you discover that menu shortcuts (for example, Alt-F to show the file menu) are not working, check any EVT_CHAR events you are handling in child windows. If you are not calling event.Skip() for events that you don't process in these event handlers, menu shortcuts may cease to work.
-  # === 
   # 
   # Category:  {Wx::Menus}
   # @see Wx::Menu
   # @see  Events and Event Handling 
   # 
   # 
+  # @wxrb_require USE_MENUBAR
   class MenuBar < Window
   
     # Construct an empty menu bar.
-    # @param style [Integer]  If {Wx::MB_DOCKABLE} the menu bar can be detached (wxGTK only).
+    # @param style [Integer]  If {Wx::MB_DOCKABLE} the menu bar can be detached (WXGTK only).
     # @return [Wx::MenuBar]
     def initialize(style=0) end
     
@@ -34,14 +38,22 @@ module Wx
     def append(menu, title) end
     
     # Checks or unchecks a menu item.
-    # Only use this when the menu bar has been associated with a frame; otherwise, use the {Wx::Menu} equivalent call.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Only use this when the menu bar has been associated with a frame; otherwise, use the {Wx::Menu} equivalent call. 
+    # </p>
+    # </div>>
     # @param id [Integer]  The menu item identifier.
     # @param check [Boolean]  If true, checks the menu item, otherwise the item is unchecked.
     # @return [void]
     def check(id, check) end
     
     # Enables or disables (greys out) a menu item.
-    # Only use this when the menu bar has been associated with a frame; otherwise, use the {Wx::Menu} equivalent call.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Only use this when the menu bar has been associated with a frame; otherwise, use the {Wx::Menu} equivalent call. 
+    # </p>
+    # </div>>
     # @param id [Integer]  The menu item identifier.
     # @param enable [Boolean]  true to enable the item, false to disable it.
     # @return [void]
@@ -54,7 +66,11 @@ module Wx
     alias_method :enabled_top?, :is_enabled_top
     
     # Enables or disables a whole menu.
-    # Only use this when the menu bar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Only use this when the menu bar has been associated with a frame. 
+    # </p>
+    # </div>>
     # @param pos [Integer]  The position of the menu, starting from zero.
     # @param enable [Boolean]  true to enable the menu, false to disable it.
     # @return [void]
@@ -76,7 +92,11 @@ module Wx
     # Finds the menu item id for a menu name/menu item string pair.
     # The menu item identifier, or {Wx::NOT_FOUND} if none was found.
     # 
-    # Any special menu codes are stripped out of source and target strings before matching.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Any special menu codes are stripped out of source and target strings before matching. 
+    # </p>
+    # </div>>
     # @param menuString [String]  Menu title to find.
     # @param itemString [String]  Item to find.
     # @return [Integer]
@@ -93,7 +113,11 @@ module Wx
     # Gets the label associated with a menu item.
     # The menu item label, or the empty string if the item was not found.
     # 
-    # Use only after the menubar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use only after the menubar has been associated with a frame. 
+    # </p>
+    # </div>>
     # @param id [Integer]  The menu item identifier.
     # @return [String]
     def get_label(id) end
@@ -115,7 +139,11 @@ module Wx
     # 
     # The menu label, or the empty string if the menu was not found.
     # 
-    # Use only after the menubar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use only after the menubar has been associated with a frame.
+    # </p>
+    # </div>>
     # @see Wx::MenuBar#get_menu_label_text
     # @see  Wx::MenuBar#set_menu_label 
     # @param pos [Integer]  Position of the menu on the menu bar, starting from zero.
@@ -128,7 +156,11 @@ module Wx
     # 
     # The menu label, or the empty string if the menu was not found.
     # 
-    # Use only after the menubar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use only after the menubar has been associated with a frame.
+    # </p>
+    # </div>>
     # @see Wx::MenuBar#get_menu_label
     # @see  Wx::MenuBar#set_menu_label 
     # @param pos [Integer]  Position of the menu on the menu bar, starting from zero.
@@ -187,7 +219,11 @@ module Wx
     def set_help_string(id, helpString) end
     
     # Sets the label of a menu item.
-    # Use only after the menubar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use only after the menubar has been associated with a frame.
+    # </p>
+    # </div>>
     # @see Wx::MenuBar#get_label 
     # @param id [Integer]  Menu item identifier.
     # @param label [String]  Menu item label.
@@ -195,7 +231,11 @@ module Wx
     def set_label(id, label) end
     
     # Sets the label of a top-level menu.
-    # Use only after the menubar has been associated with a frame.
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use only after the menubar has been associated with a frame. 
+    # </p>
+    # </div>>
     # @param pos [Integer]  The position of a menu on the menu bar, starting from zero.
     # @param label [String]  The menu label.
     # @return [void]