wxruby3 0.9.0.pre.rc.1-x64-mingw-ucrt → 0.9.0.pre.rc.3-x64-mingw-ucrt

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

@@ -3780,33 +3780,6 @@ 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}.
   # 
-  # ```
-  #   # this imports gettext ( equivalent to Wx::GetTranslation
-  #   # and gettext_noop ( a noop )
-  #   # into your module
-  #   use Wx::Locale qw(:default);
-  #   
-  #   # ....
-  #   
-  #   # use the functions
-  #   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';
-  #   
-  #   # ...
-  #   
-  #   # use the functions
-  #   print t( "Panic!!" );
-  #   
-  #   # ...
-  # ```
   #  
   # === 
   # 
@@ -3821,12 +3794,12 @@ module Wx
   
     # @overload initialize()
     #   This is the default constructor and it does nothing to initialize the object: {Wx::Locale#init} must be used to do that.
-    #   @return [Locale]
+    #   @return [Wx::Locale]
     # @overload initialize(language, flags=Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT)
     #   See {Wx::Locale#init} for parameters description.
     #   @param language [Integer] 
     #   @param flags [Integer] 
-    #   @return [Locale]
+    #   @return [Wx::Locale]
     # @overload initialize(name, shortName=(''), locale=(''), bLoadDefault=true)
     #   See {Wx::Locale#init} for parameters description.
     #   The call of this function has several global side effects which you should understand: first of all, the application locale is changed - note that this will affect many of standard C library functions such as printf() or strftime(). Second, this {Wx::Locale} object becomes the new current global locale for the application and so all subsequent calls to {get_translation} will try to translate the messages using the message catalogs for this locale.
@@ -3834,7 +3807,7 @@ module Wx
     #   @param shortName [String] 
     #   @param locale [String] 
     #   @param bLoadDefault [true,false] 
-    #   @return [Locale]
+    #   @return [Wx::Locale]
     def initialize(*args) end
     
     # @overload add_catalog(domain)
@@ -3911,7 +3884,9 @@ module Wx
     # true on success or false if the given locale couldn't be set.
     # @param language [Integer]  {Wx::Language} identifier of the locale. It can be either some concrete language, e.g. {Wx::Language::LANGUAGE_ESPERANTO}, or a special value {Wx::Language::LANGUAGE_DEFAULT} which means that {Wx::Locale} should use system's default language (see {Wx::Locale.get_system_language}). Notice that the value {Wx::Language::LANGUAGE_UNKNOWN} is not allowed here.
     # @param flags [Integer]  Combination of the following:
-    #   - {Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT}: Load the message catalog for the given locale containing the translations of standard wxWidgets messages automatically.- {Wx::LocaleInitFlags::LOCALE_DONT_LOAD_DEFAULT}: Negation of {Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT}.
+    #   
+    #   - {Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT}: Load the message catalog for the given locale containing the translations of standard wxWidgets messages automatically.
+    #   - {Wx::LocaleInitFlags::LOCALE_DONT_LOAD_DEFAULT}: Negation of {Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT}.
     # @return [true,false]
     def init(language=Wx::Language::LANGUAGE_DEFAULT, flags=Wx::LocaleInitFlags::LOCALE_LOAD_DEFAULT) end
     
@@ -4016,24 +3991,24 @@ module Wx
   class LanguageInfo < ::Object
   
     # Win32 language identifiers (LANG_xxxx, SUBLANG_xxxx).
-    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # Availability:  only available for the wxMSW port.  {Wx::msw}
     # 
     # @return [Integer]
     def win_lang; end
     # Win32 language identifiers (LANG_xxxx, SUBLANG_xxxx).
-    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # Availability:  only available for the wxMSW port.  {Wx::msw}
     # 
     # @param val [Integer]
     # @return [void]
     def win_lang=(val); end
     
     # Win32 language identifiers (LANG_xxxx, SUBLANG_xxxx).
