wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0-x64-mingw-ucrt

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

@@ -12,13 +12,19 @@ module Wx
   # === Events emitted by this class
   # 
   # Event handler methods for events emitted by this class:
-  #  
+  # 
   # - {Wx::EvtHandler#evt_query_end_session}(meth = nil, &block): Process a query end session event, supplying the member function. See {Wx::CloseEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_end_session}(meth = nil, &block): Process an end session event, supplying the member function. See {Wx::CloseEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_activate_app}(meth = nil, &block): Process a {Wx::EVT_ACTIVATE_APP} event. See {Wx::ActivateEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_hibernate}(meth = nil, &block): Process a hibernate event. See {Wx::ActivateEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_dialup_connected}(meth = nil, &block): A connection with the network was established. See {Wx::DialUpEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_dialup_disconnected}(meth = nil, &block): The connection with the network was lost. See {Wx::DialUpEvent}. 
+  # 
   # - {Wx::EvtHandler#evt_idle}(meth = nil, &block): Process a {Wx::EVT_IDLE} event. See {Wx::IdleEvent}. 
   # 
   # === 
@@ -32,89 +38,27 @@ module Wx
   # 
   class App < EvtHandler
   
-    # Called in response of an "open-application" Apple event.
-    # Override this to create a new document in your app.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @return [void]
-    def mac_new_file; end
-    
-    # Called in response of an openFiles message.
-    # You need to override this method in order to open one or more document files after the user double clicked on it or if the files and/or folders were dropped on either the application in the dock or the application icon in Finder.
-    # By default this method calls MacOpenFile for each file/folder.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @param fileNames [Array<String>] 
-    # @return [void]
-    def mac_open_files(fileNames) end
-    
-    # Called in response of a "get-url" Apple event.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @param url [String] 
-    # @return [void]
-    def mac_open_url(url) end
-    
-    # Called in response of a "print-document" Apple event.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @param fileName [String] 
-    # @return [void]
-    def mac_print_file(fileName) end
-    
-    # Called in response of a "reopen-application" Apple event.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @return [void]
-    def mac_reopen_app; end
-    
-    # May be overridden to indicate that the application is not a foreground GUI application under macOS.
-    # This method is called during the application startup and returns true by default. In this case, wxWidgets ensures that the application is ran as a foreground, GUI application so that the user can interact with it normally, even if it is not bundled. If this is undesired, i.e. if the application doesn't need to be brought to the foreground, this method can be overridden to return false.
-    # Notice that overriding it doesn't make any difference for the bundled applications which are always foreground unless LSBackgroundOnly key is specified in the Info.plist file.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx}
-    # @return [true,false]
-    def osx_is_gui_application; end
-    
-    # Enable the automatic tabbing features of macOS.
-    # This feature is native to the operating system. When it is enabled, macOS will automatically place windows inside tabs and show a tab bar in the application. Entries are also added to the View menu to show/hide the tab bar.
-    # Availability:  only available for the {Wx::OSX/Cocoa} port.  {Wx::osx} 
-    # Requires macOS 10.12+, does nothing under earlier OS versions.
-    # @param enable [true,false] 
-    # @return [void]
-    def osx_enable_automatic_tabbing(enable) end
-    
-    # Disables the printing of various GTK messages.
-    # This function can be called to suppress GTK diagnostic messages that are output on the standard error stream by default.
-    # The default value of the argument disables all messages, but you can pass in a mask flag to specifically disable only particular categories of messages.
-    # Note that this function only works when using glib 2.50 (released in September 2016) or later and does nothing with the older versions of the library.
-    # 
-    # Availability:  only available for the {Wx::GTK} port.  {Wx::gtk}
-    # @param flags [Integer]  The mask for the types of messages to suppress. Refer to the glib documentation for the GLogLevelFlags enum, which defines the various message types.
-    # @return [void]
-    def self.gtk_suppress_diagnostics(flags=-1) end
-    
     # Constructor.
     # Called implicitly with a definition of a {Wx::App} object.
-    # @return [App]
+    # @return [Wx::App]
     def initialize; end
     
-    # Get display mode that is used use.
-    # This is only used in framebuffer wxWidgets ports such as {Wx::DFB}.
-    # @return [Wx::VideoMode]
-    def get_display_mode; end
-    alias_method :display_mode, :get_display_mode
-    
     # Returns true if the application will exit when the top-level frame is deleted.
     # 
     # @see Wx::App#set_exit_on_frame_delete 
