system.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef COMMON_SYSTEM_H
#define COMMON_SYSTEM_H

#include "common/scummsys.h"
#include "common/noncopyable.h"
#include "common/array.h" // For OSystem::getGlobalKeymaps()
#include "common/list.h" // For OSystem::getSupportedFormats()
#include "common/ustr.h"
#include "common/str-array.h" // For OSystem::updateStartSettings()
#include "common/hash-str.h" // For OSystem::updateStartSettings()
#include "common/path.h"
#include "common/log.h"
#include "graphics/pixelformat.h"
#include "graphics/mode.h"
#include "graphics/opengl/context.h"

namespace Audio {
class Mixer;
}

namespace Graphics {
struct Surface;
}

namespace GUI {
class GuiObject;
class OptionsContainerWidget;
}

namespace DLC {
class Store;
}

namespace Common {
class EventManager;
class MutexInternal;
struct Rect;
class SaveFileManager;
class SearchSet;
class String;
#if defined(USE_TASKBAR)
class TaskbarManager;
#endif
#if defined(USE_UPDATES)
class UpdateManager;
#endif
class TextToSpeechManager;
#if defined(USE_SYSDIALOGS)
class DialogManager;
#endif
class TimerManager;
class SeekableReadStream;
class WriteStream;
class HardwareInputSet;
class Keymap;
class KeymapperDefaultBindings;

typedef Array<Keymap *> KeymapArray;
}

class AudioCDManager;
class FilesystemFactory;
class PaletteManager;

struct TimeDate {
    int tm_sec;     
    int tm_min;     
    int tm_hour;    
    int tm_mday;    
    int tm_mon;     
    int tm_year;    
    int tm_wday;    
};

enum CursorMaskValue {
    kCursorMaskTransparent = 0,

    kCursorMaskOpaque = 1,

    kCursorMaskInvert = 2,

    kCursorMaskPaletteXorColorXnor = 3,
};

#if defined(USE_IMGUI)
typedef struct ImGuiCallbacks {
    void (*init)() = nullptr;
    void (*render)() = nullptr;
    void (*cleanup)() = nullptr;
} ImGuiCallbacks;
#endif

class OSystem : Common::NonCopyable {
protected:
    OSystem();
    virtual ~OSystem();

protected:
    AudioCDManager *_audiocdManager;

    Common::EventManager *_eventManager;

    Common::TimerManager *_timerManager;

    Common::SaveFileManager *_savefileManager;

#if defined(USE_TASKBAR)

    Common::TaskbarManager *_taskbarManager;
#endif

#if defined(USE_UPDATES)

    Common::UpdateManager *_updateManager;
#endif

    Common::TextToSpeechManager *_textToSpeechManager;

#if defined(USE_SYSDIALOGS)

    Common::DialogManager *_dialogManager;
#endif

    FilesystemFactory *_fsFactory;

    DLC::Store *_dlcStore;

    Common::U32String _clipboard;

    bool _dummyUnused;
private:
    bool _backendInitialized;


public:

    void destroy();

    virtual void init() {}

    virtual void initBackend();

    bool backendInitialized() const { return _backendInitialized; }

    virtual void engineInit() { }

    virtual void engineDone() { }

    enum Task {
        kLocalServer,

        kCloudDownload,

        kDataPackDownload
    };

    virtual void taskStarted(Task) { }

    virtual void taskFinished(Task) { }

    virtual void updateStartSettings(const Common::String &executable, Common::String &command, Common::StringMap &startSettings, Common::StringArray& additionalArgs);

    enum Feature {
        kFeatureFullscreenMode,

        kFeatureAspectRatioCorrection,

        kFeatureFilteringMode,

        kFeatureStretchMode,

        kFeatureVirtualKeyboard,

        kFeatureCursorPalette,

        kFeatureCursorAlpha,

        kFeatureCursorMask,

        kFeatureCursorMaskInvert,

        kFeatureCursorMaskPaletteXorColorXnor,

        kFeatureOverlaySupportsAlpha,

        kFeatureIconifyWindow,

        kFeatureOpenGLForGame,

        kFeatureShadersForGame,

        kFeatureVSync,

        kFeatureFullscreenToggleKeepsContext,

        kFeatureDisplayLogFile,

        kFeatureClipboardSupport,

        kFeatureOpenUrl,

        kFeatureTouchpadMode,

        kFeatureKbdMouseSpeed,

        kFeatureJoystickDeadzone,

        kFeatureScalers,

        kFeatureShaders,

        kFeatureDLC,

        kFeatureSystemBrowserDialog,

        kFeatureNoQuit,