-    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # Availability:  only available for the wxMSW port.  {Wx::msw}
     # 
     # @return [Integer]
     def win_sublang; end
     # Win32 language identifiers (LANG_xxxx, SUBLANG_xxxx).
-    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # Availability:  only available for the wxMSW port.  {Wx::msw}
     # 
     # @param val [Integer]
     # @return [void]
@@ -4124,7 +4099,7 @@ module Wx
     def layout_direction=(val); end
     
     # Return the LCID corresponding to this language.
-    # Availability:  only available for the {Wx::MSW} port.  {Wx::msw}
+    # Availability:  only available for the wxMSW port.  {Wx::msw}
     # @return [Integer]
     def get_lcid; end
     alias_method :lcid, :get_lcid

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

@@ -162,8 +162,8 @@ 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);
+    # ```ruby
+    #   wxLog.set_component_level("wx/net", Wx::LOG_Error)
     # ```
     # 
     # {Wx::Log.set_log_level} may be used to set the global log level.
@@ -249,19 +249,20 @@ 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)
-    #   {
-    #       // let the previous logger show it
-    #       if ( m_logOld && IsPassingMessages() )
-    #           m_logOld->LogRecord(level, msg, info);
-    #   
-    #       // and also send it to the new one
-    #       if ( m_logNew && m_logNew != this )
-    #           m_logNew->LogRecord(level, msg, info);
-    #   }
+    # ```ruby
+    #   class Wx::LogChain
+    # 
+    #     def do_log_record(level, msg, info)
+    #        # let the previous logger show it
+    #        if m_logOld && is_passing_messages
+    #            m_logOld.log_record(level, msg, info)
+    #     
+    #        # and also send it to the new one
+    #        if m_logNew && m_logNew != self
+    #            m_logNew.log_record(level, msg, info)
+    #     end
+    # 
+    #   end
     # ```
     # @param level [Wx::LogLevel] 
     # @param msg [String] 
@@ -269,6 +270,32 @@ module Wx
     # @return [void]
     def log_record(level, msg, info) end
     
+    
+    protected
+    
+    # Called to log a new record.
+    # Any log message created by {log_xxx}, the corresponding prefix to msg and passes it to {Wx::Log#do_log_text_at_level}.
+    # You may override this method to implement custom formatting of the log messages or to implement custom filtering of log messages (e.g. you could discard all log messages coming from the given source file).
+    # @param level [Wx::LogLevel] 
+    # @param msg [String] 
+    # @param info [Wx::LogRecordInfo] 
+    # @return [void]
+    def do_log_record(level, msg, info) end
+    
+    # Called to log the specified string at given level.
+    # The base class versions logs debug and trace messages on the system default debug output channel and passes all the other messages to {Wx::Log#do_log_text}.
+    # @param level [Wx::LogLevel] 
+    # @param msg [String] 
+    # @return [void]
+    def do_log_text_at_level(level, msg) end
+    
+    # Called to log the specified string.
+    # A simple implementation might just send the string to stdout or stderr or save it in a file (of course, the already existing {Wx::LogStderr} can be used for this).
+    # The base class version of this function asserts so it must be overridden if you don't override {Wx::Log#do_log_record} or {Wx::Log#do_log_text_at_level}.
+    # @param msg [String] 
+    # @return [void]
+    def do_log_text(msg) end
+    
   end # Log
   
   # {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).
@@ -278,10 +305,12 @@ module Wx
   # 
   # Category:  {Wx::Logging}
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogBuffer < Log
   
     # The default ctor does nothing.
-    # @return [LogBuffer]
+    # @return [Wx::LogBuffer]
     def initialize; end
     
     # Returns the current buffer contains.
@@ -296,15 +325,11 @@ 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);
+  # ```ruby
+  #   logChain = Wx::LogChain.new(Wx::LogStderr.new)
   #   
-  #   // all the log messages are sent to stderr and also processed as usually
+  #   # all the log messages are sent to stderr and also processed as usually
   #   ...
-  #   
-  #   // 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...);
   # ```
   # 
   # === 
