wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

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

@@ -0,0 +1,235 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # An MDI (Multiple Document Interface) parent frame is a window which can contain MDI child frames in its client area which emulates the full desktop.
+  # MDI is a user-interface model in which all the window reside inside the single parent window as opposed to being separate from each other. It remains popular despite dire warnings from Microsoft itself (which popularized this model in the first model) that MDI is obsolete.
+  # 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).
+  # 
+  # 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
+  # 
+  # 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
+  # @see  Wx::Frame
+  # @see  Wx::Dialog 
+  # 
+  # 
+  class MDIParentFrame < Frame
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   Use {Wx::MDIParentFrame#create} for the objects created using this constructor.
+    #   @return [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::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 {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.
+    #   @see Wx::MDIParentFrame#create
+    #   @see  Wx::MDIParentFrame#on_create_client 
+    #   @param parent [Wx::Window]  The window parent. Usually is NULL.
+    #   @param id [Integer]  The window identifier. It may take a value of {Wx::StandardID::ID_ANY} to indicate a default value.
+    #   @param title [String]  The caption to be displayed on the frame's title bar.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The window position. The value {Wx::DEFAULT_POSITION} indicates a default position, chosen by either the windowing system or wxWidgets, depending on platform.
+    #   @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]
+    def initialize(*args) end
+    
+    # Activates the MDI child following the currently active one.
+    # The MDI children are maintained in an ordered list and this function switches to the next element in this list, wrapping around the end of it if the currently active child is the last one.
+    # @see Wx::MDIParentFrame#activate_previous 
+    # @return [void]
+    def activate_next; end
+    
+    # Activates the MDI child preceding the currently active one.
+    # 
+    # @see Wx::MDIParentFrame#activate_next 
+    # @return [void]
+    def activate_previous; end
+    
+    # Arranges any iconized (minimized) MDI child windows.
+    # This method is only implemented in MSW MDI implementation and does nothing under the other platforms.
+    # @see Wx::MDIParentFrame#cascade
+    # @see  Wx::MDIParentFrame#tile 
+    # @return [void]
+    def arrange_icons; end
+    
+    # Arranges the MDI child windows in a cascade.
+    # This method is only implemented in MSW MDI implementation and does nothing under the other platforms.
+    # @see Wx::MDIParentFrame#tile
+    # @see  Wx::MDIParentFrame#arrange_icons 
+    # @return [void]
+    def cascade; end
+    
+    # Used in two-step frame construction.
+    # See {Wx::MDIParentFrame#mdi_parent_frame} for further details.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param title [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    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.
+    # @return [Wx::MDIChildFrame]
+    def get_active_child; end
+    alias_method :active_child, :get_active_child
+    
+    # Returns a pointer to the client window.
+    # 
+    # @see Wx::MDIParentFrame#on_create_client 
+    # @return [wxMDIClientWindow *]
+    def get_client_window; end
+    alias_method :client_window, :get_client_window
+    
+    # Returns the current MDI Window menu.
+    # Unless {Wx::FRAME_NO_WINDOW_MENU} style was used, a default menu listing all the currently active children and providing the usual operations (tile, cascade, ...) on them is created automatically by the library and this function can be used to retrieve it. Notice that the default menu can be replaced by calling {Wx::MDIParentFrame#set_window_menu}.
+    # This function is currently not available under macOS.
+    # The current Window menu or NULL.
+    # @return [Wx::Menu]
+    def get_window_menu; end
+    alias_method :window_menu, :get_window_menu
+    
+    # Override this to return a different kind of client window.
+    # If you override this function, you must create your parent frame in two stages, or your function will never be called, due to the way C++ treats virtual functions called from constructors. For example:
+    # 
+    #   frame = new MyParentFrame;
+    #   frame->Create(parent, myParentFrameId, "My Parent Frame");
+    # 
+    # You might wish to derive from {Wx::MDIClientWindow} in order to implement different erase behaviour, for example, such as painting a bitmap on the background.
+    # Note that it is probably impossible to have a client window that scrolls as well as painting a bitmap or pattern, since in <b>OnScroll</b>, the scrollbar positions always return zero.
+    # @see Wx::MDIParentFrame#get_client_window
+    # @see  Wx::MDIClientWindow 
+    # @return [Wx::MDIClientWindow]
+    def on_create_client; end
+    
+    # Replace the current MDI Window menu.
+    # 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.
+    # 
+    # 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.
+    # @return [void]
+    def set_window_menu(menu) end
+    alias_method :window_menu=, :set_window_menu
+    
+    # Tiles the MDI child windows either horizontally or vertically depending on whether orient is {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL}.
+    # This method is only implemented in MSW MDI implementation and does nothing under the other platforms.
+    # @param orient [Orientation] 
+    # @return [void]
+    def tile(orient=Wx::HORIZONTAL) end
+    
+    # Returns whether the MDI implementation is tab-based.
+    # Currently only the MSW port uses the real MDI. In Mac ports the usual SDI is used, as common under this platforms, and all the other ports use TDI implementation.
+    # TDI-based MDI applications have different appearance and functionality (e.g. child frames can't be minimized and only one of them is visible at any given time) so the application may need to adapt its interface somewhat depending on the return value of this function.
+    # @return [true,false]
+    def self.is_tdi; end
+    
+  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
+  # 
+  # 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.
+  # 
+  # === 
+  # 
+  # Category:  Managed Windows
+  # @see Wx::MDIClientWindow
+  # @see  Wx::MDIParentFrame
+  # @see  Wx::Frame 
+  # 
+  # 
+  class MDIChildFrame < Frame
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [MDIChildFrame]
+    # @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 
+    #   @param parent [Wx::MDIParentFrame]  The window parent. This should not be NULL.
+    #   @param id [Integer]  The window identifier. It may take a value of -1 to indicate a default value.
+    #   @param title [String]  The caption to be displayed on the frame's title bar.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The window position. The value {Wx::DEFAULT_POSITION} indicates a default position, chosen by either the windowing system or wxWidgets, depending on platform.
+    #   @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]
+    def initialize(*args) end
+    
+    # Activates this MDI child frame.
+    # 
+    # @see Wx::MDIChildFrame#maximize
+    # @see  Wx::MDIChildFrame#restore 
+    # @return [void]
+    def activate; end
+    
+    # Used in two-step frame construction.
+    # See {Wx::MDIChildFrame#mdi_child_frame} for further details.
+    # @param parent [Wx::MDIParentFrame] 
+    # @param id [Integer] 
+    # @param title [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    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.
+    # @return [Wx::MDIParentFrame]
+    def get_mdi_parent; end
+    alias_method :mdi_parent, :get_mdi_parent
+    
+    # Returns true for MDI children in TDI implementations.
+    # TDI-based implementations represent MDI children as pages in a {Wx::Notebook} and so they are always maximized and can't be restored or iconized.
+    # @see Wx::MDIParentFrame.is_tdi. 
+    # @return [true,false]
+    def is_always_maximized; end
+    alias_method :always_maximized?, :is_always_maximized
+    
+    # Maximizes this MDI child frame.
+    # This function doesn't do anything if {Wx::MDIChildFrame#is_always_maximized} returns true.
+    # @see Wx::MDIChildFrame#activate
+    # @see  Wx::MDIChildFrame#restore 
+    # @param maximize [true,false] 
+    # @return [void]
+    def maximize(maximize=true) end
+    
+    # Restores this MDI child frame (unmaximizes).
+    # This function doesn't do anything if {Wx::MDIChildFrame#is_always_maximized} returns true.
+    # @see Wx::MDIChildFrame#activate
+    # @see  Wx::MDIChildFrame#maximize 
+    # @return [void]
+    def restore; end
+    
+  end # MDIChildFrame
+  
+
+end

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

@@ -0,0 +1,225 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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
+  # 
+  # 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
+  # 
+  # When {Wx::MediaCtrl} plays a file, it plays until the stop position is reached (currently the end of the file/stream). Right before it hits the end of the stream, it fires off a EVT_MEDIA_STOP event to its parent window, at which point the event handler can choose to veto the event, preventing the stream from actually stopping.
+  # Example:
+  # 
+  #   // bind the media event
+  #   Bind(wxMY_ID, wxEVT_MEDIA_STOP, &MyFrame::OnMediaStop, this);
+  #   
+  #   //...
+  #   void MyFrame::OnMediaStop(wxMediaEvent& evt)
+  #   {
+  #       if( userWantsToSeek )
+  #       {
+  #           m_mediactrl->Seek(m_mediactrl->Length() - 1);
+  #           evt.Veto();
+  #       }
+  #   }
+  # 
+  # When {Wx::MediaCtrl} stops, either by the EVT_MEDIA_STOP not being vetoed, or by manually calling {Wx::MediaCtrl#stop}, where it actually stops is not at the beginning, rather, but at the beginning of the stream. That is, when it stops and play is called, playback is guaranteed to start at the beginning of the media. This is because some streams are not seekable, and when stop is called on them they return to the beginning, thus {Wx::MediaCtrl} tries to keep consistent for all types of media.
+  # Note that when changing the state of the media through {Wx::MediaCtrl#play} and other methods, the media may not actually be in the {Wx::MediaState::MEDIASTATE_PLAYING}, for example. If you are relying on the media being in certain state, catch the event relevant to the state. See {Wx::MediaEvent} for the kinds of events that you can catch.
+  # 
+  # == 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
+  # 
+  # 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
+  # 
+  # 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.
+  # 
+  # == 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
+  # 
+  # 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 
+  # 
+  # 
+  class MediaCtrl < Control
+  
+    # @overload initialize()
+    #   Default constructor - you MUST call {Wx::MediaCtrl#create} before calling any other methods of {Wx::MediaCtrl}.
+    #   @return [MediaCtrl]
+    # @overload initialize(parent, id, fileName=Wx::EMPTY_STRING, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=Wx::EMPTY_STRING, validator=Wx::DEFAULT_VALIDATOR, name=("Wx::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.
+    #   @param id [Integer]  id to use for events
+    #   @param fileName [String]  If not empty, the path of a file to open.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  Position to put control at.
+    #   @param size [Array(Integer, Integer), Wx::Size]  Size to put the control at and to stretch movie to.
+    #   @param style [Integer]  Optional styles. It is recommended to use {Wx::MC_NO_AUTORESIZE}, although it is not used by default for compatibility reasons.
+    #   @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]
+    def initialize(*args) end
+    
+    # Creates this control.
+    # Returns false if it can't load the media located at fileName or it can't create a backend.
+    # If you specify a file to open via fileName and you don't specify a backend to use, {Wx::MediaCtrl} tries each of its backends until one that can render the path referred to by fileName can be found.
+    # @param parent [Wx::Window]  parent of this control. Must not be NULL.
+    # @param id [Integer]  id to use for events
+    # @param fileName [String]  If not empty, the path of a file to open.
+    # @param pos [Array(Integer, Integer), Wx::Point]  Position to put control at.
+    # @param size [Array(Integer, Integer), Wx::Size]  Size to put the control at and to stretch movie to.
+    # @param style [Integer]  Optional styles. It is recommended to use {Wx::MC_NO_AUTORESIZE}, although it is not used by default for compatibility reasons.
+    # @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 [true,false]
+    def create(parent, id, fileName=Wx::EMPTY_STRING, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, szBackend=Wx::EMPTY_STRING, validator=Wx::DEFAULT_VALIDATOR, name=("Wx::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.
+    # @return [Wx::Size]
+    def get_best_size; end
+    alias_method :best_size, :get_best_size
+    
+    # Obtains the playback rate, or speed of the media.
+    # 1.0 represents normal speed, while 2.0 represents twice the normal speed of the media, for example. Not supported on the GStreamer (Unix) backend.
+    # zero on failure.
+    # @return [Float]
+    def get_playback_rate; end
+    alias_method :playback_rate, :get_playback_rate
+    
+    # Obtains the state the playback of the media is in.
+    # {Wx::MediaState::MEDIASTATE_STOPPED} 
+    # The media has stopped. 
+    # 
+    # {Wx::MediaState::MEDIASTATE_PAUSED} 
+    # The media is paused. 
+    # 
+    # {Wx::MediaState::MEDIASTATE_PLAYING} 
+    # The media is currently playing.
+    # @return [MediaState]
+    def get_state; end
+    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}.
+    # @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]
+    def length; end
+    
+    # @overload load(fileName)
+    #   Loads the file that fileName refers to.
+    #   Returns false if loading fails.
+    #   @param fileName [String] 
+    #   @return [true,false]
+    # @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] 
+    #   @return [true,false]
+    # @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] 
+    #   @return [true,false]
+    def load(*args) end
+    
+    # Same as Load(const wxURI& uri).
+    # Kept for {Wx::Python} compatibility.
+    # @param uri [String] 
+    # @return [true,false]
+    def load_uri(uri) end
+    
+    # Same as Load(const wxURI& uri, const wxURI& proxy).
+    # Kept for {Wx::Python} compatibility.
+    # @param uri [String] 
+    # @param proxy [String] 
+    # @return [true,false]
+    def load_uri_with_proxy(uri, proxy) end
+    
+    # Pauses playback of the media.
+    # @return [true,false]
+    def pause; end
+    
+    # Resumes playback of the media.
+    # @return [true,false]
+    def play; end
+    
+    # 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 mode [Wx::SeekMode] 
+    # @return [Wx::FileOffset]
+    def seek(where, mode=Wx::FROM_START) end
+    
+    # Sets the playback rate, or speed of the media, to that referred by dRate.
+    # 1.0 represents normal speed, while 2.0 represents twice the normal speed of the media, for example. Not supported on the GStreamer (Unix) backend. Returns true if successful.
+    # @param dRate [Float] 
+    # @return [true,false]
+    def set_playback_rate(dRate) end
+    alias_method :playback_rate=, :set_playback_rate
+    
+    # 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.
+    # @param dVolume [Float] 
+    # @return [true,false]
+    def set_volume(dVolume) end
+    alias_method :volume=, :set_volume
+    
+    # A special feature to {Wx::MediaCtrl}.
+    # Applications using native toolkits such as QuickTime usually have a scrollbar, play button, and more provided to them by the toolkit. By default {Wx::MediaCtrl} does not do this. However, on the DirectShow and QuickTime backends you can show or hide the native controls provided by the underlying toolkit at will using {Wx::MediaCtrl#show_player_controls}. Simply calling the function with default parameters tells {Wx::MediaCtrl} to use the default controls provided by the toolkit. The function takes a {Wx::MediaCtrlPlayerControls} enumeration, please see available show modes there.
+    # For more info see Player controls.
+    # Currently only implemented on the QuickTime and DirectShow backends. The function returns true on success.
+    # @param flags [MediaCtrlPlayerControls] 
+    # @return [true,false]
+    def show_player_controls(flags=Wx::MEDIACTRLPLAYERCONTROLS_DEFAULT) end
+    
+    # Stops the media.
+    # See {Wx::Operation} for an overview of how stopping works.
+    # @return [true,false]
+    def stop; end
+    
+    # Obtains the current position in time within the media in milliseconds.
+    # @return [Wx::FileOffset]
+    def tell; end
+    
+  end # MediaCtrl
+  
+
+end

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

@@ -0,0 +1,109 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  MC_NO_AUTORESIZE = 1
+  
+  # Describes the current state of the media.
+  # 
+  # 
+  # @see Wx::MediaCtrl#get_state 
+  # 
+  # 
+  class MediaState < Wx::Enum
+  
+    # No media is being currently played.
+    # 
+    MEDIASTATE_STOPPED = Wx::MediaState.new(0)
+    
+    # Current media is paused.
+    # 
+    MEDIASTATE_PAUSED = Wx::MediaState.new(1)
+    
+    # There is media currently playing.
+    # 
+    MEDIASTATE_PLAYING = Wx::MediaState.new(2)
+    
+  end # MediaState
+  
+  # 
+  # 
+  # 
+  # 
+  class MediaCtrlPlayerControls < Wx::Enum
+  
+    # No controls.
+    # 
+    MEDIACTRLPLAYERCONTROLS_NONE = Wx::MediaCtrlPlayerControls.new(0)
+    
+    # Step controls like fastforward, step one frame etc.
+    # 
+    MEDIACTRLPLAYERCONTROLS_STEP = Wx::MediaCtrlPlayerControls.new(1)
+    
+    # Volume controls like the speaker icon, volume slider, etc.
+    # 
+    MEDIACTRLPLAYERCONTROLS_VOLUME = Wx::MediaCtrlPlayerControls.new(2)
+    
+    # Default controls for the toolkit.
+    # 
+    MEDIACTRLPLAYERCONTROLS_DEFAULT = Wx::MediaCtrlPlayerControls.new(3)
+    
+  end # MediaCtrlPlayerControls
+  
+  # 
+  # 
+  EVT_MEDIA_LOADED = 10329
+  
+  # 
+  # 
+  EVT_MEDIA_STOP = 10330
+  
+  # 
+  # 
+  EVT_MEDIA_FINISHED = 10328
+  
+  # 
+  # 
+  EVT_MEDIA_STATECHANGED = 10325
+  
+  # 
+  # 
+  EVT_MEDIA_PLAY = 10326
+  
+  # 
+  # 
+  EVT_MEDIA_PAUSE = 10327
+  
+  # Event {Wx::MediaCtrl} uses.
+  # === 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:
+  # - {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. 
+  # 
+  # === 
+  # 
+  # Category:  {Wx::Events}
+  # 
+  class MediaEvent < NotifyEvent
+  
+    # Default ctor.
+    # @param commandType [Integer] 
+    # @param winid [Integer] 
+    # @return [MediaEvent]
+    def initialize(commandType=Wx::EVT_NULL, winid=0) end
+    
+  end # MediaEvent
+  
+
+end

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

@@ -0,0 +1,95 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A memory device context provides a means to draw graphics onto a bitmap.
+  # When drawing in to a mono-bitmap, using {Wx::WHITE}, {Wx::WHITE_PEN} and {Wx::WHITE_BRUSH} will draw the background colour (i.e. 0) whereas all other colours will draw the foreground colour (i.e. 1).
+  # A bitmap must be selected into the new memory DC before it may be used for anything. Typical usage is as follows:
+  # 
+  #   // Create a memory DC
+  #   wxMemoryDC temp_dc;
+  #   temp_dc.SelectObject(test_bitmap);
+  #   
+  #   // We can now draw into the memory DC...
+  #   // Copy from this DC to another DC.
+  #   old_dc.Blit(250, 50, BITMAP_WIDTH, BITMAP_HEIGHT, temp_dc, 0, 0);
+  # 
+  # Note that the memory DC must be deleted (or the bitmap selected out of it) before a bitmap can be reselected into another memory DC.
+  # And, before performing any other operations on the bitmap data, the bitmap must be selected out of the memory DC:
+  # 
+  #   temp_dc.SelectObject(wxNullBitmap);
+  # 
+  # This happens automatically when {Wx::MemoryDC} object goes out of scope.
+  # Note that the scaling factor of the bitmap determines the scaling factor used by this device context, so when using a memory device context as a back buffer for a window, you should typically create the bitmap using the same scale factor as used by the window, e.g. 
+  # 
+  #   void MyWindow::OnPaint(wxPaintEvent&)
+  #   {
+  #       wxBitmap bmp;
+  #       bmp.CreateWithDIPSize(GetClientSize(), GetDPIScaleFactor());
+  #       {
+  #           wxMemoryDC memdc(bmp);
+  #           ... use memdc to draw on the bitmap ...
+  #       }
+  #   
+  #       wxPaintDC dc(this);
+  #       dc.DrawBitmap(bmp, wxPoint(0, 0));
+  #   }
+  # 
+  # === 
+  # 
+  # Category:  Device Contexts
+  # @see Wx::Bitmap
+  # @see  Wx::DC 
+  # 
+  # 
+  class MemoryDC < DC
+  
+    # @overload initialize()
+    #   Constructs a new memory device context.
+    #   Use the {Wx::DC#is_ok} member to test whether the constructor was successful in creating a usable device context. Don't forget to select a bitmap into the DC before drawing on it.
+    #   @return [MemoryDC]
+    # @overload initialize(dc)
+    #   Constructs a new memory device context having the same characteristics as the given existing device context.
+    #   This constructor creates a memory device context compatible with dc in {Wx::MSW}, the argument is ignored in the other ports. If dc is NULL, a device context compatible with the screen is created, just as with the default constructor.
+    #   @param dc [Wx::DC] 
+    #   @return [MemoryDC]
+    # @overload initialize(bitmap)
+    #   Constructs a new memory device context and calls {Wx::MemoryDC#select_object} with the given bitmap.
+    #   Use the {Wx::DC#is_ok} member to test whether the constructor was successful in creating a usable device context.
+    #   @param bitmap [Wx::Bitmap] 
+    #   @return [MemoryDC]
+    def initialize(*args) end
+    
+    # Allow using this device context object to modify the given bitmap contents.
+    # Note that if you need to only use the existing bitmap contents instead of modifying it, you should use {Wx::MemoryDC#select_object_as_source} instead.
+    # Before using the updated bitmap data, make sure to select it out of context first either by selecting {Wx::NULL_BITMAP} into the device context or destroying the device context entirely.
+    # If the bitmap is already selected in this device context, nothing is done. If it is selected in another context, the function asserts and drawing on the bitmap won't work correctly.
+    # @param bitmap [Wx::Bitmap] 
+    # @return [void]
+    def select_object(bitmap) end
+    
+    # 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).
+    # 
+    # 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] 
+    # @return [void]
+    def select_object_as_source(bitmap) end
+    
+    # @overload get_selected_bitmap()
+    #   Get the selected bitmap.
+    #   @return [void]
+    # @overload get_selected_bitmap()
+    #   @return [Wx::Bitmap]
+    def get_selected_bitmap(*args) end
+    alias_method :selected_bitmap, :get_selected_bitmap
+    
+  end # MemoryDC
+  
+
+end