wxruby3 0.9.2-x64-mingw-ucrt → 0.9.4-x64-mingw-ucrt

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

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

@@ -7,6 +7,7 @@
 module Wx
 
   # The {Wx::AppTraits} class defines various configurable aspects of a {Wx::App}.
+  # 
   # You can access it using {Wx::App#get_traits} function and you can create your own {Wx::AppTraits} overriding the {Wx::App#create_traits} function.
   # Note that {Wx::AppTraits} is an abstract class since it contains many pure virtual functions. In fact, by default, wxWidgets creates a {Wx::ConsoleAppTraits} object for console applications (i.e. those applications linked against {Wx::Base} library only - see the Library List page) and a {Wx::GUIAppTraits} object for GUI applications. Both these classes are derived by {Wx::AppTraits} and represent concrete implementation of the {Wx::AppTraits} interface.
   # 
@@ -18,12 +19,14 @@ module Wx
   class AppTraits < ::Object
   
     # This method returns the name of the desktop environment currently running in a Unix desktop.
+    # 
     # Currently only "KDE" or "GNOME" are supported and the code uses the X11 session protocol vendor name to figure out, which desktop environment is running. The method returns an empty string otherwise and on all other platforms.
     # @return [String]
     def get_desktop_environment; end
     alias_method :desktop_environment, :get_desktop_environment
     
     # Returns the {Wx::StandardPaths} object for the application.
+    # 
     # It's normally the same for {Wx::Base} and {Wx::GUI} except in the case of WXOSX and {Wx::Cocoa}.
     # 
     # <div class="wxrb-note">
@@ -36,6 +39,7 @@ module Wx
     alias_method :standard_paths, :get_standard_paths
     
     # Returns the wxWidgets port ID used by the running program and eventually fills the given pointers with the values of the major, minor, and micro digits of the native toolkit currently used.
+    # 
     # The version numbers returned are thus detected at run-time and not compile-time (except when this is not possible e.g. {Wx::Motif}).
     # E.g. if your program is using WXGTK port this function will return {Wx::PortId::PORT_GTK} and put in given pointers the versions of the GTK library in use. See {Wx::PlatformInfo} for more details.
     # If a micro version is not available it will have a value of 0.
@@ -44,18 +48,21 @@ module Wx
     alias_method :toolkit_version, :get_toolkit_version
     
     # Returns true if the library was built as {Wx::Universal}.
+    # 
     # Always returns false for {Wx::Base}-only apps.
     # @return [Boolean]
     def is_using_universal_widgets; end
     alias_method :using_universal_widgets?, :is_using_universal_widgets
     
     # Shows the assert dialog with the specified message in GUI mode or just prints the string to stderr in console mode.
+    # 
     # Returns true to suppress subsequent asserts, false to continue as before.
     # @param msg [String] 
     # @return [Boolean]
     def show_assert_dialog(msg) end
     
     # Shows a message box with the given text and title if possible.
+    # 
     # In some ports, e.g. WXMSW, a message box will always be shown, while in the other ones it will be only done if the GUI is available (e.g. X11 display was successfully opened for X11-based ports) and the function simply returns false without doing anything otherwise.
     # This function is safe in the sense that it can always be called, even before creating {Wx::App}, similarly to {safe_show_message} which is implemented by calling this function and then logging the message to standard error stream if it returned false.
     # 
@@ -66,6 +73,7 @@ module Wx
     def safe_message_box(text, title) end
     
     # Helper function mostly useful for derived classes {Wx::AppTraits#show_assert_dialog} implementation.
+    # 
     # Returns the stack frame as a plain (and possibly empty) {Wx::String}.
     # This function is only available when {Wx::Setup::USE_STACKWALKER} is 1.
     # @return [String]
@@ -76,6 +84,7 @@ module Wx
   end # AppTraits
   
   # {Wx::StandardPaths} returns the standard locations in the file system and should be used by applications to find their data files in a portable way.
