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

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

@@ -67,6 +67,7 @@ module Wx
   NULL_ANIMATION = nil
   
   # The {Wx::Animation} class handles the interface between the animation control and the details of the animation image or data.
+  # 
   # Predefined objects/pointers: {Wx::NULL_ANIMATION}
   # @see Wx::AnimationCtrl
   # @see  Animation Sample 
@@ -77,12 +78,14 @@ module Wx
   
     # @overload initialize()
     #   Constructs a new empty animation object.
+    #   
     #   Call {Wx::Animation#load} to initialize it.
     #   @see Wx::AnimationCtrl#create_animation 
     #   @return [Wx::Animation]
     # @overload initialize(name, type=Wx::AnimationType::ANIMATION_TYPE_ANY)
     #   Constructs a new animation object and load the animation data from the given filename.
     #   
+    #   
     #   @see Wx::AnimationCtrl#create_animation 
     #   @param name [String]  A filename.
     #   @param type [Wx::AnimationType]  One of the {Wx::AnimationType} values; {Wx::AnimationType::ANIMATION_TYPE_ANY} means that the function should try to autodetect the filetype.
@@ -99,6 +102,7 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Returns the delay for the i-th frame in milliseconds.
+    # 
     # If <code>-1</code> is returned the frame is to be displayed forever.
     # @param frame [Integer] 
     # @return [Integer]
@@ -106,12 +110,14 @@ module Wx
     alias_method :delay, :get_delay
     
     # Returns the number of frames for this animation.
+    # 
     # This method is not implemented in the native WXGTK implementation of this class and always returns 0 there.
     # @return [Integer]
     def get_frame_count; end
     alias_method :frame_count, :get_frame_count
     
     # Returns the i-th frame as a {Wx::Image}.
+    # 
     # This method is not implemented in the native WXGTK implementation of this class and always returns an invalid image there.
     # @param frame [Integer] 
     # @return [Wx::Image]
@@ -124,6 +130,7 @@ module Wx
     alias_method :size, :get_size
     
     # Loads an animation from a file.
+    # 
     # true if the operation succeeded, false otherwise.
     # @param name [String]  A filename.
     # @param type [Wx::AnimationType]  One of the {Wx::AnimationType} values; {Wx::AnimationType::ANIMATION_TYPE_ANY} means that the function should try to autodetect the filetype.
@@ -131,6 +138,7 @@ module Wx
     def load_file(name, type=Wx::AnimationType::ANIMATION_TYPE_ANY) end
     
     # Loads an animation from the given stream.
+    # 
     # true if the operation succeeded, false otherwise.
     # @param stream [IO,Wx::InputStream]  The stream to use to load the animation. Under WXGTK may be any kind of stream; under other platforms this must be a seekable stream.
     # @param type [Wx::AnimationType]  One of the {Wx::AnimationType} enumeration values.
@@ -157,11 +165,13 @@ module Wx
     def self.find_handler(animType) end
     
     # Load the stock animation decoders (currently GIF and ANI) into the list of decoders.
+    # 
     # This is called automatically at program startup.
     # @return [void]
     def self.init_standard_handlers; end
     
     # Clear out the animation decoder list.
+    # 
     # This is called automatically at program shutdown.
     # @return [void]
     def self.clean_up_handlers; end
@@ -171,6 +181,7 @@ module Wx
   # {Wx::AnimationDecoder} is used by {Wx::Animation} for loading frames and other information for the animation from the animation image file.
   # 
   # 
+  # 
   # @wxrb_require USE_ANIMATIONCTRL
   class AnimationDecoder < ::Object
   
@@ -219,6 +230,7 @@ module Wx
     alias_method :disposal_method, :get_disposal_method
     
     # Return the number of milliseconds this frame should be displayed.
+    # 
     # If -1 is returned then the frame must be displayed forever.
     # @param frame [Integer] 
     # @return [Integer]

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

@@ -7,6 +7,7 @@
 module Wx
 
   # This is a static control which displays an animation.
