wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

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

@@ -0,0 +1,363 @@
+# :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
+  
+    # 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]
+    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]
+    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]
+    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]
+    def get_use_best_visual; end
+    alias_method :use_best_visual, :get_use_best_visual
+    
+    # Returns a pointer to the top window.
+    # 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.
+    # @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 [true,false]
+    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] 
+    # @param onlyIfNeeded [true,false] 
+    # @return [true,false]
+    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]
+    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.
+    # @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.
+    # @param theme [String]  The name of the new theme or an absolute path to a gtkrc-theme-file
+    # @return [true,false]
+    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 
+    # 
+    #   wxApp::SetTopWindow(NULL) 
+    # .
+    # @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 [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.
+    # @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 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] 
+    # @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 [true,false]
+    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 [true,false]
+    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, may be empty if the compiler doesn't support C99 __FUNCTION__
+    # @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 NULL if just {Wx::ASSERT} or {Wx::FAIL} was used
+    # @return [void]
+    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]
+    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.
+    # This may be used in a platform specific manner to refer to the application.
+    # @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 [true,false] 
+    # @return [true,false]
+    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
+    
+    # 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]
+    def self.is_main_loop_running; end
+    
+  end # App
+  
+
+end