+  # 
   # Note that you must not create objects of class {Wx::StandardPaths} directly, but use the global standard paths object returned by {Wx::StandardPaths.get} (which can be of a type derived from {Wx::StandardPaths} and not of exactly this type) and call the methods you need on it. The object returned by {Wx::StandardPaths.get} may be customized by overriding {Wx::AppTraits#get_standard_paths} methods.
   # In the description of the methods below, the example return values are given for the Unix, Windows and macOS systems, however please note that these are just the examples and the actual values may differ. For example, under Windows: the system administrator may change the standard directories locations, e.g. the Windows directory may be named <code>"W:\Win2003"</code> instead of the default <code>"C:\Windows"</code>.
   # Notice that in the examples below the string appinfo may be either just the application name (as returned by {Wx::App#get_app_name}) or a combination of the vendor name ({Wx::App#get_vendor_name}) and the application name, with a path separator between them. By default, only the application name is used, use {Wx::StandardPaths#use_app_info} to change this.
@@ -88,6 +97,8 @@ module Wx
   # @see Wx::FileConfig 
   # 
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class StandardPaths < ::Object
   
     # Possible values for category parameter of {Wx::StandardPaths#get_localized_resources_dir}.
@@ -175,12 +186,14 @@ module Wx
     end # ConfigFileConv
     
     # MSW-specific function undoing the effect of {Wx::StandardPaths#ignore_app_sub_dir} calls.
+    # 
     # After a call to this function the program directory will be exactly the directory containing the main application binary, i.e. it undoes the effect of any previous {Wx::StandardPaths#ignore_app_sub_dir} calls including the ones done indirectly by {Wx::StandardPaths#ignore_app_build_sub_dirs} called from the class constructor.
     # @return [void]
     # @wxrb_require WXMSW
     def dont_ignore_app_sub_dir; end
     
     # Return the directory for the document files used by this application.
+    # 
     # If the application-specific directory doesn't exist, this function returns {Wx::StandardPaths#get_documents_dir}.
     # Example return values:
     # 
@@ -192,6 +205,7 @@ module Wx
     alias_method :app_documents_dir, :get_app_documents_dir
     
     # Return the directory containing the system config files.
+    # 
     # Example return values:
     # 
     # - Unix: <code>/etc</code> 
@@ -209,6 +223,7 @@ module Wx
     alias_method :config_dir, :get_config_dir
     
     # Return the location of the applications global, i.e. not user-specific, data files.
+    # 
     # Example return values:
     # 
     # - Unix: <code>prefix/share/appinfo</code> 
@@ -223,6 +238,7 @@ module Wx
     
     # Same as calling {Wx::StandardPaths#get_user_dir} with Dir_Documents parameter.
     # 
+    # 
     # @see Wx::StandardPaths#get_app_documents_dir
     # @see  Wx::StandardPaths#get_user_dir 
     # @return [String]
@@ -230,6 +246,7 @@ module Wx
     alias_method :documents_dir, :get_documents_dir
     
     # Return the directory and the filename for the current executable.
+    # 
     # Example return values:
     # 
     # - Unix: <code>/usr/local/bin/exename</code> 
@@ -240,20 +257,23 @@ module Wx
     alias_method :executable_path, :get_executable_path
     
     # Return the location for application data files which are host-specific and can't, or shouldn't, be shared with the other machines.
+    # 
     # This is the same as {Wx::StandardPaths#get_data_dir} except under Unix where it returns <code>/etc/appinfo</code>.
     # @return [String]
     def get_local_data_dir; end
     alias_method :local_data_dir, :get_local_data_dir
     
     # Return the localized resources directory containing the resource files of the specified category for the given language.
+    # 
     # In general this is just the same as lang subdirectory of {Wx::StandardPaths#get_resources_dir} (or lang.lproj under macOS) but is something quite different for message catalog category under Unix where it returns the standard <code>prefix/share/locale/lang/LC_MESSAGES</code> directory.
     # @param lang [String] 
-    # @param category [Wx::wxStandardPaths::ResourceCat] 
+    # @param category [Wx::StandardPaths::ResourceCat] 
     # @return [String]
     def get_localized_resources_dir(lang, category=Wx::StandardPaths::ResourceCat::ResourceCat_None) end
     alias_method :localized_resources_dir, :get_localized_resources_dir
     
     # Return the directory where the loadable modules (plugins) live.
+    # 
     # Example return values:
     # 
     # - Unix: <code>prefix/lib/appinfo</code> 
@@ -265,6 +285,7 @@ module Wx
     alias_method :plugins_dir, :get_plugins_dir
     
     # Return the directory where the application resource files are located.