+  # 
   # {Wx::AnimationCtrl} API is as simple as possible and won't give you full control on the animation; if you need it then use {Wx::MediaCtrl}.
   # This control is useful to display a (small) animation while doing a long task (e.g. a "throbber").
   # It is only available if {Wx::Setup::USE_ANIMATIONCTRL} is set to 1 (the default).
@@ -44,6 +45,7 @@ module Wx
     def initialize(parent, id, anim=Wx::NULL_ANIMATION, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::AC_DEFAULT_STYLE, name=Wx::ANIMATION_CTRL_NAME_STR) end
     
     # Creates the control with the given anim animation.
+    # 
     # After control creation you must explicitly call {Wx::AnimationCtrl#play} to start to play the animation. Until that function won't be called, the first frame of the animation is displayed.
     # 
     # true if the control was successfully created or false if creation failed.
@@ -58,6 +60,7 @@ module Wx
     def create(parent, id, anim=Wx::NULL_ANIMATION, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::AC_DEFAULT_STYLE, name=Wx::ANIMATION_CTRL_NAME_STR) end
     
     # Create a new animation object compatible with this control.
+    # 
     # A {Wx::Animation} object created using this function is always compatible with controls of this type, see {Wx::Animation#is_compatible_with}.
     # @see Wx::AnimationCtrl.create_compatible_animation
     # @return [Wx::Animation]
@@ -79,6 +82,7 @@ module Wx
     alias_method :playing?, :is_playing
     
     # Loads the animation from the given file and calls {Wx::AnimationCtrl#set_animation}.
+    # 
     # See {Wx::Animation#load_file} for more info.
     # @param file [String] 
     # @param animType [Wx::AnimationType] 
@@ -86,6 +90,7 @@ module Wx
     def load_file(file, animType=Wx::AnimationType::ANIMATION_TYPE_ANY) end
     
     # Loads the animation from the given stream and calls {Wx::AnimationCtrl#set_animation}.
+    # 
     # See {Wx::Animation#load} for more info.
     # @param file [IO,Wx::InputStream] 
     # @param animType [Wx::AnimationType] 
@@ -93,11 +98,13 @@ module Wx
     def load(file, animType=Wx::AnimationType::ANIMATION_TYPE_ANY) end
     
     # Starts playing the animation.
+    # 
     # The animation is always played in loop mode (unless the last frame of the animation has an infinite delay time) and always start from the first frame even if you {Wx::stopped} it while some other frame was displayed.
     # @return [Boolean]
     def play; end
     
     # Sets the animation to play in this control.
+    # 
     # If the previous animation is being played, it's {Wx::AnimationCtrl#stop} stopped. Until {Wx::AnimationCtrl#play} isn't called, a static image, the first frame of the given animation or the background colour will be shown (see {Wx::AnimationCtrl#set_inactive_bitmap} for more info).
     # @param anim [Wx::Animation] 
     # @return [void]
@@ -105,6 +112,7 @@ module Wx
     alias_method :animation=, :set_animation
     
     # Sets the bitmap to show on the control when it's not playing an animation.
+    # 
     # If you set as inactive bitmap {Wx::NULL_BITMAP} (which is the default), then the first frame of the animation is instead shown when the control is inactive; in this case, if there's no valid animation associated with the control (see {Wx::AnimationCtrl#set_animation}), then the background colour of the window is shown.
     # If the control is not playing the animation, the given bitmap will be immediately shown, otherwise it will be shown as soon as {Wx::AnimationCtrl#stop} is called.
     # Note that the inactive bitmap, if smaller than the control's size, will be centered in the control; if bigger, it will be stretched to fit it.
@@ -114,11 +122,13 @@ module Wx
     alias_method :inactive_bitmap=, :set_inactive_bitmap
     
     # Stops playing the animation.
+    # 
     # The control will show the first frame of the animation, a custom static image or the window's background colour as specified by the last {Wx::AnimationCtrl#set_inactive_bitmap} call.
     # @return [void]
     def stop; end
     
     # Create a new animation object compatible with this control.