@@ -315,13 +340,9 @@ module Wx
   
     # 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.
     # @param logger [Wx::Log] 
-    # @return [LogChain]
+    # @return [Wx::LogChain]
     def initialize(logger) end
     
-    # Detaches the old log target so it won't be destroyed when the {Wx::LogChain} object is destroyed.
-    # @return [void]
-    def detach_old_log; end
-    
     # Returns the pointer to the previously active log target (which may be NULL).
     # @return [Wx::Log]
     def get_old_log; end
@@ -345,6 +366,9 @@ module Wx
     def set_log(logger) end
     alias_method :log=, :set_log
     
+    
+    protected
+    
   end # LogChain
   
   # This is the default log target for the GUI wxWidgets applications.
@@ -357,10 +381,12 @@ module Wx
   # 
   # Category:  {Wx::Logging}
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogGui < Log
   
     # Default constructor.
-    # @return [LogGui]
+    # @return [Wx::LogGui]
     def initialize; end
     
   end # LogGui
@@ -373,19 +399,10 @@ module Wx
   # @see Wx::LogStream 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogStderr < Log
   
-    # Constructs a log target which sends all the log messages to the given FILE.
-    # If it is NULL, the messages are sent to stderr. The messages will be written in the encoding specified by the given {Wx::MBConv}.
-    # The conv argument is only available in wxWidgets 3.1.1 and later.
-    # In practice, it is only advisable to specify {Wx::ConvUTF8} as the conv. If using <code>mb_conv_utf16</code>, the file should be opened in <code>"wb"</code> mode.
-    # 
-    # If a log message contains any characters that cannot be converted to the character set given by conv, that message will be silently ignored, i.e. it will not be written at all.
-    # @param fp [FILE] 
-    # @param conv [Wx::MBConv] 
-    # @return [LogStderr]
-    def initialize(fp=nil, conv=Wx::ConvWhateverWorks) end
-    
   end # LogStderr
   
   # This class can be used to redirect the log messages to a C++ stream.
@@ -397,6 +414,8 @@ module Wx
   # @see  Wx::StreamToTextRedirector 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogStream < Log
   
     # Constructs a log target which sends all the log messages to the given output stream.
@@ -407,7 +426,7 @@ module Wx
     # If a log message contains any characters that cannot be converted to the character set given by conv, that message will be silently ignored, i.e. it will not be written at all.
     # @param ostr [std::ostream] 
     # @param conv [Wx::MBConv] 
-    # @return [LogStream]
+    # @return [Wx::LogStream]
     def initialize(ostr=nil, conv=Wx::ConvWhateverWorks) end
     
   end # LogStream
@@ -421,12 +440,14 @@ module Wx
   # @see  Wx::StreamToTextRedirector 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogTextCtrl < Log
   
     # Constructs a log target which sends all the log messages to the given text control.
     # The textctrl parameter cannot be NULL.
     # @param pTextCtrl [Wx::TextCtrl] 
-    # @return [LogTextCtrl]
+    # @return [Wx::LogTextCtrl]
     def initialize(pTextCtrl) end
     
   end # LogTextCtrl
@@ -442,7 +463,7 @@ module Wx
   class LogInterposer < LogChain
   
     # The default constructor installs this object as the current active log target.
-    # @return [LogInterposer]
+    # @return [Wx::LogInterposer]
     def initialize; end
     
   end # LogInterposer
@@ -457,7 +478,7 @@ module Wx
   class LogInterposerTemp < LogChain
   
     # The default constructor installs this object as the current active log target.
-    # @return [LogInterposerTemp]
+    # @return [Wx::LogInterposerTemp]
     def initialize; end
     
   end # LogInterposerTemp
@@ -470,6 +491,8 @@ module Wx
   # @see Wx::LogTextCtrl 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class LogWindow < LogInterposer
   
     # Creates the log frame window and starts collecting the messages in it.