        kFeatureTouchscreen,

        kFeatureCpuNEON,

        kFeatureCpuSSE2,

        kFeatureCpuSSE41,

        kFeatureCpuAVX2,

        kFeatureCpuAltivec,

        kFeatureRotationMode,
    };

    virtual bool hasFeature(Feature f) { return false; }

    virtual void setFeatureState(Feature f, bool enable) {}

    virtual bool getFeatureState(Feature f) { return false; }

    struct GraphicsMode {
        const char *name;
        const char *description;
        int id;
    };

    virtual const GraphicsMode *getSupportedGraphicsModes() const {
        static const GraphicsMode noGraphicsModes[] = {{"NONE", "Normal", 0}, {nullptr, nullptr, 0 }};
        return noGraphicsModes;
    }

    virtual int getDefaultGraphicsMode() const { return 0; }

    enum GfxModeFlags {
        kGfxModeNoFlags = 0,         
        kGfxModeRender3d = (1 << 0)  
    };

    virtual bool setGraphicsMode(int mode, uint flags = kGfxModeNoFlags) { return (mode == 0); }

    bool setGraphicsMode(const char *name);

    virtual int getGraphicsMode() const { return 0; }

#ifdef USE_RGB_COLOR

    virtual Graphics::PixelFormat getScreenFormat() const = 0;

    virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const = 0;
#else
    inline Graphics::PixelFormat getScreenFormat() const {
        return Graphics::PixelFormat::createFormatCLUT8();
    }

    inline Common::List<Graphics::PixelFormat> getSupportedFormats() const {
        Common::List<Graphics::PixelFormat> list;
        list.push_back(Graphics::PixelFormat::createFormatCLUT8());
        return list;
    }
#endif

    virtual Common::Array<uint> getSupportedAntiAliasingLevels() const {
        return Common::Array<uint>();
    }

    virtual OpenGL::ContextType getOpenGLType() const {
        return OpenGL::kContextNone;
    }

#if defined(USE_OPENGL) && defined(USE_GLAD)

    virtual void *getOpenGLProcAddress(const char *name) const { return nullptr; }
#endif

#if defined(USE_IMGUI)

    virtual void setImGuiCallbacks(const ImGuiCallbacks &callbacks) {}
    virtual void *getImGuiTexture(const Graphics::Surface &image, const byte *palette = nullptr, int palCount = 0) { return nullptr; }
    virtual void freeImGuiTexture(void *texture) {}
#endif

    virtual bool setShader(const Common::Path &fileName) { return false; }

    virtual const GraphicsMode *getSupportedStretchModes() const {
        static const GraphicsMode noStretchModes[] = {{"NONE", "Normal", 0}, {nullptr, nullptr, 0 }};
        return noStretchModes;
    }

    virtual int getDefaultStretchMode() const { return 0; }

    virtual bool setStretchMode(int mode) { return false; }

    bool setStretchMode(const char *name);

    virtual int getStretchMode() const { return 0; }

    virtual uint getDefaultScaler() const { return 0; }

    virtual uint getDefaultScaleFactor() const { return 1; }

    virtual bool setScaler(uint mode, int factor) { return false; }

    virtual bool setScaler(const char *name, int factor) { return false; }

    virtual uint getScaler() const { return 0; }

    virtual uint getScaleFactor() const { return 1; }


    virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format = nullptr) = 0;

    virtual void initSizeHint(const Graphics::ModeList &modes) {}

    virtual int getScreenChangeID() const { return 0; }

    virtual void beginGFXTransaction() {}

    enum TransactionError {
        kTransactionSuccess = 0,                        
        kTransactionAspectRatioFailed = (1 << 0),       
        kTransactionFullscreenFailed = (1 << 1),        
        kTransactionModeSwitchFailed = (1 << 2),        
        kTransactionSizeChangeFailed = (1 << 3),        
        kTransactionFormatNotSupported = (1 << 4),      
        kTransactionFilteringFailed = (1 << 5),         
        kTransactionStretchModeSwitchFailed = (1 << 6), 
        kTransactionShaderChangeFailed = (1 << 7),      
        kTransactionVSyncFailed = (1 << 8),             
    };

    virtual TransactionError endGFXTransaction() { return kTransactionSuccess; }

    virtual int16 getHeight() = 0;

    virtual int16 getWidth() = 0;

    virtual PaletteManager *getPaletteManager() = 0;

    virtual float getHiDPIScreenFactor() const { return 1.0f; }

    virtual void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h) = 0;

    virtual Graphics::Surface *lockScreen() = 0;

    virtual void unlockScreen() = 0;

    virtual void fillScreen(uint32 col) = 0;

    virtual void fillScreen(const Common::Rect &r, uint32 col) = 0;

    virtual void updateScreen() = 0;

    virtual void setShakePos(int shakeXOffset, int shakeYOffset) = 0;

    virtual void setFocusRectangle(const Common::Rect& rect) {}

    virtual void clearFocusRectangle() {}

    virtual void saveScreenshot() {}

    virtual void showOverlay(bool inGUI = true) = 0;

    virtual void hideOverlay() = 0;

    virtual bool isOverlayVisible() const = 0;

    virtual Graphics::PixelFormat getOverlayFormat() const = 0;

    virtual void clearOverlay() = 0;

    virtual void grabOverlay(Graphics::Surface &surface) = 0;

    virtual void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h) = 0;

    virtual int16 getOverlayHeight() = 0;

    virtual int16 getOverlayWidth() = 0;

    virtual bool showMouse(bool visible) = 0;

    virtual bool lockMouse(bool lock) { return false; }

    virtual void warpMouse(int x, int y) = 0;

    virtual void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, bool dontScale = false, const Graphics::PixelFormat *format = nullptr, const byte *mask = nullptr) = 0;

    virtual void setCursorPalette(const byte *colors, uint start, uint num) {}



    virtual uint32 getDoubleClickTime() const { return 0; }

    virtual uint32 getMillis(bool skipRecord = false) = 0;

    virtual void delayMillis(uint msecs) = 0;

    virtual void getTimeAndDate(TimeDate &td, bool skipRecord = false) const = 0;

    virtual Common::TimerManager *getTimerManager();

    inline Common::EventManager *getEventManager() {
        return _eventManager;
    }

    virtual Common::HardwareInputSet *getHardwareInputSet() { return nullptr; }

    virtual Common::KeymapArray getGlobalKeymaps() { return Common::KeymapArray(); }

    virtual Common::KeymapperDefaultBindings *getKeymapperDefaultBindings() { return nullptr; }

    virtual Common::MutexInternal *createMutex() = 0;

    virtual Audio::Mixer *getMixer() = 0;

    inline AudioCDManager *getAudioCDManager() {
        return _audiocdManager;
    }

    virtual void quit() = 0;

    virtual void fatalError();

    virtual void setWindowCaption(const Common::U32String &caption) {}

    virtual void displayMessageOnOSD(const Common::U32String &msg) = 0;

    virtual void displayActivityIconOnOSD(const Graphics::Surface *icon) = 0;
    virtual Common::SaveFileManager *getSavefileManager();

#if defined(USE_TASKBAR)

    virtual Common::TaskbarManager *getTaskbarManager() {
        return _taskbarManager;
    }
#endif

#if defined(USE_UPDATES)

    virtual Common::UpdateManager *getUpdateManager() {
        return _updateManager;
    }
#endif

    virtual Common::TextToSpeechManager *getTextToSpeechManager() {
        return _textToSpeechManager;
    }

#if defined(USE_SYSDIALOGS)

    virtual Common::DialogManager *getDialogManager() {
        return _dialogManager;
    }
#endif

    virtual DLC::Store *getDLCStore() {
        return _dlcStore;
    }

    virtual FilesystemFactory *getFilesystemFactory();
    virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0) {}

    virtual Common::SeekableReadStream *createConfigReadStream();

    virtual Common::WriteStream *createConfigWriteStream();

    virtual Common::Path getDefaultConfigFileName();

    virtual Common::Path getDefaultLogFileName() { return Common::Path(); }

    virtual void registerDefaultSettings(const Common::String &target) const {}

    virtual GUI::OptionsContainerWidget *buildBackendOptionsWidget(GUI::GuiObject *boss, const Common::String &name, const Common::String &target) const { return nullptr; }

     virtual const char * const *buildHelpDialogData() { return nullptr; }

    virtual void applyBackendSettings() {}

    virtual void logMessage(LogMessageType::Type type, const char *message) = 0;

    virtual void messageBox(LogMessageType::Type type, const char *message) {}

    virtual bool displayLogFile() { return false; }

    virtual bool hasTextInClipboard() { return !_clipboard.empty(); }

    virtual Common::U32String getTextFromClipboard() { return _clipboard; }

    virtual bool setTextInClipboard(const Common::U32String &text) { _clipboard = text; return true; }

    virtual bool openUrl(const Common::String &url) {return false; }

    virtual Common::String getSystemLanguage() const;

    virtual bool isConnectionLimited();

};


extern OSystem *g_system;

#endif