+    # 
     # This method does the same thing as {Wx::AnimationCtrl#create_animation} but is static, i.e. can be called without creating any {Wx::AnimationCtrl} objects.
     # @return [Wx::Animation]
     def self.create_compatible_animation; end

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

@@ -33,11 +33,13 @@ module Wx
   # A class for common button functionality used as the base for the various button classes.
   # 
   # 
+  # 
   # @wxrb_require USE_BUTTON|USE_TOGGLEBTN
   class AnyButton < Control
   
     # @overload set_bitmap_margins(x, y)
     #   Set the margins between the bitmap and the text of the button.
+    #   
     #   This method is currently only implemented under MSW. If it is not called, default margin is used around the bitmap.
     #   @see Wx::AnyButton#set_bitmap
     #   @see  Wx::AnyButton#set_bitmap_position
@@ -46,6 +48,7 @@ module Wx
     #   @return [void]
     # @overload set_bitmap_margins(sz)
     #   Set the margins between the bitmap and the text of the button.
+    #   
     #   This method is currently only implemented under MSW. If it is not called, default margin is used around the bitmap.
     #   @see Wx::AnyButton#set_bitmap
     #   @see  Wx::AnyButton#set_bitmap_position
@@ -58,6 +61,7 @@ module Wx
     def initialize; end
     
     # Return the bitmap shown by the button.
+    # 
     # The returned bitmap may be invalid only if the button doesn't show any images.
     # @see Wx::AnyButton#set_bitmap
     # @return [Wx::Bitmap]
@@ -65,24 +69,28 @@ module Wx
     alias_method :bitmap, :get_bitmap
     
     # Returns the bitmap used when the mouse is over the button.
+    # 
     # The returned bitmap is only valid if {Wx::AnyButton#set_bitmap_current} had been previously called.
     # @return [Wx::Bitmap]
     def get_bitmap_current; end
     alias_method :bitmap_current, :get_bitmap_current
     
     # Returns the bitmap used for the disabled state.
+    # 
     # The returned bitmap is only valid if {Wx::AnyButton#set_bitmap_disabled} had been previously called.
     # @return [Wx::Bitmap]
     def get_bitmap_disabled; end
     alias_method :bitmap_disabled, :get_bitmap_disabled
     
     # Returns the bitmap used for the focused state.
+    # 
     # The returned bitmap is only valid if {Wx::AnyButton#set_bitmap_focus} had been previously called.
     # @return [Wx::Bitmap]
     def get_bitmap_focus; end
     alias_method :bitmap_focus, :get_bitmap_focus
     
     # Returns the bitmap for the normal state.
+    # 
     # This is exactly the same as {Wx::AnyButton#get_bitmap} but uses a name backwards-compatible with {Wx::BitmapButton}.
     # @see Wx::AnyButton#set_bitmap
     # @see  Wx::AnyButton#set_bitmap_label
@@ -91,12 +99,14 @@ module Wx
     alias_method :bitmap_label, :get_bitmap_label
     
     # Returns the bitmap used when the button is pressed.
+    # 
     # The returned bitmap is only valid if {Wx::AnyButton#set_bitmap_pressed} had been previously called.
     # @return [Wx::Bitmap]
     def get_bitmap_pressed; end
     alias_method :bitmap_pressed, :get_bitmap_pressed
     
     # Sets the bitmap to display in the button.
+    # 
     # The bitmap is displayed together with the button label. This method sets up a single bitmap which is used in all button states, use {Wx::AnyButton#set_bitmap_disabled}, {Wx::AnyButton#set_bitmap_pressed}, {Wx::AnyButton#set_bitmap_current} or {Wx::AnyButton#set_bitmap_focus} to change the individual images used in different states.
     # @see Wx::AnyButton#set_bitmap_position
     # @see  Wx::AnyButton#set_bitmap_margins
@@ -107,6 +117,7 @@ module Wx
     alias_method :bitmap=, :set_bitmap
     
     # Sets the bitmap to be shown when the mouse is over the button.