@@ -477,7 +500,7 @@ module Wx
     # @param szTitle [String]  The title for the log frame
     # @param show [true,false]  true to show the frame initially (default), otherwise {Wx::LogWindow#show} must be called later.
     # @param passToOld [true,false]  true to process the log messages normally in addition to logging them in the log frame (default), false to only log them in the log frame. Note that if no targets were set using {Wx::Log.set_active_target} then {Wx::LogWindow} simply becomes the active one and messages won't be passed to other targets.
-    # @return [LogWindow]
+    # @return [Wx::LogWindow]
     def initialize(pParent, szTitle, show=true, passToOld=true) end
     
     # Returns the associated log frame window.
@@ -505,5 +528,59 @@ module Wx
     
   end # LogWindow
   
+  # This class allows you to temporarily suspend logging.
+  # All calls to the log functions during the life time of an object of this class are just ignored.
+  # In particular, it can be used to suppress the log messages given by wxWidgets itself but it should be noted that it is rarely the best way to cope with this problem as <b>all</b> log messages are suppressed, even if they indicate a completely different error than the one the programmer wanted to suppress.
+  # For instance, the example of the overview:
+  # 
+  # ```ruby
+  #   mime_type = ... # retrieved from somewhere
+  #   img = Wx::Image.new
+  #   Wx::LogNull.no_log do     # suspend logging 
+  # 
+  #     # Wx::Image#load_stream will complain if there is no handler for the given mimetype and fail
+  #     if !img.load_stream(File.open('file.img'), mime_type)
+  #       # handle problem
+  #     end
+  # 
+  #   end # old log sink restored
+  #   
+  #   Wx.log_message('...') # ok
+  # ```
+  # 
+  # would be better written as:
+  # 
+  # ```ruby
+  #   mime_type = ... # retrieved from somewhere
+  # 
+  #   # check the condition that makes your code complain
+  #   if Wx::Image.mime_types.include?(mime_type)
+  #     img.load_stream(File.open('file.img'), mime_type)
+  #     ...
+  #   else
+  #     # do something else
+  #     ...
+  #   end
+  # ```
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Logging}
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class LogNull < ::Object
+  
+  end # LogNull
+  
+  # Information about a log record (unit of the log output).
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class LogRecordInfo < ::Object
+  
+  end # LogRecordInfo
+  
 
 end

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

@@ -9,7 +9,7 @@ module Wx
   # An MDI client window is a child of {Wx::MDIParentFrame}, and manages zero or more {Wx::MDIChildFrame} objects.
   # 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 {Wx::MSW}, 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
@@ -22,7 +22,7 @@ module Wx
   
     # Default constructor.
     # Objects of this class are only created by {Wx::MDIParentFrame} which uses the default constructor and calls {Wx::MDIClientWindow#create_client} immediately afterwards.
-    # @return [MDIClientWindow]
+    # @return [Wx::MDIClientWindow]
     def initialize; end
     
     # Called by {Wx::MDIParentFrame} immediately after creating the client window.

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

@@ -32,12 +32,12 @@ module Wx
     # @overload initialize()
     #   Default constructor.
     #   Use {Wx::MDIParentFrame#create} for the objects created using this constructor.
-    #   @return [MDIParentFrame]
+    #   @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)
     #   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 {Wx::MSW}, 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.
     #   @see Wx::MDIParentFrame#create
     #   @see  Wx::MDIParentFrame#on_create_client 
     #   @param parent [Wx::Window]  The window parent. Usually is NULL.
@@ -47,7 +47,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The window size. The value {Wx::DEFAULT_SIZE} indicates a default size, chosen by either the windowing system or wxWidgets, depending on platform.
     #   @param style [Integer]  The window style. Default value includes {Wx::HSCROLL} and {Wx::VSCROLL} styles.
     #   @param name [String]  The name of the window. This parameter is used to associate a name with the item, allowing the application user to set Motif resource values for individual windows.
-    #   @return [MDIParentFrame]
+    #   @return [Wx::MDIParentFrame]
     def initialize(*args) end
     
     # Activates the MDI child following the currently active one.
