# :stopdoc:
# This file is automatically generated by the WXRuby3 documentation 
# generator. Do not alter this file.
# :startdoc:


module Wx

  # Changes the cursor to the given cursor for all windows in the application.
  # Use {end_busy_cursor} to revert the cursor back to its previous state. These two calls can be nested, and a counter ensures that only the outer calls take effect.
  # @see is_busy
  # @see  Wx::BusyCursor
  # @param cursor [Wx::Cursor] 
  # @return [void]
  def self.begin_busy_cursor(cursor=Wx::HOURGLASS_CURSOR) end
  
  # Changes the cursor back to the original cursor, for all windows in the application.
  # Use with {begin_busy_cursor}.
  # @see is_busy
  # @see  Wx::BusyCursor
  # @return [void]
  def self.end_busy_cursor; end
  
  # Returns true if between two {begin_busy_cursor} and {end_busy_cursor} calls.
  # 
  # @see Wx::BusyCursor.
  # @return [Boolean]
  def self.is_busy; end
  
  # Ring the system bell.
  # This function is categorized as a GUI one and so is not thread-safe.
  # 
  # ===
  # @return [void]
  def self.bell; end
  
  # Shows a message box with the information about the wxWidgets build used, including its version, most important build parameters and the version of the underlying GUI toolkit.
  # This is mainly used for diagnostic purposes and can be invoked by Ctrl-Alt-middle clicking on any {Wx::Window} which doesn't otherwise handle this event.
  # @see get_library_version_info
  # @param parent [Wx::Window] 
  # @return [void]
  def self.info_message_box(parent) end
  
  # Get wxWidgets version information.
  # ===
  # @see Wx::VersionInfo
  # @return [Wx::VersionInfo]
  def self.get_library_version_info; end
  
  # For normal keys, returns true if the specified key is currently down.
  # For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns true if the key is toggled such that its LED indicator is lit. There is currently no way to test whether togglable keys are up or down.
  # Even though there are virtual key codes defined for mouse buttons, they cannot be used with this function currently.
  # In wxGTK, this function can be only used with modifier keys ({Wx::KeyCode::K_ALT}, {Wx::KeyCode::K_CONTROL} and {Wx::KeyCode::K_SHIFT}) when not using X11 backend currently.
  # @param key [Wx::KeyCode] 
  # @return [Boolean]
  def self.get_key_state(key) end
  
  # Returns the mouse position in screen coordinates.
  # @return [Wx::Point]
  def self.get_mouse_position; end
  
  # Returns the current state of the mouse.
  # Returns a {Wx::MouseState} instance that contains the current position of the mouse pointer in screen coordinates, as well as boolean values indicating the up/down status of the mouse buttons and the modifier keys.
  # @return [Wx::MouseState]
  def self.get_mouse_state; end
  
  # This function enables or disables all top level windows.
  # It is used by {safe_yield}.
  # @param enable [Boolean] 
  # @return [void]
  def self.enable_top_level_windows(enable=true) end
  
  # Find the deepest window at the given mouse position in screen coordinates, returning the window if found, or NULL if not.
  # This function takes child windows at the given position into account even if they are disabled. The hidden children are however skipped by it.
  # @param pt [Array(Integer, Integer), Wx::Point] 
  # @return [Wx::Window]
  def self.find_window_at_point(pt) end
  
  # Find a menu item identifier associated with the given frame's menu bar.
  # @param frame [Wx::Frame] 
  # @param menuString [String] 
  # @param itemString [String] 
  # @return [Integer]
  def self.find_menu_item_id(frame, menuString, itemString) end
  
  # Ensures that Ids subsequently generated by {new_id} do not clash with the given id.
  # @param id [Integer] 
  # @return [void]
  def self.register_id(id) end
  
  # Opens the document in the application associated with the files of this type.
  # The flags parameter is currently not used
  # Returns true if the application was successfully launched.
  # @see launch_default_browser
  # @see  execute
  # @param document [String] 
  # @param flags [Integer] 
  # @return [Boolean]
  def self.launch_default_application(document, flags=0) end
  
  # Opens the url in user's default browser.
  # If the flags parameter contains {Wx::BROWSER_NEW_WINDOW} flag, a new window is opened for the URL (currently this is only supported under Windows).
  # And unless the flags parameter contains {Wx::BROWSER_NOBUSYCURSOR} flag, a busy cursor is shown while the browser is being launched (using {Wx::BusyCursor}).
  # The parameter url is interpreted as follows:
  # 
  # - if it has a valid scheme (e.g. <code>"file:"</code>, <code>"http:"</code> or <code>"mailto:"</code>) it is passed to the appropriate browser configured in the user system.
  # - if it has no valid scheme (e.g. it's a local file path without the <code>"file:"</code> prefix), then {Wx::FileExists} and {Wx::DirExists} are used to test if it's a local file/directory; if it is, then the browser is called with the url parameter eventually prefixed by <code>"file:"</code>.
  # - if it has no valid scheme and it's not a local file/directory, then <code>"http:"</code> is prepended and the browser is called.
  # 
  # Returns true if the application was successfully launched.
  # For some configurations of the running user, the application which is launched to open the given URL may be URL-dependent (e.g. a browser may be used for local URLs while another one may be used for remote URLs).
  # @see launch_default_application
  # @see  execute
  # @param url [String] 
  # @param flags [Integer] 
  # @return [Boolean]
  def self.launch_default_browser(url, flags=0) end
  
  # Copies the user's email address into the supplied buffer, by concatenating the values returned by {get_full_host_name} and {get_user_id}.
  # true if successful, false otherwise.
  # @return [String]
  def self.get_email_address; end
  
  # Returns the amount of free memory in bytes under environments which support it, and -1 if not supported or failed to perform measurement.
  # @return [Integer]
  def self.get_free_memory; end
  
  # Return the (current) user's home directory.
  # 
  # @see get_user_home
  # @see  Wx::StandardPaths
  # @return [String]
  def self.get_home_dir; end
  
  # Copies the current host machine's name into the supplied buffer.
  # Please note that the returned name is not fully qualified, i.e. it does not include the domain name.
  # The hostname if successful or an empty string otherwise.
  # @see get_full_host_name
  # @return [String]
  def self.get_host_name; end
  
  # Returns the FQDN (fully qualified domain host name) or an empty string on error.
  # 
  # @see get_host_name
  # @return [String]
  def self.get_full_host_name; end
  
  # Returns the home directory for the given user.
  # If the user is empty (default value), this function behaves like {get_home_dir} (i.e. returns the current user home directory).
  # If the home directory couldn't be determined, an empty string is returned.
  # @param user [String] 
  # @return [String]
  def self.get_user_home(user=('')) end
  
  # This function returns the "user id" also known as "login name" under Unix (i.e.
  # something like "jsmith"). It uniquely identifies the current user (on this system). Under Windows or NT, this function first looks in the environment variables USER and LOGNAME; if neither of these is found, the entry <b>UserId</b> in the <b>wxWidgets</b> section of the WIN.INI file is tried.
  # The login name if successful or an empty string otherwise.
  # @see get_user_name
  # @return [String]
  def self.get_user_id; end
  
  # This function returns the full user name (something like "Mr. John Smith").
  # Under Windows or NT, this function looks for the entry UserName in the wxWidgets section of the WIN.INI file. If PenWindows is running, the entry Current in the section User of the PENWIN.INI file is used.
  # The full user name if successful or an empty string otherwise.
  # @see get_user_id
  # @return [String]
  def self.get_user_name; end
  
  # Returns the string containing the description of the current platform in a user-readable form.
  # For example, this function may return strings like "Windows 10 (build 10240), 64-bit edition" or "Linux 4.1.4 i386".
  # @see get_os_version
  # @return [String]
  def self.get_os_description; end
  
  # Returns true if the version of the operating system on which the program is running under is the same or later than the given version.
  # 
  # @see get_os_version
  # @see  Wx::PlatformInfo
  # @param majorVsn [Integer] 
  # @param minorVsn [Integer] 
  # @param microVsn [Integer] 
  # @return [Boolean]
  def self.check_os_version(majorVsn, minorVsn=0, microVsn=0) end
  
  # Returns true if the operating system the program is running under is 64 bit.
  # The check is performed at run-time and may differ from the value available at compile-time (at compile-time you can just check if <code>sizeof(void*) == 8</code>) since the program could be running in emulation mode or in a mixed 32/64 bit system.
  # This function is not 100% reliable on some systems given the fact that there isn't always a standard way to do a reliable check on the OS bitness.
  # @return [Boolean]
  def self.is_platform64bit; end
  
  # Returns true if the current platform is little endian (instead of big endian).
  # The check is performed at run-time.
  # @see Byte Order Functions and Macros
  # @return [Boolean]
  def self.is_platform_little_endian; end
  
  # Returns the CPU architecture name.
  # This can be, for example, "x86_64", "arm64", or "i86pc". The name for the same CPU running on the same hardware can vary across operating systems.
  # The returned string may be empty if the CPU architecture couldn't be recognized.
  # @see get_native_cpu_architecture_name
  # @return [String]
  def self.get_cpu_architecture_name; end
  
  # In some situations the current process and native CPU architecture may be different.
  # This returns the native CPU architecture regardless of the current process CPU architecture.
  # Common examples for CPU architecture differences are the following:
  # 
  # - Win32 process in x64 Windows (WoW)
  # - Win32 or x64 process on ARM64 Windows (WoW64)
  # - x86_64 process on ARM64 macOS (Rosetta 2)
  # 
  # The returned string may be empty if the CPU architecture couldn't be recognized.
  # @see get_cpu_architecture_name
  # @return [String]
  def self.get_native_cpu_architecture_name; end
  
  # This function shuts down or reboots the computer depending on the value of the flags.
  # Note that performing the shutdown requires the corresponding access rights (superuser under Unix, SE_SHUTDOWN privilege under Windows) and that this function is only implemented under Unix and MSW.
  # 
  # true on success, false if an error occurred.
  # @param flags [Integer]  One of {Wx::SHUTDOWN_POWEROFF}, {Wx::SHUTDOWN_REBOOT} or {Wx::SHUTDOWN_LOGOFF} (currently implemented only for MSW) possibly combined with {Wx::SHUTDOWN_FORCE} which forces shutdown under MSW by forcefully terminating all the applications. As doing this can result in a data loss, this flag shouldn't be used unless really necessary.
  # @return [Boolean]
  def self.shutdown(flags=Wx::SHUTDOWN_POWEROFF) end
  

end