wxruby3 0.9.2-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

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

@@ -7,6 +7,7 @@
 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).
@@ -15,7 +16,7 @@ module Wx
   # <b>Remark:</b>
   # <p>
   # </p>
-  # </div>>
+  # </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
@@ -36,17 +37,19 @@ module Wx
   
     # @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::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.
     #   
     #   <div class="wxrb-remark">
     #   <b>Remark:</b>
     #   <p>
     #   </p>
-    #   </div>>
+    #   </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
@@ -62,6 +65,7 @@ module Wx
     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]
@@ -69,11 +73,13 @@ module Wx
     
     # 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 
@@ -81,6 +87,7 @@ module Wx
     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 
@@ -88,6 +95,7 @@ module Wx
     def cascade; end
     
     # Used in two-step frame construction.
+    # 
     # See {Wx::MDIParentFrame#initialize} for further details.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -100,6 +108,7 @@ module Wx
     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
@@ -107,12 +116,14 @@ module Wx
     
     # 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.
@@ -121,6 +132,7 @@ module Wx
     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:
     # 
     # ```ruby
@@ -132,7 +144,7 @@ module Wx
     # <b>Remark:</b>
     # <p>
     # </p>
-    # </div>>
+    # </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.
@@ -142,6 +154,7 @@ module Wx
     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):
@@ -160,12 +173,14 @@ module Wx
     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 [Wx::Orientation] 
     # @return [void]
     def tile(orient=Wx::Orientation::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 [Boolean]
@@ -174,6 +189,7 @@ 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
   # 
   # This class supports the following styles:
@@ -183,7 +199,7 @@ module Wx
   # <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>>
+  # </div>
   # 
   # Category:  Managed Windows
   # @see Wx::MDIClientWindow
@@ -200,6 +216,7 @@ module Wx
     # @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.
@@ -213,12 +230,14 @@ module Wx
     
     # 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#initialize} for further details.
     # @param parent [Wx::MDIParentFrame] 
     # @param id [Integer] 
@@ -231,12 +250,14 @@ module Wx
     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 [Boolean]
@@ -244,6 +265,7 @@ module Wx
     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 
@@ -252,6 +274,7 @@ module Wx
     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 

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

@@ -7,6 +7,7 @@
 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
@@ -81,6 +82,7 @@ module Wx
     #   @return [Wx::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.
     #   @param id [Integer]  id to use for events
@@ -95,6 +97,7 @@ module Wx
     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.
@@ -110,12 +113,14 @@ module Wx
     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.
     # @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]
@@ -123,6 +128,7 @@ module Wx
     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. 
     # 
@@ -136,6 +142,7 @@ module Wx
     alias_method :state, :get_state
     
     # Gets the volume of the media from a 0.0 to 1.0 range.
+    # 
     # <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}. 
@@ -151,16 +158,19 @@ module Wx
     
     # @overload load(fileName)
     #   Loads the file that fileName refers to.
+    #   
     #   Returns false if loading fails.
     #   @param fileName [String] 
     #   @return [Boolean]
     # @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 [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 [URI] 
     #   @param proxy [URI] 
@@ -168,12 +178,14 @@ module Wx
     def load(*args) end
     
     # Same as Load(const wxURI& uri).
+    # 
     # Kept for {Wx::Python} compatibility.
     # @param uri [String] 
     # @return [Boolean]
     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] 
@@ -189,6 +201,7 @@ module Wx
     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 [Integer] 
     # @param mode [Wx::SeekMode] 
@@ -196,6 +209,7 @@ module Wx
     def seek(where, mode=Wx::SeekMode::FromStart) 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 [Boolean]
@@ -203,6 +217,7 @@ module Wx
     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.
     # 
     # <div class="wxrb-note">
@@ -216,6 +231,7 @@ module Wx
     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.
@@ -224,6 +240,7 @@ module Wx
     def show_player_controls(flags=Wx::MediaCtrlPlayerControls::MEDIACTRLPLAYERCONTROLS_DEFAULT) end
     
     # Stops the media.
+    # 
     # See {Wx::Operation} for an overview of how stopping works.
     # @return [Boolean]
     def stop; end

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

@@ -82,6 +82,7 @@ module Wx
   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.
@@ -105,7 +106,7 @@ module Wx
   class MediaEvent < NotifyEvent
   
     # Default ctor.
-    # @param commandType [Wx::Slider::EventType] 
+    # @param commandType [Wx::StaticLine::EventType] 
     # @param winid [Integer] 
     # @return [Wx::MediaEvent]
     def initialize(commandType=Wx::EVT_NULL, winid=0) end

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

@@ -16,12 +16,14 @@ module Wx
   BUFFER_USES_SHARED_BUFFER = 4
   
   # Check if the window is natively double buffered and will return a {Wx::PaintDC} if it is, a {Wx::BufferedPaintDC} otherwise.