@@ -112,9 +112,9 @@ 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");
+    # ```ruby
+    #   frame = MyParentFrame.new
+    #   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.
@@ -128,7 +128,13 @@ module Wx
     # Ownership of the menu object passes to the frame when you call this function, i.e. the menu will be deleted by it when it's no longer needed (usually when the frame itself is deleted or when {Wx::MDIParentFrame#set_window_menu} is called again).
     # To remove the window completely, you can use the {Wx::FRAME_NO_WINDOW_MENU} window style but this function also allows doing it by passing NULL pointer as menu.
     # The menu may include the items with the following standard identifiers (but may use arbitrary text and help strings and bitmaps for them):
-    # - {Wx::StandardID::ID_MDI_WINDOW_CASCADE} - {Wx::StandardID::ID_MDI_WINDOW_TILE_HORZ} - {Wx::StandardID::ID_MDI_WINDOW_TILE_VERT} - {Wx::StandardID::ID_MDI_WINDOW_ARRANGE_ICONS} - {Wx::StandardID::ID_MDI_WINDOW_PREV} - {Wx::StandardID::ID_MDI_WINDOW_NEXT} All of which are handled by {Wx::MDIParentFrame} itself. If any other commands are used in the menu, the derived frame should handle them.
+    # 
+    # - {Wx::StandardID::ID_MDI_WINDOW_CASCADE} 
+    # - {Wx::StandardID::ID_MDI_WINDOW_TILE_HORZ} 
+    # - {Wx::StandardID::ID_MDI_WINDOW_TILE_VERT} 
+    # - {Wx::StandardID::ID_MDI_WINDOW_ARRANGE_ICONS} 
+    # - {Wx::StandardID::ID_MDI_WINDOW_PREV} 
+    # - {Wx::StandardID::ID_MDI_WINDOW_NEXT} All of which are handled by {Wx::MDIParentFrame} itself. If any other commands are used in the menu, the derived frame should handle them.
     # 
     # This function is currently not available under macOS.
     # @param menu [Wx::Menu]  The menu to be used instead of the standard MDI Window menu or NULL.
@@ -169,7 +175,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [MDIChildFrame]
+    #   @return [Wx::MDIChildFrame]
     # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_FRAME_STYLE, name=Wx::FrameNameStr)
     #   Constructor, creating the window.
     #   
@@ -181,7 +187,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The window size. The value {Wx::DEFAULT_SIZE} indicates a default size, chosen by either the windowing system or wxWidgets, depending on platform.
     #   @param style [Integer]  The window style. See {Wx::MDIChildFrame}.
     #   @param name [String]  The name of the window. This parameter is used to associate a name with the item, allowing the application user to set Motif resource values for individual windows.
-    #   @return [MDIChildFrame]
+    #   @return [Wx::MDIChildFrame]
     def initialize(*args) end
     
     # Activates this MDI child frame.

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

@@ -52,7 +52,10 @@ module Wx
   # 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:
   # 
-  # - <b>{Wx::MEDIABACKEND_DIRECTSHOW}:</b> Use ActiveMovie/DirectShow. Uses the native ActiveMovie (I.E. DirectShow) control. Default backend on Windows and supported by nearly all Windows versions. May display a windows media player logo while inactive.- <b>{Wx::MEDIABACKEND_QUICKTIME}:</b> Use QuickTime. Mac Only. WARNING: May not work correctly when embedded in a {Wx::Notebook}.- <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.
+  # - <b>{Wx::MEDIABACKEND_DIRECTSHOW}:</b> Use ActiveMovie/DirectShow. Uses the native ActiveMovie (I.E. DirectShow) control. Default backend on Windows and supported by nearly all Windows versions. May display a windows media player logo while inactive.
+  # - <b>{Wx::MEDIABACKEND_QUICKTIME}:</b> Use QuickTime. Mac Only. WARNING: May not work correctly when embedded in a {Wx::Notebook}.
+  # - <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
   # 
@@ -63,7 +66,7 @@ module Wx
   # === 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). 
   # 
   # === 