+    # 
     # The resources are the auxiliary data files needed for the application to run and include, for example, image and sound files it might use.
     # This function is the same as {Wx::StandardPaths#get_data_dir} for all platforms except macOS. Example return values:
     # 
@@ -277,12 +298,14 @@ module Wx
     alias_method :resources_dir, :get_resources_dir
     
     # Return the directory for storing temporary files, for the current user.
+    # 
     # Same as Wx::FileName#get_temp_dir. To create unique temporary files, it is best to use Wx::FileName#create_temp_file_name for correct behaviour when multiple processes are attempting to create temporary files.
     # @return [String]
     def get_temp_dir; end
     alias_method :temp_dir, :get_temp_dir
     
     # Return the directory for the user config files.
+    # 
     # This directory is:
     # 
     # - Unix: <code>~</code> (the home directory) or XDG_CONFIG_HOME depending on {Wx::StandardPaths#get_file_layout} return value
@@ -295,6 +318,7 @@ module Wx
     alias_method :user_config_dir, :get_user_config_dir
     
     # Return the directory for the user-dependent application data files:
+    # 
     # - Unix: <code>~/</code>.appinfo
     # - Windows: <code>"C:\Users\username\AppData\Roaming\appinfo"</code> or <code>"C:\Documents and Settings\username\Application Data\appinfo"</code> 
     # - Mac: <code>"~/Library/Application Support/appinfo"</code>
@@ -303,6 +327,7 @@ module Wx
     alias_method :user_data_dir, :get_user_data_dir
     
     # Return the path of the specified user data directory.
+    # 
     # If the value could not be determined the users home directory is returned.
     # 
     # <div class="wxrb-note">
@@ -310,18 +335,20 @@ module Wx
     # <p>On Unix this (newer) method always respects the XDG base directory specification, even if {Wx::StandardPaths#set_file_layout} with FileLayout_XDG hadn't been called.
     # </p>
     # </div>
-    # @param userDir [Wx::wxStandardPaths::Dir] 
+    # @param userDir [Wx::StandardPaths::Dir] 
     # @return [String]
     def get_user_dir(userDir) end
     alias_method :user_dir, :get_user_dir
     
     # Return the directory for user data files which shouldn't be shared with the other machines.
+    # 
     # This is the same as {Wx::StandardPaths#get_user_data_dir} for all platforms except Windows where it returns <code>"C:\Users\username\AppData\Local\appinfo"</code> or <code>"C:\Documents and Settings\username\Local Settings\Application Data\appinfo"</code>
     # @return [String]
     def get_user_local_data_dir; end
     alias_method :user_local_data_dir, :get_user_local_data_dir
     
     # MSW-specific function to customize application directory detection.
+    # 
     # This class supposes that data, plugins &c files are located under the program directory which is the directory containing the application binary itself. But sometimes this binary may be in a subdirectory of the main program directory, e.g. this happens in at least the following common cases:
     # 
     # - The program is in "bin" subdirectory of the installation directory.
@@ -335,6 +362,7 @@ module Wx
     def ignore_app_sub_dir(subdirPattern) end
     
     # MSW-specific function to ignore all common build directories.
+    # 
     # This function calls {Wx::StandardPaths#ignore_app_sub_dir} with all common values for build directory, e.g. <code>"debug"</code> and <code>"release"</code>.
     # It is called by the class constructor and so the build directories are always ignored by default. You may use {Wx::StandardPaths#dont_ignore_app_sub_dir} to avoid ignoring them if this is inappropriate for your application.
     # @return [void]
@@ -342,6 +370,7 @@ module Wx
     def ignore_app_build_sub_dirs; end
     
     # Controls what application information is used when constructing paths that should be unique to this program, such as the application data directory, the plugins directory on Unix, etc.
+    # 
     # Valid values for info are:
     # 
     # - AppInfo_None: use neither application nor vendor name in the paths.
@@ -354,23 +383,26 @@ module Wx
     def use_app_info(info) end
     
     # Sets the current file layout.
+    # 
     # The default layout is FileLayout_Classic for compatibility, however newer applications are encouraged to set it to FileLayout_XDG on program startup.
