wxruby3 0.9.0-x64-mingw-ucrt → 0.9.2-x64-mingw-ucrt

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

@@ -10,6 +10,7 @@ module Wx
   # 
   # 
   # 
+  # @wxrb_require USE_LOG
   class LogLevelValues < Wx::Enum
   
     # program can't continue, abort immediately
@@ -61,15 +62,19 @@ module Wx
   # {Wx::Log} class defines the interface for the log targets used by wxWidgets logging functions as explained in the Logging Overview.
   # The only situations when you need to directly use this class is when you want to derive your own log target because the existing ones don't satisfy your needs.
   # Otherwise, it is completely hidden behind the wxLogXXX() functions and you may not even know about its existence.
-  # For console-mode applications, the default target is {Wx::LogStderr}, so that all {log_xxx} functions print on stderr when {Wx::Setup::USE_GUI} = 0.
   # 
-  # === 
+  # <div class="wxrb-note">
+  # <b>Note:</b>
+  # <p>For console-mode applications, the default target is {Wx::LogStderr}, so that all {log_xxx} functions print on stderr when {Wx::Setup::USE_GUI} = 0.
+  # </p>
+  # </div>
   # 
   # Category:  {Wx::Logging}
   # @see Logging Overview
   # @see  wxLogXXX() functions 
   # 
   # 
+  # @wxrb_require USE_LOG
   class Log < ::Object
   
     # Add the mask to the list of allowed masks for {log_trace}.
@@ -294,12 +299,12 @@ module Wx
   # {Wx::LogBuffer} is a very simple implementation of log sink which simply collects all the logged messages in a string (except the debug messages which are output in the usual way immediately as we're presumably not interested in collecting them for later).
   # The messages from different log function calls are separated by the new lines.
   # All the messages collected so far can be shown to the user (and the current buffer cleared) by calling the overloaded {Wx::LogBuffer#flush} method.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogBuffer < Log
   
     # The default ctor does nothing.
@@ -325,10 +330,9 @@ module Wx
   #   ...
   # ```
   # 
-  # === 
-  # 
   # Category:  {Wx::Logging}
   # 
+  # @wxrb_require USE_LOG
   class LogChain < Log
   
     # Sets the specified logger (which may be NULL) as the default log target but the log messages are also passed to the previous log target if any.
@@ -370,12 +374,12 @@ module Wx
   # Also notice that if an error message is logged when several informative messages had been already logged before, the informative messages are discarded on the assumption that they are not useful  and may be confusing and hence harmful  any more after the error. The warning and error messages are never discarded however and any informational messages logged after the first error one are also kept (as they may contain information about the error recovery). You may override DoLog() method to change this behaviour.
   # At any rate, it is possible that that several messages were accumulated before this class {Wx::LogGui#flush} method is called. If this is the case, {Wx::LogGui#flush} uses a custom dialog which shows the last message directly and allows the user to view the previously logged ones by expanding the "Details" {Wx::CollapsiblePane} inside it. This custom dialog also provides the buttons for copying the log messages to the clipboard and saving them to a file.
   # However if only a single message is present when {Wx::LogGui#flush} is called, just a {message_box} is used to show it. This has the advantage of being closer to the native behaviour but it doesn't give the user any possibility to copy or save the message (except for the recent Windows versions where <code>Ctrl-C</code> may be pressed in the message box to copy its contents to the clipboard) so you may want to override {Wx::LogGui#do_show_single_log_message} to customize {Wx::LogGui}  the dialogs sample shows how to do this.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogGui < Log
   
     # Default constructor.
@@ -386,7 +390,6 @@ module Wx
   
   # This class can be used to redirect the log messages to a C file stream (not to be confused with C++ streams).
   # It is the default log target for the non-GUI wxWidgets applications which send all the output to stderr.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # @see Wx::LogStream 
@@ -394,13 +397,13 @@ module Wx
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogStderr < Log
   
   end # LogStderr
   
   # Using these target all the log messages can be redirected to a text control.
   # The text control must have been created with {Wx::TE_MULTILINE} style by the caller previously.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # @see Wx::TextCtrl
@@ -409,6 +412,7 @@ module Wx
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogTextCtrl < Log
   
     # Constructs a log target which sends all the log messages to the given text control.
@@ -423,10 +427,10 @@ module Wx
   # It forwards log messages to the previously installed one in addition to processing them itself.
   # Unlike {Wx::LogChain} which is usually used directly as is, this class must be derived from to implement {Wx::Log::DoLog} and/or {Wx::Log::DoLogString} methods.
   # {Wx::LogInterposer} destroys the previous log target in its destructor. If you don't want this to happen, use {Wx::LogInterposerTemp} instead.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # 
+  # @wxrb_require USE_LOG
   class LogInterposer < LogChain
   
     # The default constructor installs this object as the current active log target.
@@ -437,12 +441,12 @@ module Wx
   
   # This class represents a background log window: to be precise, it collects all log messages in the log frame which it manages but also passes them on to the log target which was active at the moment of its creation.
   # This allows you, for example, to show all the log messages in a frame but still continue to process them normally by showing the standard log dialog.
-  # === 
   # 
   # Category:  {Wx::Logging}
   # @see Wx::LogTextCtrl 
   # 
   # 