@@ -76,7 +79,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor - you MUST call {Wx::MediaCtrl#create} before calling any other methods of {Wx::MediaCtrl}.
-    #   @return [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"))
     #   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.
@@ -89,7 +92,7 @@ module Wx
     #   @param szBackend [String]  Name of backend you want to use, leave blank to make {Wx::MediaCtrl} figure it out.
     #   @param validator [Wx::Validator]  validator to use.
     #   @param name [String]  Window name.
-    #   @return [MediaCtrl]
+    #   @return [Wx::MediaCtrl]
     def initialize(*args) end
     
     # Creates this control.

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

@@ -84,11 +84,17 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::MediaEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_media_loaded}(id, meth = nil, &block): Sent when a media has loaded enough data that it can start playing. Processes a {Wx::EVT_MEDIA_LOADED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_media_stop}(id, meth = nil, &block): Sent when a media has switched to the {Wx::MediaState::MEDIASTATE_STOPPED} state. You may be able to Veto this event to prevent it from stopping, causing it to continue playing - even if it has reached that end of the media (note that this may not have the desired effect - if you want to loop the media, for example, catch the EVT_MEDIA_FINISHED and play there instead). Processes a {Wx::EVT_MEDIA_STOP} event type. 
+  # 
   # - {Wx::EvtHandler#evt_media_finished}(id, meth = nil, &block): Sent when a media has finished playing in a {Wx::MediaCtrl}. Processes a {Wx::EVT_MEDIA_FINISHED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_media_statechanged}(id, meth = nil, &block): Sent when a media has switched its state (from any media state). Processes a {Wx::EVT_MEDIA_STATECHANGED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_media_play}(id, meth = nil, &block): Sent when a media has switched to the {Wx::MediaState::MEDIASTATE_PLAYING} state. Processes a {Wx::EVT_MEDIA_PLAY} event type. 
+  # 
   # - {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. 
   # 
   # === 
@@ -98,9 +104,9 @@ module Wx
   class MediaEvent < NotifyEvent
   
     # Default ctor.
-    # @param commandType [Integer] 
+    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param winid [Integer] 
-    # @return [MediaEvent]
+    # @return [Wx::MediaEvent]
     def initialize(commandType=Wx::EVT_NULL, winid=0) end
     
   end # MediaEvent

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

@@ -25,38 +25,34 @@ module Wx
   # 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);
-  #   
-  #   // 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);
+  # ```ruby
+  #   Wx::MemoryDC.draw_on(test_bitmap) do |mem_dc|
+  #     # We can now draw into the memory DC...
+  #     
+  #     # Copy from this DC to another DC.
+  #     old_dc.blit(250, 50, BITMAP_WIDTH, BITMAP_HEIGHT, mem_dc, 0, 0)
+  #   end
   # ```
   # 
   # 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:
+  # And, before performing any other operations on the bitmap data, the bitmap must be selected out of the memory DC. Note that when using the `.draw_on` method this will happen automatically when the block returns.
   # 
-  # ```
-  #   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;
-  #       bmp.CreateWithDIPSize(GetClientSize(), GetDPIScaleFactor());
-  #       {
-  #           wxMemoryDC memdc(bmp);
-  #           ... use memdc to draw on the bitmap ...
-  #       }
-  #   
-  #       wxPaintDC dc(this);
-  #       dc.DrawBitmap(bmp, wxPoint(0, 0));
-  #   }
+  # ```ruby
+  #   class MyWindow
+  # 
+  #     def on_paint(_)
+  #       bmp = Wx::Bitmap.new
+  #       bmp.create_with_dip_size(get_client_size, get_dpi_scale_factor)
+  #       Wx::MemoryDC.draw_on(bmp) do |mem_dc|  
+  #         ... use mem_dc to draw on the bitmap ...
+  #       end
+  #       self.paint do |dc|
+  #         dc.draw_bitmap(bmp, Wx::Point.new(0, 0))
+  #       end
+  #     end
+  # 
+  #   end
   # ```
   # 
   # ===