-    # @param layout [Wx::wxStandardPaths::FileLayout] 
+    # @param layout [Wx::StandardPaths::FileLayout] 
     # @return [void]
     def set_file_layout(layout) end
     alias_method :file_layout=, :set_file_layout
     
     # Returns the current file layout.
     # 
+    # 
     # @see Wx::StandardPaths#set_file_layout
-    # @return [Wx::wxStandardPaths::FileLayout]
+    # @return [Wx::StandardPaths::FileLayout]
     def get_file_layout; end
     alias_method :file_layout, :get_file_layout
     
     # Return the file name which would be used by {Wx::FileConfig} if it were constructed with basename.
+    # 
     # conv is used to construct the name of the file under Unix and only matters when using the class file layout, i.e. if {Wx::StandardPaths#set_file_layout} had not been called with FileLayout_XDG argument. In this case, this argument is used to determine whether to use an extension or a leading dot. When following XDG specification, the function always appends the extension, regardless of conv value. Finally, this argument is not used at all under non-Unix platforms.
     # @param basename [String] 
-    # @param conv [Wx::wxStandardPaths::ConfigFileConv] 
+    # @param conv [Wx::StandardPaths::ConfigFileConv] 
     # @return [String]
     def make_config_file_name(basename, conv=Wx::StandardPaths::ConfigFileConv::ConfigFileConv_Ext) end
     
@@ -379,6 +411,7 @@ module Wx
     def self.get; end
     
     # Returns location of Windows shell special folder.
+    # 
     # This function is, by definition, MSW-specific. It can be used to access pre-defined shell directories not covered by the existing methods of this class, e.g.: 
     # ```
     #   \#ifdef __WXMSW__

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

@@ -267,6 +267,7 @@ module Wx
   ART_WX_LOGO = "wxART_WX_LOGO"
   
   # {Wx::ArtProvider} class is used to customize the look of wxWidgets application.
+  # 
   # When wxWidgets needs to display an icon or a bitmap (e.g. in the standard file dialog), it does not use a hard-coded resource but asks {Wx::ArtProvider} for it instead. This way users can plug in their own {Wx::ArtProvider} class and easily replace standard art with their own version.
   # All that is needed is to derive a class from {Wx::ArtProvider}, override either its {Wx::ArtProvider#create_bitmap} and/or its {Wx::ArtProvider#create_icon_bundle} methods and register the provider with {Wx::ArtProvider.push}:
   # 
@@ -449,6 +450,7 @@ module Wx
     def self.delete(provider) end
     
     # Query registered providers for bitmap with given ID.
+    # 
     # Note that applications using wxWidgets 3.1.6 or later should prefer calling {Wx::ArtProvider.get_bitmap_bundle}.
     # 
     # The bitmap if one of registered providers recognizes the ID or {Wx::NULL_BITMAP} otherwise.
@@ -459,6 +461,7 @@ module Wx
     def self.get_bitmap(id, client=Wx::ART_OTHER, size=Wx::DEFAULT_SIZE) end
     
     # Query registered providers for a bundle of bitmaps with given ID.
+    # 
     # If any of the registered providers recognizes the ID in its {Wx::ArtProvider#create_bitmap_bundle}, this bundle is returned. Otherwise, if any of providers returns a valid bitmap from {Wx::ArtProvider#create_bitmap}, the bundle containing only this bitmap is returned. Otherwise, an empty bundle is returned.
     # @param id [Wx::ArtID]  {Wx::ArtID} unique identifier of the bitmap.
     # @param client [Wx::ArtClient]  {Wx::ArtClient} identifier of the client (i.e. who is asking for the bitmap).
@@ -474,6 +477,7 @@ module Wx
     def self.get_icon(id, client=Wx::ART_OTHER, size=Wx::DEFAULT_SIZE) end
     
     # Returns native icon size for use specified by client hint in DIPs.
+    # 
     # If the platform has no commonly used default for this use or if client is not recognized, returns {Wx::DEFAULT_SIZE}.
     # 
     # <div class="wxrb-note">
@@ -486,6 +490,7 @@ module Wx
     def self.get_native_dip_size_hint(client) end
     
     # Returns native icon size for use specified by client hint.
+    # 
     # This function does the same thing as {Wx::ArtProvider.get_native_dip_size_hint}, but uses win to convert the returned value to logical pixels. If win is NULL, default DPI scaling (i.e. that of the primary display) is used.
     # @param client [Wx::ArtClient] 
     # @param win [Wx::Window] 