-    # @return [true,false]
+    # @return [Boolean]
     def get_exit_on_frame_delete; end
     alias_method :exit_on_frame_delete, :get_exit_on_frame_delete
     
     # Return the layout direction for the current locale or {Wx::LayoutDirection::Layout_Default} if it's unknown.
-    # @return [LayoutDirection]
+    # @return [Wx::LayoutDirection]
     def get_layout_direction; end
     alias_method :layout_direction, :get_layout_direction
     
     # 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 [true,false]
+    # @return [Boolean]
     def get_use_best_visual; end
     alias_method :use_best_visual, :get_use_best_visual
     
@@ -127,7 +71,7 @@ module Wx
     
     # 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 [true,false]
+    # @return [Boolean]
     def is_active; end
     alias_method :active?, :is_active
     
@@ -135,37 +79,30 @@ module Wx
     # 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] 
-    # @param onlyIfNeeded [true,false] 
-    # @return [true,false]
+    # @param onlyIfNeeded [Boolean] 
+    # @return [Boolean]
     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] 
-    # @return [true,false]
+    # @return [Boolean]
     def safe_yield_for(win, eventsToProcess) end
     
-    # Set display mode to use.
-    # This is only used in framebuffer wxWidgets ports such as {Wx::DFB}.
-    # @param info [Wx::VideoMode] 
-    # @return [true,false]
-    def set_display_mode(info) end
-    alias_method :display_mode=, :set_display_mode
-    
     # 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 [true,false]  If true (the default), the application will exit when the top-level frame is deleted. If false, the application will continue to run.
+    # @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.
     # @return [void]
     def set_exit_on_frame_delete(flag) end
     alias_method :exit_on_frame_delete=, :set_exit_on_frame_delete
     
     # Allows runtime switching of the UI environment theme.
-    # Currently implemented for {Wx::GTK2}-only. Return true if theme was successfully changed.
+    # 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 [true,false]
+    # @return [Boolean]
     def set_native_theme(theme) end
     alias_method :native_theme=, :set_native_theme
     
@@ -186,8 +123,8 @@ module Wx
     # 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 [true,false]  If true, the app will use the best visual.
-    # @param forceTrueColour [true,false]  If true then the application will try to force using a TrueColour visual and abort the app if none is found.
+    # @param flag [Boolean]  If true, the app will use the best visual.
+    # @param forceTrueColour [Boolean]  If true then the application will try to force using a TrueColour visual and abort the app if none is found.
     # @return [void]
     def set_use_best_visual(flag, forceTrueColour=false) end
     alias_method :use_best_visual=, :set_use_best_visual
@@ -213,7 +150,7 @@ module Wx
     # 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 [true,false]
+    # @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}.
@@ -230,7 +167,7 @@ module Wx
     
     # 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 [true,false]
+    # @return [Boolean]
     def has_pending_events; end
     alias_method :has_pending_events?, :has_pending_events
     
@@ -336,8 +273,8 @@ module Wx
     # 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 [true,false] 
-    # @return [true,false]
+    # @param onlyIfNeeded [Boolean] 
+    # @return [Boolean]
     def yield(onlyIfNeeded=false) end
     
     # Sets the C locale to the default locale for the current environment.
@@ -357,7 +294,7 @@ module Wx
     
     # 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 [true,false]
+    # @return [Boolean]
     def self.is_main_loop_running; end
     
   end # App

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

