X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;ds=sidebyside;f=include%2FMUtils%2FOSSupport.h;h=92bbd851dfb00488598306e2d3e6b08524932245;hb=9c3ab391729c232788cafbaef1878c69e77b4f80;hp=c7f0f848ea2cbee621c05d93fe7b6793027028d7;hpb=b012aa0dbb604a06afc4b3827068bf8b6d9e9735;p=mutilities%2FMUtilities.git diff --git a/include/MUtils/OSSupport.h b/include/MUtils/OSSupport.h index c7f0f84..92bbd85 100644 --- a/include/MUtils/OSSupport.h +++ b/include/MUtils/OSSupport.h @@ -1,6 +1,6 @@ /////////////////////////////////////////////////////////////////////////////// // MuldeR's Utilities for Qt -// Copyright (C) 2004-2014 LoRd_MuldeR +// Copyright (C) 2004-2019 LoRd_MuldeR // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -19,35 +19,286 @@ // http://www.gnu.org/licenses/lgpl-2.1.txt ////////////////////////////////////////////////////////////////////////////////// +/** + * @file + * @brief This file contains function that wrap OS-specific functionality in a platform-independent way + */ + #pragma once +//MUtils +#include + +//Qt #include +#include #include +#include + +//Forward declaration +class QFile; /////////////////////////////////////////////////////////////////////////////// +/** +* \brief Global MUtils namespace +*/ namespace MUtils { + /** + * \brief MUtils OS-specific functions namespace + */ namespace OS { - //Known Folders IDs + /** + * \brief OS version information namespace + */ + namespace Version + { + /** + * \brief This enumeration specifies the type of the underlaying operating system + */ + typedef enum + { + OS_UNKNOWN = 0, ///< Unknown operating system + OS_WINDOWS = 1 ///< Microsoft(R) Windows + } + os_type_t; + + /** + * \brief This struct contains version information about the underlaying operating system. See `_os_version_t` for details! + */ + typedef struct _os_version_t + { + unsigned int type; ///< The type of the underlaying operating system, as `os_type_t` + unsigned int versionMajor; ///< The *major* version of the underlaying operating system + unsigned int versionMinor; ///< The *minor* version of the underlaying operating system + unsigned int versionBuild; ///< The *build* number of the underlaying operating system + unsigned int versionSPack; ///< The *service pack* version of the underlaying operating system + bool overrideFlag; + + MUTILS_API bool operator== (const _os_version_t &rhs) const; + MUTILS_API bool operator!= (const _os_version_t &rhs) const; + MUTILS_API bool operator> (const _os_version_t &rhs) const; + MUTILS_API bool operator>= (const _os_version_t &rhs) const; + MUTILS_API bool operator< (const _os_version_t &rhs) const; + MUTILS_API bool operator<= (const _os_version_t &rhs) const; + } + os_version_t; + + //Known Windows NT versions + MUTILS_API extern const os_version_t WINDOWS_WIN2K; ///< \brief Operating system version constant \details Microsoft(R) Windows 2000 + MUTILS_API extern const os_version_t WINDOWS_WINXP; ///< \brief Operating system version constant \details Microsoft(R) Windows XP + MUTILS_API extern const os_version_t WINDOWS_XPX64; ///< \brief Operating system version constant \details Microsoft(R) Windows XP x64-edition + MUTILS_API extern const os_version_t WINDOWS_VISTA; ///< \brief Operating system version constant \details Microsoft(R) Windows Vista + MUTILS_API extern const os_version_t WINDOWS_WIN70; ///< \brief Operating system version constant \details Microsoft(R) Windows 7 + MUTILS_API extern const os_version_t WINDOWS_WIN80; ///< \brief Operating system version constant \details Microsoft(R) Windows 8 + MUTILS_API extern const os_version_t WINDOWS_WIN81; ///< \brief Operating system version constant \details Microsoft(R) Windows 8.1 + MUTILS_API extern const os_version_t WINDOWS_WN100; ///< \brief Operating system version constant \details Microsoft(R) Windows 10 + + //Unknown OS + MUTILS_API extern const os_version_t UNKNOWN_OPSYS; ///< \brief Operating system version constant \details Unknown operating system version + } + + /** + * \brief This enumeration specifies possible operating system architectures + */ typedef enum { - FOLDER_LOCALAPPDATA = 0, - FOLDER_PROGRAMFILES = 2, - FOLDER_SYSTEMFOLDER = 3, - FOLDER_SYSTROOT_DIR = 4 + ARCH_X86 = 1, ///< Intel x86 or compatible [32-bit] + ARCH_X64 = 2 ///< x86-64, aka AMD64, aka Intel 64 [64-bit] + } + os_arch_t; + + /** + * \brief This enumeration specifies "known" folder identifiers + */ + typedef enum + { + FOLDER_PROFILE_USER = 1, ///< The user's profile folder + FOLDER_PROFILE_PUBL = 2, ///< The "all users" profile folder + FOLDER_APPDATA_ROAM = 3, ///< Application-specific data + FOLDER_APPDATA_LOCA = 4, ///< Local application data (non-roaming) + FOLDER_DOCS_USER = 5, ///< The user's Documents directory + FOLDER_DOCS_PUBL = 6, ///< The "all users" Documents directory + FOLDER_DESKTOP_USER = 7, ///< The user's Desktop directory + FOLDER_DESKTOP_PUBL = 8, ///< The "all users" Desktop directory + FOLDER_PICTURES_USER = 9, ///< The user's Music directory + FOLDER_PICTURES_PUBL = 10, ///< The user's Music directory + FOLDER_MUSIC_USER = 11, ///< The user's Music directory + FOLDER_MUSIC_PUBL = 12, ///< The "all users" Music directory + FOLDER_VIDEO_USER = 13, ///< The user's Video directory + FOLDER_VIDEO_PUBL = 14, ///< The "all users" Video directory + FOLDER_PROGRAMS_DEF = 15, ///< Program files + FOLDER_PROGRAMS_X86 = 16, ///< Program files + FOLDER_PROGRAMS_X64 = 17, ///< Program files + FOLDER_SYSROOT = 18, ///< System "root" directory + FOLDER_SYSTEM_DEF = 19, ///< System directory + FOLDER_SYSTEM_X86 = 20, ///< System directory for x86 (32-Bit) } known_folder_t; + /** + * \brief This enumeration specifies network connection types + */ + typedef enum + { + NETWORK_TYPE_ERR = 0, ///< Network connection is unknown + NETWORK_TYPE_NON = 1, ///< Computer is **not** connected to a network + NETWORK_TYPE_YES = 2 ///< Computer *is* connected to a network + } + network_type_t; + + /** + * \brief This enumeration specifies drive types + */ + typedef enum + { + DRIVE_TYPE_ERR = 0, ///< The drive type cannot be determined + DRIVE_TYPE_FDD = 1, ///< Floppy Drive, or Flash Card reader + DRIVE_TYPE_HDD = 2, ///< Hard Disk drive or Solid-State Drive + DRIVE_TYPE_NET = 3, ///< Remote/Network drive + DRIVE_TYPE_OPT = 4, ///< Optical disk srive, e.g. CD or DVD + DRIVE_TYPE_RAM = 5 ///< RAM disk + } + drive_type_t; + + //System message + MUTILS_API void system_message_nfo(const wchar_t *const title, const wchar_t *const text); + MUTILS_API void system_message_wrn(const wchar_t *const title, const wchar_t *const text); + MUTILS_API void system_message_err(const wchar_t *const title, const wchar_t *const text); + + //CLI Arguments + typedef QMap ArgumentMap; + MUTILS_API const QStringList crack_command_line(const QString &command_line = QString()); + MUTILS_API const ArgumentMap &arguments(void); + + //Copy file + typedef bool (*progress_callback_t)(const double &progress, void *const userData); + MUTILS_API bool copy_file(const QString &sourcePath, const QString &outputPath, const bool &overwrite = true, const progress_callback_t callback = NULL, void *const userData = NULL); + + //Get file version + MUTILS_API bool get_file_version(const QString fileName, quint16 *const major = NULL, quint16 *const minor = NULL, quint16 *const patch = NULL, quint16 *const build = NULL); + + //Get the OS version + MUTILS_API const Version::os_version_t &os_version(void); + MUTILS_API const char *os_friendly_name(const MUtils::OS::Version::os_version_t &os_version); + MUTILS_API const bool &running_on_wine(void); + MUTILS_API const os_arch_t &os_architecture(void); + //Get known Folder - const QString &known_folder(known_folder_t folder_id); + MUTILS_API const QString &known_folder(const known_folder_t folder_id); + + //Current Date & Time + MUTILS_API QDate current_date(void); + MUTILS_API quint64 current_file_time(void); + + //Check for process elevation + MUTILS_API bool is_elevated(bool *bIsUacEnabled = NULL); + MUTILS_API bool user_is_admin(void); + + /** + * \brief Check the network status + * + * Checks whether the computer is *currently* connected to a network. Note that an existing network connection does **not** necessarily imply actual Internet access! + * + * \return The function returns the current network status as a `OS::network_type_t` value. + */ + MUTILS_API int network_status(void); + + //Message handler + MUTILS_API bool handle_os_message(const void *const message, long *result); + + /** + * \brief Suspend calling thread + * + * This function suspends the calling thread. The thread will give up its current time-slice and enter "sleeping" state. The thread will remain in "sleeping" for the specified duration. After the specified duration has elapsed, the thread will be resumed. + * + * Note that it depends on the operating system's scheduling decisions, when the thread will actually be allowed to execute again! While the thread is still in "sleeping" state, it can **not** be selected for execution by the operating system's scheduler. Once the thread is *no* longer in "sleeping" state, i.e. the specified period has elapsed, the thread *can* be selected for execution by the operating system's scheduler again - but this does **not** need to happen *immediately*! The scheduler decides which thread is allowed to execute next, taking into consideration thread priorities. + * + * \param duration The amount of time that the thread will be suspended, in milliseconds. A value of **0** means that the thread will *not* actually enter "sleeping" state, but it will still give up its current time-slice! + */ + MUTILS_API void sleep_ms(const size_t &duration); + + //Is executable/library file? + MUTILS_API bool is_executable_file(const QString &path); + MUTILS_API bool is_library_file(const QString &path); + + //Shutdown & Hibernation + MUTILS_API bool is_hibernation_supported(void); + MUTILS_API bool shutdown_computer(const QString &message, const unsigned long timeout, const bool forceShutdown, const bool hibernate); + + //Free diskspace + MUTILS_API bool free_diskspace(const QString &path, quint64 &freeSpace); + + /** + * \brief Detect drive type + * + * This function detetcs the type of the drive to which the given path is pointing. + * + * \param path The path to the drive whose type is to be detected. On the Windows platform, only the drive letter is relevant. + * + * \param fast_seeking Pointer to a variable that will be set to TRUE, if the drive supports "fast" seeking (e.g. SSD or similar device), or to FALSE otherwise. This parameter is optional and may be NULL. + * + * \return The function returns the type of the drive as a `OS::drive_type_t` value. In case of error, the value `DRIVE_TYPE_ERR` will be returned. + */ + MUTILS_API drive_type_t get_drive_type(const QString &path, bool *fast_seeking = NULL); + + //Shell open + MUTILS_API bool shell_open(const QWidget *parent, const QString &url, const bool explore = false); + MUTILS_API bool shell_open(const QWidget *parent, const QString &url, const QString ¶meters, const QString &directory, const bool explore = false); + + //Open media file + MUTILS_API bool open_media_file(const QString &mediaFilePath); + + //Process priority + MUTILS_API bool change_process_priority(const int priority); + MUTILS_API bool change_process_priority(const QProcess *proc, const int priority); + + //Process ID + MUTILS_API quint32 process_id(void); + MUTILS_API quint32 process_id(const QProcess *const proc); + + //Thread ID + MUTILS_API quint32 thread_id(void); + MUTILS_API quint32 thread_id(const QProcess *const proc); + + //Suspend or resume processv + MUTILS_API bool suspend_process(const QProcess *proc, const bool suspend); + + //System timer resolution + MUTILS_API bool setup_timer_resolution(const quint32 &interval = 1); + MUTILS_API bool reset_timer_resolution(const quint32 &interval = 1); + + //Set file time + MUTILS_API bool set_file_time(const QFile &file, const QDateTime &created = QDateTime(), const QDateTime &modified = QDateTime(), const QDateTime &accessed = QDateTime()); + MUTILS_API bool set_file_time(const QString &path, const QDateTime &created = QDateTime(), const QDateTime &modified = QDateTime(), const QDateTime &accessed = QDateTime()); + + //Keyboard support + MUTILS_API bool check_key_state_esc(void); + + //Shell notification + MUTILS_API void shell_change_notification(void); + + //Get file path from descriptor + MUTILS_API QString get_file_path(const int &fd); + + //WOW64 redirection + MUTILS_API bool wow64fsredir_disable(uintptr_t &oldValue); + MUTILS_API bool wow64fsredir_revert (const uintptr_t oldValue); + + //Environment variables + MUTILS_API QString get_envvar(const QString &name); + MUTILS_API bool set_envvar(const QString &name, const QString &value); + + //NULL device + MUTILS_API const QLatin1String &null_device(void); - //Current Date - QDate current_date(void); + //Check if debugger is present + MUTILS_API void check_debugger(void); //Error handling - void fatal_exit(const char* const errorMessage); + MUTILS_API void fatal_exit(const wchar_t* const errorMessage); } }