+    # 
     # If bitmap is invalid, the normal bitmap will be used in the current state.
     # @see Wx::AnyButton#get_bitmap_current
     # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
@@ -115,6 +126,7 @@ module Wx
     alias_method :bitmap_current=, :set_bitmap_current
     
     # Sets the bitmap for the disabled button appearance.
+    # 
     # If bitmap is invalid, the disabled bitmap is set to the automatically generated greyed out version of the normal bitmap, i.e. the same bitmap as is used by default if this method is not called at all. Use {Wx::AnyButton#set_bitmap} with an invalid bitmap to remove the bitmap completely (for all states).
     # @see Wx::AnyButton#get_bitmap_disabled
     # @see  Wx::AnyButton#set_bitmap_label
@@ -126,6 +138,7 @@ module Wx
     alias_method :bitmap_disabled=, :set_bitmap_disabled
     
     # Sets the bitmap for the button appearance when it has the keyboard focus.
+    # 
     # If bitmap is invalid, the normal bitmap will be used in the focused state.
     # @see Wx::AnyButton#get_bitmap_focus
     # @see  Wx::AnyButton#set_bitmap_label
@@ -137,11 +150,12 @@ module Wx
     alias_method :bitmap_focus=, :set_bitmap_focus
     
     # Sets the bitmap label for the button.
+    # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>This is the bitmap used for the unselected state, and for all other states if no other bitmaps are provided.
     # </p>
-    # </div>>
+    # </div>
     # @see Wx::AnyButton#set_bitmap
     # @see  Wx::AnyButton#get_bitmap_label
     # @param bitmap [Wx::BitmapBundle,Wx::Bitmap,Wx::Icon,Wx::Image] 
@@ -157,12 +171,14 @@ module Wx
     
     # Get the margins between the bitmap and the text of the button.
     # 
+    # 
     # @see Wx::AnyButton#set_bitmap_margins
     # @return [Wx::Size]
     def get_bitmap_margins; end
     alias_method :bitmap_margins, :get_bitmap_margins
     
     # Set the position at which the bitmap is displayed.
+    # 
     # This method should only be called if the button does have an associated bitmap.
     # @param dir [Wx::Direction]  Direction in which the bitmap should be positioned, one of {Wx::Direction::LEFT}, {Wx::Direction::RIGHT}, {Wx::Direction::TOP} or {Wx::Direction::BOTTOM}.
     # @return [void]

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

@@ -7,6 +7,7 @@
 module Wx
 
   # The {Wx::App} class represents the application itself when <code>wxUSE_GUI=1</code>.
+  # 
   # In addition to the features provided by {Wx::AppConsole} it keeps track of the top window (see {Wx::App#set_top_window}) and adds support for video modes (see {Wx::App#set_display_mode}).
   # In general, application-wide settings for GUI-only apps are accessible from {Wx::App} (or from {Wx::SystemSettings} or {Wx::SystemOptions} classes).
   # ### Events emitted by this class
@@ -37,12 +38,14 @@ module Wx
   class App < EvtHandler
   
     # Constructor.
+    # 
     # Called implicitly with a definition of a {Wx::App} object.
     # @return [Wx::App]
     def initialize; end
     
     # Returns true if the application will exit when the top-level frame is deleted.
     # 
+    # 
     # @see Wx::App#set_exit_on_frame_delete 
     # @return [Boolean]
     def get_exit_on_frame_delete; end
@@ -55,29 +58,33 @@ module Wx
     
     # Returns true if the application will use the best visual on systems that support different visuals, false otherwise.
     # 
+    # 
     # @see Wx::App#set_use_best_visual 
     # @return [Boolean]
     def get_use_best_visual; end
     alias_method :use_best_visual, :get_use_best_visual
     
     # Returns a pointer to the top window.
+    # 
     # <div class="wxrb-remark">
     # <b>Remark:</b>
     # <p>If the top window hasn't been set using {Wx::App#set_top_window}, this function will find the first top-level window (frame or dialog or instance of {Wx::TopLevelWindow}) from the internal top level window list and return that.
     # </p>