@@ -0,0 +1,381 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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.
+  # === 
+  # 
+  # Category:  Application and System configuration
+  # @see wxApp Overview
+  # @see  Wx::App 
+  # 
+  # 
+  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 {Wx::Mac} and {Wx::Cocoa}.
+    # The returned reference is to a {Wx::StandardPathsBase} class but you can consider it to be equivalent to {Wx::StandardPaths} (which is documented).
+    # @return [Wx::StandardPaths]
+    def get_standard_paths; end
+    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.
+    # @return [Array(Wx::PortId,Integer,Integer,Integer)]
+    def get_toolkit_version; end
+    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.
+    # 
+    # true if the message box was shown or false otherwise.
+    # @param text [String]  The text to show to the user.
+    # @param title [String]  The title of the message box shown to the user.
+    # @return [Boolean]
+    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]
+    def get_assert_stack_trace; end
+    alias_method :assert_stack_trace, :get_assert_stack_trace
+    
+  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.
+  # The other placeholders should be self-explanatory: the string username should be replaced with the value the name of the currently logged in user. and prefix is only used under Unix and is <code>/usr/local</code> by default but may be changed using {Wx::StandardPaths#set_install_prefix}.
+  # The directories returned by the methods of this class may or may not exist. If they don't exist, it's up to the caller to create them, {Wx::StandardPaths} doesn't do it.
+  # Finally note that these functions only work with standardly packaged applications. I.e. under Unix you should follow the standard installation conventions and under Mac you should create your application bundle according to the Apple guidelines. Again, this class doesn't help you to do it.
+  # This class is MT-safe: its methods may be called concurrently from different threads without additional locking.
+  # === 
+  # 
+  # Category:  File Handling
+  # @see Wx::FileConfig 
+  # 
+  # 
+  class StandardPaths < ::Object
+  
+    # Possible values for category parameter of {Wx::StandardPaths#get_localized_resources_dir}.
+    # 
+    # 
+    # 
+    class ResourceCat < Wx::Enum
+    
+      # No special category, this is the default.
+      # 
+      ResourceCat_None = Wx::StandardPaths::ResourceCat.new(0)
+      
+      # Message catalog resources category.
+      # 
+      ResourceCat_Messages = Wx::StandardPaths::ResourceCat.new(1)
+      
+    end # ResourceCat
+    
+    # Possible values for userDir parameter of {Wx::StandardPaths#get_user_dir}.
+    # 
+    # 
+    # 
+    class Dir < Wx::Enum
+    
+      # Directory for caching files.
+      # 
+      Dir_Cache = Wx::StandardPaths::Dir.new(0)
+      
+      # Directory containing user documents.
+      # 
+      Dir_Documents = Wx::StandardPaths::Dir.new(1)
+      
+      # Directory containing files on the users desktop.
+      # 
+      Dir_Desktop = Wx::StandardPaths::Dir.new(2)
+      
+      # Directory for downloaded files.
+      # 
+      Dir_Downloads = Wx::StandardPaths::Dir.new(3)
+      
+      # Directory containing music files.
+      # 
+      Dir_Music = Wx::StandardPaths::Dir.new(4)
+      
+      # Directory containing picture files.
+      # 
+      Dir_Pictures = Wx::StandardPaths::Dir.new(5)
+      
+      # Directory containing video files.
+      # 
+      Dir_Videos = Wx::StandardPaths::Dir.new(6)
+      
+    end # Dir
+    
+    # Possible values for {Wx::StandardPaths#set_file_layout} argument.
+    # 
+    # The elements of this enum correspond to the different file layout standards under Unix systems.
+    # 
+    class FileLayout < Wx::Enum
+    
+      # Use the classic file layout.
+      # 
+      FileLayout_Classic = Wx::StandardPaths::FileLayout.new(0)
+      
+      # Use a XDG styled file layout.
+      # 
+      FileLayout_XDG = Wx::StandardPaths::FileLayout.new(1)
+      
+    end # FileLayout
+    
+    # Possible values for {Wx::StandardPaths#make_config_file_name} naming convention argument.
+    # 
+    # The values in this enum are only used under Unix and only when using the classic Unix convention for file layout, in XDG mode, XDG naming convention is used unconditionally.
+    # 
+    class ConfigFileConv < Wx::Enum
+    
+      # Use the class Unix dot-file convention.
+      # 
+      ConfigFileConv_Dot = Wx::StandardPaths::ConfigFileConv.new(0)
+      
+      # Use <code></code>.conf extension for the file names.
+      # 
+      ConfigFileConv_Ext = Wx::StandardPaths::ConfigFileConv.new(1)
+      
+    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]
+    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:
+    # 
+    # - Unix: <code>~/appinfo</code> 
+    # - Windows: <code>"C:\Users\username\Documents\appinfo"</code> or <code>"C:\Documents and Settings\username\My Documents\appinfo"</code> 
+    # - Mac: <code>~/Documents/appinfo</code>
+    # @return [String]
+    def get_app_documents_dir; end
+    alias_method :app_documents_dir, :get_app_documents_dir
+    
+    # Return the directory containing the system config files.
+    # Example return values:
+    # 
+    # - Unix: <code>/etc</code> 
+    # - Windows: <code>"C:\ProgramData\appinfo"</code> or <code>"C:\Documents and Settings\All Users\Application Data\appinfo"</code> 
+    # - Mac: <code>/Library/Preferences</code> 
+    # 
+    # Under Windows this includes appinfo which makes it inconsistent with other ports.
+    # @see Wx::FileConfig 
+    # @return [String]
+    def get_config_dir; end
+    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> 
+    # - Windows: the directory where the executable file is located
+    # - Mac: <code>appinfo.app/Contents/SharedSupport</code> bundle subdirectory
+    # 
+    # Under Unix (only) it is possible to override the default value returned from this function by setting the value of WX_APPNAME_DATA_DIR environment variable to the directory to use (where APPNAME is the upper-cased value of {Wx::App#get_app_name}). This is useful in order to be able to run applications using this function without installing them as you can simply set this environment variable to the source directory location to allow the application to find its files there.
+    # @see Wx::StandardPaths#get_local_data_dir 
+    # @return [String]
+    def get_data_dir; end
+    alias_method :data_dir, :get_data_dir
+    
+    # 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]
+    def get_documents_dir; end
+    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> 
+    # - Windows: <code>"C:\Programs\AppFolder\exename.exe"</code> 
+    # - Mac: <code>/Applications/exename</code>.app/Contents/MacOS/exename
+    # @return [String]
+    def get_executable_path; end
+    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] 
+    # @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> 
+    # - Windows: the directory of the executable file
+    # - Mac: <code>appinfo.app/Contents/PlugIns</code> bundle subdirectory
+    # @see Wx::DynamicLibrary 
+    # @return [String]
+    def get_plugins_dir; end
+    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:
+    # 
+    # - Unix: <code>prefix/share/appinfo</code> 
+    # - Windows: the directory where the executable file is located
+    # - Mac: <code>appinfo.app/Contents/Resources</code> bundle subdirectory
+    # @see Wx::StandardPaths#get_localized_resources_dir 
+    # @return [String]
+    def get_resources_dir; end
+    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
+    # - Windows: <code>"C:\Users\username\AppData\Roaming"</code> or <code>"C:\Documents and Settings\username\Application Data"</code> 
+    # - Mac: <code>~/Library/Preferences</code> 
+    # 
+    # Only use this method if you have a single configuration file to put in this directory, otherwise {Wx::StandardPaths#get_user_data_dir} is more appropriate as the latter adds appinfo to the path, unlike this function.
+    # @return [String]
+    def get_user_config_dir; end
+    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>
+    # @return [String]
+    def get_user_data_dir; end
+    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.
+    # 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.
+    # @param userDir [Wx::wxStandardPaths::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.
+    # - The program is in "debug" subdirectory of the directory containing sources and data files during development
+    # 
+    # By calling this function you instruct the class to remove the last component of the path if it matches its argument. Notice that it may be called more than once, e.g. you can call both IgnoreAppSubDir("bin") and IgnoreAppSubDir("debug") to take care of both production and development cases above but that each call will only remove the last path component. Finally note that the argument can contain wild cards so you can also call IgnoreAppSubDir("vc*msw*") to ignore all build directories at once when using wxWidgets-inspired output directories names.
+    # @see Wx::StandardPaths#ignore_app_build_sub_dirs
+    # @param subdirPattern [String]  The subdirectory containing the application binary which should be ignored when determining the top application directory. The pattern is case-insensitive and may contain wild card characters <code>'</code>?' and <code>'*'</code>.
+    # @return [void]
+    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]
+    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.
+    # - AppInfo_AppName: use the application name in the paths.
+    # - AppInfo_VendorName: use the vendor name in the paths, usually used combined with AppInfo_AppName, i.e. as <code>AppInfo_AppName | AppInfo_VendorName</code>.
+    # 
+    # By default, only the application name is used.
+    # @param info [Integer] 
+    # @return [void]
+    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] 
+    # @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]
+    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] 
+    # @return [String]
+    def make_config_file_name(basename, conv=Wx::StandardPaths::ConfigFileConv::ConfigFileConv_Ext) end
+    
+    # Returns reference to the unique global standard paths object.
+    # @return [Wx::StandardPaths]
+    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__
+    #       // get the location of files waiting to be burned on a CD
+    #       wxString cdburnArea =
+    #           wxStandardPaths::MSWGetShellDir(CSIDL_CDBURN_AREA);
+    #   #endif // __WXMSW__
+    # ```
+    # @param csidl [Integer]  
+    # @return [String]
+    def self.msw_get_shell_dir(csidl) end
+    
+  end # StandardPaths
+  
+
+end