wxruby3 1.6.1 → 1.7.0

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

@@ -0,0 +1,463 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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
+  # 
+  # 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}. 
+  # 
+  # Category:  Application and Process Management
+  # @see wxApp Overview
+  # @see  Wx::AppTraits
+  # @see  Wx::EventLoopBase
+  # @see  Wx::SystemSettings 
+  # 
+  # 
+  class App < EvtHandler
+  
+    # Possible parameters for {Wx::App#set_appearance}.
+    # 
+    # 
+    # 
+    class Appearance < Wx::Enum
+    
+      # Use system default appearance.
+      # 
+      System = Wx::App::Appearance.new(0)
+      
+      # Use light appearance.
+      # 
+      Light = Wx::App::Appearance.new(1)
+      
+      # Use dark appearance.
+      # 
+      Dark = Wx::App::Appearance.new(2)
+      
+    end # Appearance
+    
+    # Possible values returned by {Wx::App#set_appearance}.
+    # 
+    # 
+    # 
+    class AppearanceResult < Wx::Enum
+    
+      # Changing the appearance failed.
+      # 
+      Failure = Wx::App::AppearanceResult.new(0)
+      
+      # {Wx::App::Appearance} was successfully changed.
+      # 
+      Ok = Wx::App::AppearanceResult.new(1)
+      
+      # {Wx::App::Appearance} can't be changed any more.
+      # 
+      CannotChange = Wx::App::AppearanceResult.new(2)
+      
+    end # AppearanceResult
+    
+    # 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.
+    # If WXSUPPRESS_GTK_DIAGNOSTICS environment variable is set to a non-zero value, wxWidgets automatically calls this function on program startup with the value of this variable as flags if it's a number or with the default flags value otherwise.
+    # 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 WXGTK port.
+    # @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]
+    # @wxrb_require WXGTK
+    def self.gtk_suppress_diagnostics(flags=-1) end
+    
+    # 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
+    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 [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 [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>
+    # @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 nil, 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 [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::EventLoopBase#yield_for for more info.
+    # @param win [Wx::Window] 
+    # @param eventsToProcess [Integer] 
+    # @return [Boolean]
+    def safe_yield_for(win, eventsToProcess) end
+    
+    # Request using either system default or explicitly light or dark theme for the application.
+    # 
+    # Under GTK and macOS applications use the system default appearance by default, and so it is only useful to call this function with either {Wx::App::Appearance::Light} or {Wx::App::Appearance::Dark} parameters if you need to override the default system appearance. The effect of calling this function is immediate, i.e. this function returns {Wx::App::AppearanceResult::Ok}, and affects all the existing windows as well as any windows created after this call.
+    # Under MSW, the default appearance is always light and the applications that want to follow the system appearance need to explicitly call this function with {Wx::App::Appearance::System} parameter in order to do it. Please note using dark appearance under MSW requires using non-documented system functions and has several known limitations, please see {Wx::App#msw_enable_dark_mode} for more details. Also, on this platform the appearance can be only set before any windows are created and calling this function too late will return {Wx::App::AppearanceResult::CannotChange}.
+    # Note that to query the current appearance, you can use {Wx::SystemAppearance}, see {Wx::SystemSettings.get_appearance}.
+    # {Wx::App::AppearanceResult::Ok} if the appearance was successfully changed or had been already set to the requested value, {Wx::App::AppearanceResult::CannotChange} if the appearance can't be changed any more because it's too late to do it but could be changed if done immediately on next program launch (only returned by WXMSW currently) or {Wx::App::AppearanceResult::Failure} if changing the appearance failed for some other reason, e.g. because GTK_THEME is defined when using WXGTK of this function is not implemented at all for the current platform.
+    # @param appearance [Wx::App::Appearance] 
+    # @return [Wx::App::AppearanceResult]
+    def set_appearance(appearance) end
+    alias_method :appearance=, :set_appearance
+    
+    # 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.
+    # @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 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]
+    def set_native_theme(theme) end
+    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 <code>wxApp::SetTopWindow(nil)</code>.
+    # @see Wx::App#get_top_window
+    # @see  Wx::App#on_init 
+    # @param window [Wx::Window]  The new top window.
+    # @return [void]
+    def set_top_window(window) end
+    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.
+    # @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
+    
+    # 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 nil 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] 
+    # @return [Integer]
+    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.
+    # @return [void]
+    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
+    alias_method :has_pending_events?, :has_pending_events
+    
+    # Temporary suspends processing of the pending events.
+    # 
+    # 
+    # @see Wx::App#resume_processing_of_pending_events 
+    # @return [void]
+    def suspend_processing_of_pending_events; end
+    
+    # Resume processing of the pending events previously stopped because of a call to {Wx::App#suspend_processing_of_pending_events}.
+    # @return [void]
+    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
+    # @param func [String]  the name of the function where the assert occurred
+    # @param cond [String]  the condition of the failed assert in text form
+    # @param msg [String]  the message specified as argument to {Wx::ASSERT_MSG} or {Wx::FAIL_MSG}, will be nil if just {Wx::ASSERT} or {Wx::FAIL} was used
+    # @return [void]
+    def on_assert_failure(file, line, func, cond, msg) end
+    
+    # Call {Wx::App#on_unhandled_exception} on the current {Wx::TheApp} object if it exists.
+    # 
+    # This function is used by wxWidgets itself and is usually not meant to be called by the application code. If you do call it, it must be done from a catch clause of a try block, i.e. there must be a currently handled exception.
+    # The function checks if {Wx::TheApp} is not nil and if it is, calls {Wx::App#on_unhandled_exception} on it.
+    # Additionally, if this call results in an exception, it is caught and Wx::AppConsole#on_unhandled_exception is called.
+    # @return [void]
+    def self.call_on_unhandled_exception; 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]
+    def get_app_display_name; end
+    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]
+    def get_app_name; end
+    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]
+    def get_class_name; end
+    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]
+    def get_vendor_display_name; end
+    alias_method :vendor_display_name, :get_vendor_display_name
+    
+    # Returns the application's vendor name.
+    # @return [Wx::String]
+    def get_vendor_name; end
+    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] 
+    # @return [void]
+    def set_app_display_name(name) end
+    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 
+    # @param name [String] 
+    # @return [void]
+    def set_app_name(name) end
+    alias_method :app_name=, :set_app_name
+    
+    # Sets the class name of the application.
+    # 
+    # The class name is used in a platform specific manner. Currently it is used as "Application User Model ID" under Windows (see Microsoft documentation), "app ID" when using WXGTK 3.24.22 or later with Wayland (see Wayland documentation) and is unused under the other platforms.
+    # When it is used, the class name purpose is to allow the system to handle all windows with the same ID as belonging to the same application, e.g. to group them together in the taskbar (so the value set here is used by {Wx::TaskBarJumpList} constructor). By default the application executable name is used as its ID, so it is not necessary to set the class name, but it may be useful to do it to specify a more unique string (typically by using a reverse domain name notation with the domain unique to the application vendor) or by specifying the same ID in different applications that should be handled as a single one at UI level.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Under Windows setting the application user model ID changes some functionality available by default, notably Shift middle clicking the application icon in the taskbar doesn't open a new instance of the application any more and most recently used files list maintained by the shell doesn't work any longer. Application that need to keep this working need to use <code>SHGetPropertyStoreForWindow()</code> and <code>SHAddToRecentDocs()</code> functions to provide the necessary support for it.
+    # </p>
+    # </div>
+    # 
+    # Please note that {Wx::App#set_class_name} must be called as early as possible and definitely before creating any top-level windows to have an effect. Typically it should be called in the constructor of the class derived from {Wx::App}, e.g.
+    # 
+    # ```
+    #   class MyApp : public wxApp
+    #   {
+    #   public:
+    #       MyApp() {
+    #           // Constructor shouldn't perform any non-trivial initialization
+    #           // as the GUI is not available yet, but this function is fine
+    #           // to call.
+    #           SetClassName("com.example.myapp");
+    #       }
+    #   };
+    # ```
+    # @see Wx::App#get_class_name 
+    # @param name [String] 
+    # @return [void]
+    def set_class_name(name) end
+    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]
+    def set_vendor_display_name(name) end
+    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] 
+    # @return [void]
+    def set_vendor_name(name) end
+    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] 
+    # @return [Boolean]
+    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 
+    # ```
+    #   setlocale(LC_ALL, "");
+    # ```
+    #  but performs additional toolkit-specific tasks under some platforms and so should be used instead of <code>setlocale()</code> itself. Alternatively, you can use {Wx::Locale} to change the locale with more control.
+    # Notice that this does not change the global C++ locale, you need to do it explicitly if you want, e.g. 
+    # ```
+    #   std::locale::global(std::locale(""));
+    # ```
+    #  but be warned that locale support in C++ standard library can be poor or worse under some platforms.
+    # @return [void]
+    def set_c_locale; end
+    
+    # Sets the error code to use in case of exit on error.
+    # 
+    # This function is mostly useful to customize the error code returned by the application when it exits due to {Wx::App#on_init} returning false and can be called from {Wx::App#on_init} itself or other virtual functions called from it, for example {Wx::App#on_cmd_line_error}.
+    # By default, the exit code is 255 which indicates a generic error, so it is may be useful to call this function to set a more precise exit code, e.g. 2 which is a de facto standard exit code if command line parsing fails.
+    # Please also note that in the previous versions of wxWidgets this exit code was <code>-1</code>, which corresponds to either 255 or 127 depending on the platform and compiler used, so you may want to call this function with <code>-1</code> argument if you need to preserve compatibility with the old behaviour.
+    # {Wx::App#set_error_exit_code} can be overridden by the application to perform additional actions, but the overridden version should call the base class version to update the value returned by GetErrorExitCode() and actually used when exiting the application.
+    # @see Wx::App#set_fatal_error_exit_code
+    # @param code [Integer] 
+    # @return [void]
+    def set_error_exit_code(code) end
+    alias_method :error_exit_code=, :set_error_exit_code
+    
+    # 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
+    
+    # Allows to set a custom process exit code if a fatal error happens.
+    # 
+    # If the program can't continue due to a fatal error, such as receiving an unhandled exception or failing to initialize the graphical environment for the GUI applications, it terminates with the default fatal error exit code which is 255.
+    # This function can be used to change this default value to something else, e.g. <code>-1</code> which used to be returned in the previous versions of wxWidgets (and corresponds to either 255 or 127 depending on the platform and compiler used) if compatibility is important.
+    # Notice that it has to be called as early as possible to take effect even during the early application initialization, e.g.
+    # 
+    # ```
+    #   struct FatalErrorCodeInitializer {
+    #       FatalErrorCodeInitializer() {
+    #           wxApp::SetFatalErrorExitCode(3); // same as abort()
+    #       }
+    #   };
+    #   
+    #   // Create a global variable to call SetFatalErrorExitCode() in its ctor.
+    #   static FatalErrorCodeInitializer s_fatalErrorCodeInitializer;
+    # ```
+    # 
+    # Note that this function doesn't change the exit code returned if {Wx::App#on_init} returns false, so if you change the default value of this exit code you may want to call {Wx::App#set_error_exit_code} to change the other one too.
+    # @param code [Integer] 
+    # @return [void]
+    def self.set_fatal_error_exit_code(code) end
+    
+  end # App
+  
+
+end