ApplicationResource.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: ApplicationResource
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/ApplicationOptions.h>
#include <NDEVR/Resource.h>
#include <NDEVR/PasswordString.h>
#include <NDEVR/Time.h>
namespace NDEVR
{
    class File;
    class InfoPipe;
    class RGBColor;
    class INIFactory;
    class Font;
    class UUID;

    class OSInformation
    {
    public:
        enum OSVersion
        {
            e_unknown
            //GENERIC
            , e_windows_generic
            , e_linux_generic
            , e_macOS_generic
            , e_ios_generic
            , e_android_generic
            //WINDOWS
            , e_windows_11
            , e_windows_10
            , e_windows_8
            , e_windows_7
            , e_windows_vista
            , e_windows_server_2012
            , e_windows_server_2008
            , e_windows_xp
        };
        OSVersion os_version = OSVersion::e_unknown; 
        String os_version_name; 
        String os_service_pack_name; 
        uint04 os_version_num = Constant<uint04>::Invalid; 
        uint04 os_sub_version_num = Constant<uint04>::Invalid; 
        uint04 os_revision_num = Constant<uint04>::Invalid; 
    };

    class VideoCardInformation
    {
    public:
        enum VideoCardType
        {
              e_unknown
            //GENERIC
            , e_intel_generic
            , e_nvidia_generic
            , e_amd_generic
            //NVIDIA
            , e_nvidia_geforce
            , e_nvidia_quadpro
            , e_nvidia_titan
            //AMD
        };
 
        String config_manager_string; 
        String architecture_name; 
        String device_name; 
        String device_id; 
        String driver_version; 
        String video_processor; 
        String video_mode_description; 
        String adapter_dac_type; 
        VideoCardType card_type = VideoCardType::e_unknown; 
        uint04 config_manager_code = Constant<uint04>::Invalid; 
        uint04 video_memory = Constant<uint04>::Invalid; 
        uint04 architecture_id = Constant<uint04>::Invalid; 
    };

    class HardwareInformation
    {
    public:
        String manufacturer; 
        String model; 
 
        uint04 oem_id = Constant<uint04>::Invalid; 
        uint04 num_of_processors = Constant<uint04>::Invalid; 
        uint04 page_size = Constant<uint04>::Invalid; 
        uint04 processor_type = Constant<uint04>::Invalid; 
        uint04 active_processor_mask = Constant<uint04>::Invalid; 
 
        uint08 memory_size = Constant<uint08>::Invalid; 
 
        Buffer<VideoCardInformation> video_card_information; 
        bool is_valid = false; 
    };

    class NDEVR_BASE_API ApplicationResource
    {
    public:
        enum class InstanceType
        {
              e_system
            , e_desktop
            , e_session
            , e_trustee
        };

        enum class ReleaseType
        {
              e_alpha = 0
            , e_beta = 1
            , e_release = 2
            , e_lts_release = 3
            , e_size
        };

        enum UIMode
        {
              e_no_ui
            , e_window_manager
            , e_3D_window_manager
        };
        static Resource<TranslatedString> application_name; 
        static Resource<String> application_version; 
        static Resource<String> username; 
        static Resource<PasswordString> password; 
        static Resource<String> user_email; 
        static Resource<String> activation_code; 
        static Resource<Buffer<String>> startup_options; 
        static ApplicationOption<String> last_application_version; 
        static ApplicationOption<Time> current_run_time; 
        static Resource<ReleaseType> release_type; 
        static ApplicationOption<bool> proper_shutdown; 
        static ApplicationOption<bool> has_finished_initial_setup; 
        static Resource<UIMode> ui_mode;//Must be set before setupUI ///< The active user interface mode.
        static bool last_proper_shutdown; 
        static Time last_run_time; 
    public:
        static bool GlobalLock(StringView guid, InstanceType kind = InstanceType::e_system);
        static TranslatedString ApplicationNameAndVersion();
        static UUID SessionID();
        static Time BuildTime();
        static String AppContextName(bool lower_case);
        static Time SessionStartTime();
        static Buffer<uint01> GetAppBundledResource(void* handle, const StringView& type, const StringView& name);
        static String OSUserName();
        static bool IsFirstTimeRunning();

        static String MakeSafeForCommandLine(StringView var);

        static String ApplicationDisplayName();
        static bool SetupAsConsole(bool is_console);
        static File GetDefaultOSApplicationForExtension(const StringView& extension);
        static void OpenExplorerWindow(const StringView& location);
        static void OpenFile(const File& file);
        static void SendFile(const File& file);
        static void ShareFileWithMediaServer(const File& file);
        static void SetFolderIcon(const File& folder, const File& icon);
        static void OpenOSWifiDialog();
        static bool IsOSLanguageInstalled(String language);
        static void OpenOSLanguageDialog();
        static void OpenOSBluetoothDialog();
        static void OpenOSClockDialog();
        static void OpenOSLocationDialog();
        static void OpenOSPrinterDialog();
        static void OpenOSFileSystemDialog();
        static void LogApplicationInformation(LogPtr log);
        static void LogComputerInformation(LogPtr log);
        static void LogOSInformation(LogPtr log);
        static void LogUserSettings(LogPtr log, bool log_only_non_defaults);
        static void CloseApp(bool relaunch = false, const StringView& relaunch_options = "--relaunch");
        static void FactoryResetApp();
        static void SaveUserOptions(bool is_shutting_down);
        static void ReadUserOptions();
        static uint04 RecommendedThreadCount();
        static TranslatedString GetLastErrorString();
        static Buffer<VideoCardInformation> GetVideoCardInfo();
        static OSInformation GetOSInformation();
        static HardwareInformation GetHardwareInformation();
        static TranslatedString GetErrorString(sint08 result);
    };
    template class NDEVR_BASE_API StringStream<ApplicationResource::ReleaseType>;
};