-    # </div>>
+    # </div>
     # @see Wx::App#set_top_window 
     # @return [Wx::Window]
     def get_top_window; end
     alias_method :top_window, :get_top_window
     
     # Returns true if the application is active, i.e. if one of its windows is currently in the foreground.
+    # 
     # If this function returns false and you need to attract users attention to the application, you may use {Wx::TopLevelWindow#request_user_attention} to do it.
     # @return [Boolean]
     def is_active; end
     alias_method :active?, :is_active
     
     # This function is similar to {yield}, except that it disables the user input to all program windows before calling Wx::AppConsole::Yield and re-enables it again afterwards.
+    # 
     # If win is not NULL, this window will remain enabled, allowing the implementation of some limited user interaction. Returns the result of the call to Wx::AppConsole::Yield.
     # @see safe_yield 
     # @param win [Wx::Window] 
@@ -86,6 +93,7 @@ module Wx
     def safe_yield(win, onlyIfNeeded) end
     
     # Works like {Wx::App#safe_yield} with onlyIfNeeded == true except that it allows the caller to specify a mask of events to be processed.
+    # 
     # See Wx::AppConsole::YieldFor for more info.
     # @param win [Wx::Window] 
     # @param eventsToProcess [Integer] 
@@ -94,6 +102,7 @@ module Wx
     
     # Allows the programmer to specify whether the application will exit when the top-level frame is deleted.
     # 
+    # 
     # @see Wx::App#get_exit_on_frame_delete
     # @see  Application Shutdown 
     # @param flag [Boolean]  If true (the default), the application will exit when the top-level frame is deleted. If false, the application will continue to run.
@@ -102,6 +111,7 @@ module Wx
     alias_method :exit_on_frame_delete=, :set_exit_on_frame_delete
     
     # Allows runtime switching of the UI environment theme.
+    # 
     # Currently implemented for WXGTK2-only. Return true if theme was successfully changed.
     # @param theme [String]  The name of the new theme or an absolute path to a gtkrc-theme-file
     # @return [Boolean]
@@ -109,6 +119,7 @@ module Wx
     alias_method :native_theme=, :set_native_theme
     
     # Sets the 'top' window.
+    # 
     # You can call this from within {Wx::App#on_init} to let wxWidgets know which is the main window. You don't have to set the top window; it is only a convenience so that (for example) certain dialogs without parents can use a specific window as the top window.
     # If no top window is specified by the application, wxWidgets just uses the first frame or dialog (or better, any {Wx::TopLevelWindow}) in its top-level window list, when it needs to use the top window. If you previously called {Wx::App#set_top_window} and now you need to restore this automatic behaviour you can call 
     # ```
@@ -123,6 +134,7 @@ module Wx
     alias_method :top_window=, :set_top_window
     
     # Allows the programmer to specify whether the application will use the best visual on systems that support several visual on the same display.
+    # 
     # This is typically the case under Solaris and IRIX, where the default visual is only 8-bit whereas certain applications are supposed to run in TrueColour mode.
     # Note that this function has to be called in the constructor of the {Wx::App} instance and won't have any effect when called later on. This function currently only has effect under GTK.
     # @param flag [Boolean]  If true, the app will use the best visual.
@@ -132,17 +144,20 @@ module Wx
     alias_method :use_best_visual=, :set_use_best_visual
     
     # Returns a pointer to the top application window if any.
+    # 
     # This function is safe to call even before creating, or after destroying, the application object, as it simply returns NULL if it doesn't exist. Otherwise it's equivalent to calling <code>wxTheApp->Wx::App#get_top_window</code>.
     # @return [Wx::Window]
     def self.get_main_top_window; end
     
     # Call this to explicitly exit the main message (event) loop.
+    # 
     # You should normally exit the main loop (and the application) by deleting the top window.
     # This function simply calls Wx::EvtLoopBase#exit on the active loop.
     # @return [void]
     def exit_main_loop; end
     
     # Overridden {Wx::EventFilter} method.