@@ -493,6 +498,7 @@ module Wx
     def self.get_native_size_hint(client, win=nil) end
     
     # Returns a suitable size hint for the given {Wx::ArtClient} in DIPs.
+    # 
     # Return the size used by the topmost {Wx::ArtProvider} for the given client. {Wx::DEFAULT_SIZE} may be returned if the client doesn't have a specified size, like {Wx::ART_OTHER} for example.
     # @see Wx::ArtProvider.get_native_dip_size_hint 
     # @param client [Wx::ArtClient] 
@@ -500,6 +506,7 @@ module Wx
     def self.get_dip_size_hint(client) end
     
     # Returns a suitable size hint for the given {Wx::ArtClient}.
+    # 
     # This function does the same thing as {Wx::ArtProvider.get_dip_size_hint}, but uses win to convert the returned value to logical pixels. If win is NULL, default DPI scaling (i.e. that of the primary display) is used.
     # Note that win parameter is only available since wxWidgets 3.1.6.
     # @param client [Wx::ArtClient] 
@@ -508,6 +515,7 @@ module Wx
     def self.get_size_hint(client, win=nil) end
     
     # Query registered providers for icon bundle with given ID.
+    # 
     # The icon bundle if one of registered providers recognizes the ID or {Wx::NULL_ICON_BUNDLE} otherwise.
     # @param id [Wx::ArtID]  {Wx::ArtID} unique identifier of the icon bundle.
     # @param client [Wx::ArtClient]  {Wx::ArtClient} identifier of the client (i.e. who is asking for the icon bundle).
@@ -515,6 +523,7 @@ module Wx
     def self.get_icon_bundle(id, client=Wx::ART_OTHER) end
     
     # Returns true if the platform uses native icons provider that should take precedence over any customizations.
+    # 
     # This is true for any platform that has user-customizable icon themes, currently only WXGTK.
     # A typical use for this method is to decide whether a custom art provider should be plugged in using {Wx::ArtProvider.push} or {Wx::ArtProvider.push_back}.
     # @return [Boolean]
@@ -525,6 +534,7 @@ module Wx
     def self.pop; end
     
     # Register new art provider and add it to the top of providers stack (i.e.
+    # 
     # it will be queried as the first provider).
     # @see Wx::ArtProvider.push_back 
     # @param provider [Wx::ArtProvider] 
@@ -532,6 +542,7 @@ module Wx
     def self.push(provider) end
     
     # Register new art provider and add it to the bottom of providers stack.
+    # 
     # In other words, it will be queried as the last one, after all others, including the default provider.
     # @see Wx::ArtProvider.push
     # @param provider [Wx::ArtProvider] 
@@ -552,12 +563,14 @@ module Wx
     protected
     
     # Derived art provider classes may override this method to return the size of the images used by this provider.
+    # 
     # Note that the returned size should be in DPI-independent pixels, i.e. DIPs. The default implementation returns the result of {Wx::ArtProvider.get_native_dip_size_hint}.
     # @param client [Wx::ArtClient] 
     # @return [Wx::Size]
     def do_get_size_hint(client) end
     
     # Derived art provider classes may override this method to create requested art resource.
+    # 
     # For bitmaps available in more than one size, {Wx::ArtProvider#create_bitmap_bundle} should be overridden instead.
     # Note that returned bitmaps are cached by {Wx::ArtProvider} and it is therefore not necessary to optimize {Wx::ArtProvider#create_bitmap} for speed (e.g. you may create {Wx::Bitmap} objects from XPMs here).
     # 
@@ -574,6 +587,7 @@ module Wx
     def create_bitmap(id, client, size) end
     
     # Override this method to create the requested art resources available in more than one size.
+    # 
     # Unlike {Wx::ArtProvider#create_bitmap}, this method can be overridden to return the same bitmap in several (or all, if {Wx::BitmapBundle.from_svg} is used) sizes at once, which will allow selecting the size best suited for the current display resolution automatically.
     # @param id [Wx::ArtID]  {Wx::ArtID} unique identifier of the bitmap.
     # @param client [Wx::ArtClient]  {Wx::ArtClient} identifier of the client (i.e. who is asking for the bitmap). This only serves as a hint.