+  # 
   # It is the caller's responsibility to delete the {Wx::DC} pointer when finished with it.
   # @param window [Wx::Window] 
   # @return [Wx::DC]
   def self.auto_buffered_paint_dc_factory(window) end
   
   # A memory device context provides a means to draw graphics onto a bitmap.
+  # 
   # When drawing in to a mono-bitmap, using {Wx::WHITE}, {Wx::WHITE_PEN} and {Wx::WHITE_BRUSH} will draw the background colour (i.e. 0) whereas all other colours will draw the foreground colour (i.e. 1).
   # A bitmap must be selected into the new memory DC before it may be used for anything. Typical usage is as follows:
   # 
@@ -65,6 +67,7 @@ module Wx
   class MemoryDC < DC
   
     # 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.
@@ -73,6 +76,7 @@ module Wx
     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.
     # 
     # <div class="wxrb-note">
@@ -94,6 +98,7 @@ module Wx
   end # MemoryDC
   
   # This class provides a simple way to avoid flicker: when drawing on it, everything is in fact first drawn on an in-memory buffer (a {Wx::Bitmap}) and then copied to the screen, using the associated {Wx::DC}, only once, when this object is destroyed.
+  # 
   # {Wx::BufferedDC} itself is typically associated with {Wx::ClientDC}, if you want to use it in your EVT_PAINT handler, you should look at {Wx::BufferedPaintDC} instead.
   # When used like this, a valid DC must be specified in the constructor while the buffer bitmap doesn't have to be explicitly provided, by default this class will allocate the bitmap of required size itself. However using a dedicated bitmap can speed up the redrawing process by eliminating the repeated creation and destruction of a possibly big bitmap. Otherwise, {Wx::BufferedDC} can be used in the same way as any other device context.
   # Another possible use for {Wx::BufferedDC} is to use it to maintain a backing store for the window contents. In this case, the associated DC may be NULL but a valid backing store bitmap should be specified.
@@ -110,6 +115,7 @@ module Wx
   
     # @overload init(dc, area, style=Wx::BUFFER_CLIENT_AREA)
     #   Initializes the object created using the default constructor.
+    #   
     #   Please see the constructors for parameter details.
     #   @param dc [Wx::DC] 
     #   @param area [Array(Integer, Integer), Wx::Size] 
@@ -117,6 +123,7 @@ module Wx
     #   @return [void]
     # @overload init(dc, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
     #   Initializes the object created using the default constructor.
+    #   
     #   Please see the constructors for parameter details.
     #   @param dc [Wx::DC] 
     #   @param buffer [Wx::Bitmap] 
@@ -125,6 +132,7 @@ module Wx
     def init(*args) end
     
     # Blits the buffer to the dc, and detaches the dc from the buffer (so it can be effectively used once only).
+    # 
     # Usually only called in the destructor or by the destructor of derived classes if the BufferedDC must blit before the derived class (which may own the dc it's blitting to) is destroyed.
     # @return [void]
     def un_mask; end
@@ -143,6 +151,7 @@ module Wx
   end # BufferedDC
   
   # This is a subclass of {Wx::BufferedDC} which can be used inside of an <code>EVT_PAINT()</code> event handler to achieve double-buffered drawing.
+  # 
   # Just use this class instead of {Wx::PaintDC} and make sure {Wx::Window#set_background_style} is called with {Wx::BackgroundStyle::BG_STYLE_PAINT} somewhere in the class initialization code, and that's all you have to do to (mostly) avoid flicker. The only thing to watch out for is that if you are using this class together with {Wx::Scrolled}, you probably do <b>not</b> want to call Wx::Scrolled#prepare_dc on it as it already does this internally for the real underlying {Wx::PaintDC}.
   # 
   # Category:  Device Contexts
@@ -157,6 +166,7 @@ module Wx
   end # BufferedPaintDC
   
   # This {Wx::DC} derivative can be used inside of an <code>EVT_PAINT()</code> event handler to achieve double-buffered drawing.
+  # 
   # Just use this class instead of {Wx::PaintDC} and make sure {Wx::Window#set_background_style} is called with {Wx::BackgroundStyle::BG_STYLE_PAINT} somewhere in the class initialization code, and that's all you have to do to (mostly) avoid flicker.
   # The difference between {Wx::BufferedPaintDC} and this class is that this class won't double-buffer on platforms which have native double-buffering already, avoiding any unnecessary buffering to avoid flicker.
   # {Wx::AutoBufferedPaintDC} is simply a typedef of {Wx::PaintDC} on platforms that have native double-buffering, otherwise, it is a typedef of {Wx::BufferedPaintDC}.