+    # 
     # This function is called before processing any event and allows the application to preempt the processing of some events, see {Wx::EventFilter} documentation for more information.
     # {Wx::App} implementation of this method always return -1 indicating that the event should be processed normally.
     # @param event [Wx::Event] 
@@ -150,12 +165,14 @@ module Wx
     def filter_event(event) end
     
     # Returns true if the application is using an event loop.
+    # 
     # This function always returns true for the GUI applications which must use an event loop but by default only returns true for the console programs if an event loop is already running as it can't know whether one will be created in the future.
     # Thus, it only makes sense to override it in console applications which do use an event loop, to return true instead of checking if there is a currently active event loop.
     # @return [Boolean]
     def uses_event_loop; end
     
     # Process all pending events; it is necessary to call this function to process events posted with {Wx::EvtHandler#queue_event} or {Wx::EvtHandler#add_pending_event}.
+    # 
     # This happens during each event loop iteration (see {Wx::EventLoopBase}) in GUI mode but it may be also called directly.
     # Note that this function does not only process the pending events for the {Wx::App} object itself (which derives from {Wx::EvtHandler}) but also the pending events for any event handler of this application.
     # This function will immediately return and do nothing if {Wx::App#suspend_processing_of_pending_events} was called.
@@ -163,11 +180,13 @@ module Wx
     def process_pending_events; end
     
     # Deletes the pending events of all {Wx::EvtHandlers} of this application.
+    # 
     # See {Wx::EvtHandler#delete_pending_events} for warnings about deleting the pending events.
     # @return [void]
     def delete_pending_events; end
     
     # Returns true if there are pending events on the internal pending event list.
+    # 
     # Whenever {Wx::EvtHandler#queue_event} or {Wx::EvtHandler#add_pending_event} are called (not only for {Wx::App} itself, but for any event handler of the application!), the internal {Wx::App}'s list of handlers with pending events is updated and this function will return true.
     # @return [Boolean]
     def has_pending_events; end
@@ -175,6 +194,7 @@ module Wx
     
     # Temporary suspends processing of the pending events.
     # 
+    # 
     # @see Wx::App#resume_processing_of_pending_events 
     # @return [void]
     def suspend_processing_of_pending_events; end
@@ -184,6 +204,7 @@ module Wx
     def resume_processing_of_pending_events; end
     
     # This function is called when an assert failure occurs, i.e. the condition specified in {assert} macro evaluated to false.
+    # 
     # It is only called in debug mode (when __WXDEBUG__ is defined) as asserts are not left in the release code at all. The base class version shows the default assert failure dialog box proposing to the user to stop the program, continue or ignore all subsequent asserts.
     # @param file [String]  the name of the source file where the assert occurred
     # @param line [Integer]  the line number in this file where the assert occurred
@@ -194,6 +215,7 @@ module Wx
     def on_assert_failure(file, line, func, cond, msg) end
     
     # Returns the user-readable application name.
+    # 
     # The difference between this string and the one returned by {Wx::App#get_app_name} is that this one is meant to be shown to the user and so should be used for the window titles, page headers and so on while the other one should be only used internally, e.g. for the file names or configuration file keys.
     # If the application name for display had been previously set by {Wx::App#set_app_display_name}, it will be returned by this function. Otherwise, if {Wx::App#set_app_name} had been called its value will be returned; also as is. Finally if none was called, this function returns the program name capitalized using Wx::String#capitalize.
     # @return [String]
@@ -201,6 +223,7 @@ module Wx
     alias_method :app_display_name, :get_app_display_name
     
     # Returns the application name.
+    # 
     # If {Wx::App#set_app_name} had been called, returns the string passed to it. Otherwise returns the program name, i.e. the value of argv[0] passed to the <code>main()</code> function.
     # @see Wx::App#get_app_display_name 
     # @return [String]
@@ -208,6 +231,7 @@ module Wx
     alias_method :app_name, :get_app_name
     
     # Gets the class name of the application.