+  # @wxrb_require USE_LOG
   class LogWindow < LogInterposer
   
     # Creates the log frame window and starts collecting the messages in it.
@@ -513,12 +517,11 @@ module Wx
   #   end
   # ```
   # 
-  # === 
-  # 
   # Category:  {Wx::Logging}
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogNull < ::Object
   
   end # LogNull
@@ -528,6 +531,7 @@ module Wx
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_LOG
   class LogRecordInfo < ::Object
   
   end # LogRecordInfo

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

@@ -7,10 +7,15 @@
 module Wx
 
   # An MDI client window is a child of {Wx::MDIParentFrame}, and manages zero or more {Wx::MDIChildFrame} objects.
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>
+  # </p>
+  # </div>>
+  # 
   # The client window is the area where MDI child windows exist. It doesn't have to cover the whole parent frame; other windows such as toolbars and a help window might coexist with it. There can be scrollbars on a client window, which are controlled by the parent window style.
   # The {Wx::MDIClientWindow} class is usually adequate without further derivation, and it is created automatically when the MDI parent frame is created. If the application needs to derive a new class, the function {Wx::MDIParentFrame#on_create_client} must be overridden in order to give an opportunity to use a different class of client window.
-  # 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.
-  # === 
+  # 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.
   # 
   # Category:  Managed Windows
   # @see Wx::MDIChildFrame
@@ -18,6 +23,7 @@ module Wx
   # @see  Wx::Frame 
   # 
   # 
+  # @wxrb_require USE_MDI
   class MDIClientWindow < Window
   
     # Default constructor.

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,17 +31,24 @@ module Wx
   # @see  Wx::Dialog 
   # 
   # 
+  # @wxrb_require USE_MDI
   class MDIParentFrame < Frame
   
     # @overload initialize()
     #   Default constructor.
     #   Use {Wx::MDIParentFrame#create} for the objects created using this constructor.
     #   @return [Wx::MDIParentFrame]
-    # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::DEFAULT_FRAME_STYLE|Wx::VSCROLL|Wx::HSCROLL), name=Wx::FrameNameStr)
+    # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::DEFAULT_FRAME_STYLE|Wx::VSCROLL|Wx::HSCROLL), name=Wx::FRAME_NAME_STR)
     #   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.
@@ -86,7 +97,7 @@ module Wx
     # @param style [Integer] 
     # @param name [String] 
     # @return [Boolean]
-    def create(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::DEFAULT_FRAME_STYLE|Wx::VSCROLL|Wx::HSCROLL), name=Wx::FrameNameStr) end
+    def create(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=(Wx::DEFAULT_FRAME_STYLE|Wx::VSCROLL|Wx::HSCROLL), name=Wx::FRAME_NAME_STR) end
     
     # Returns a pointer to the active MDI child, if there is one.
     # If there are any children at all this function returns a non-NULL pointer.
@@ -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,12 +191,13 @@ module Wx
   # @see  Wx::Frame 
   # 
   # 
+  # @wxrb_require USE_MDI
   class MDIChildFrame < Frame
   
     # @overload initialize()
     #   Default constructor.
     #   @return [Wx::MDIChildFrame]
-    # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_FRAME_STYLE, name=Wx::FrameNameStr)
+    # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_FRAME_STYLE, name=Wx::FRAME_NAME_STR)
     #   Constructor, creating the window.
     #   
     #   @see Wx::MDIChildFrame#create 
@@ -207,7 +228,7 @@ module Wx
     # @param style [Integer] 
     # @param name [String] 
     # @return [Boolean]
-    def create(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_FRAME_STYLE, name=Wx::FrameNameStr) end
+    def create(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_FRAME_STYLE, name=Wx::FRAME_NAME_STR) end
     
     # Returns the MDI parent frame containing this child.
     # Notice that this may return a different object than {Wx::MDIChildFrame#get_parent} as the child frames may be created as children of the client window internally.

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,30 +57,29 @@ 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()
     #   Default constructor - you MUST call {Wx::MediaCtrl#create} before calling any other methods of {Wx::MediaCtrl}.
     #   @return [Wx::MediaCtrl]
-    # @overload initialize(parent, id, fileName=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=(''), validator=Wx::DEFAULT_VALIDATOR, name=("mediaCtrl"))
+    # @overload initialize(parent, id, fileName=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=(''), validator=Wx::DEFAULT_VALIDATOR, name=("MEDIA_CTRL"))
     #   Constructor that calls {Wx::MediaCtrl#create}.
     #   You may prefer to call {Wx::MediaCtrl#create} directly to check to see if {Wx::MediaCtrl} is available on the system.
     #   @param parent [Wx::Window]  parent of this control. Must not be NULL.
@@ -108,7 +107,7 @@ module Wx
     # @param validator [Wx::Validator]  validator to use.
     # @param name [String]  Window name.
     # @return [Boolean]
-    def create(parent, id, fileName=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=(''), validator=Wx::DEFAULT_VALIDATOR, name=("mediaCtrl")) end
+    def create(parent, id, fileName=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=(''), validator=Wx::DEFAULT_VALIDATOR, name=("MEDIA_CTRL")) end
     
     # Obtains the best size relative to the original/natural size of the video, if there is any.
     # See Video size for more information.
@@ -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