+    # 
     # The class name may be used in a platform specific manner to refer to the application.
     # @see Wx::App#set_class_name 
     # @return [String]
@@ -215,12 +239,14 @@ module Wx
     alias_method :class_name, :get_class_name
     
     # Returns a pointer to the {Wx::AppTraits} object for the application.
+    # 
     # If you want to customize the {Wx::AppTraits} object, you must override the {Wx::App#create_traits} function.
     # @return [Wx::AppTraits]
     def get_traits; end
     alias_method :traits, :get_traits
     
     # Returns the user-readable vendor name.
+    # 
     # The difference between this string and the one returned by {Wx::App#get_vendor_name} is that this one is meant to be shown to the user and so should be used for the window titles, page headers and so on while the other one should be only used internally, e.g. for the file names or configuration file keys.
     # By default, returns the same string as {Wx::App#get_vendor_name}.
     # @return [Wx::String]
@@ -233,6 +259,7 @@ module Wx
     alias_method :vendor_name, :get_vendor_name
     
     # Set the application name to be used in the user-visible places such as window titles.
+    # 
     # See {Wx::App#get_app_display_name} for more about the differences between the display name and name.
     # Notice that if this function is called, the name is used as is, without any capitalization as done by default by {Wx::App#get_app_display_name}.
     # @param name [String] 
@@ -241,6 +268,7 @@ module Wx
     alias_method :app_display_name=, :set_app_display_name
     
     # Sets the name of the application.
+    # 
     # This name should be used for file names, configuration file entries and other internal strings. For the user-visible strings, such as the window titles, the application display name set by {Wx::App#set_app_display_name} is used instead.
     # By default the application name is set to the name of its executable file.
     # @see Wx::App#get_app_name 
@@ -250,6 +278,7 @@ module Wx
     alias_method :app_name=, :set_app_name
     
     # Sets the class name of the application.
+    # 
     # This may be used in a platform specific manner to refer to the application.
     # @see Wx::App#get_class_name 
     # @param name [String] 
@@ -258,6 +287,7 @@ module Wx
     alias_method :class_name=, :set_class_name
     
     # Set the vendor name to be used in the user-visible places.
+    # 
     # See {Wx::App#get_vendor_display_name} for more about the differences between the display name and name.
     # @param name [String] 
     # @return [void]
@@ -265,6 +295,7 @@ module Wx
     alias_method :vendor_display_name=, :set_vendor_display_name
     
     # Sets the name of application's vendor.
+    # 
     # The name will be used in registry access. A default name is set by wxWidgets.
     # @see Wx::App#get_vendor_name 
     # @param name [String] 
@@ -273,6 +304,7 @@ module Wx
     alias_method :vendor_name=, :set_vendor_name
     
     # Yields control to pending messages in the event loop.
+    # 
     # This method is a convenient wrapper for Wx::EvtLoopBase#yield. If the main loop is currently running, it calls this method on it. Otherwise it creates a temporary event loop and uses it instead, which can be useful to process pending messages during the program startup, before the main loop is created.
     # Use extreme caution when calling this function as, just as Wx::EvtLoopBase#yield, it can result in unexpected reentrances.
     # @param onlyIfNeeded [Boolean] 
@@ -280,6 +312,7 @@ module Wx
     def yield(onlyIfNeeded=false) end
     
     # Sets the C locale to the default locale for the current environment.
+    # 
     # It is advised to call this to ensure that the underlying toolkit uses the locale in which the numbers and monetary amounts are shown in the format expected by user and so on.
     # Calling this function is roughly equivalent to calling 
     # ```
@@ -295,6 +328,7 @@ module Wx
     def set_c_locale; end
     
     # Returns true if the main event loop is currently running, i.e. if the application is inside {Wx::App#on_run}.
+    # 
     # This can be useful to test whether events can be dispatched. For example, if this function returns false, non-blocking sockets cannot be used because the events from them would never be processed.
     # @return [Boolean]
     def self.is_main_loop_running; end