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 "common/frac.h"
#include "graphics/pixelformat.h"
#include "graphics/mode.h"
#include "graphics/opengl/context.h"
 
namespace Audio {
class Mixer;
}
 
namespace Graphics {
class CursorManager;
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 PrintingManager;
class TimerManager;
class SeekableReadStream;
class WriteStream;
class HardwareInputSet;
class Keymap;
class KeymapperDefaultBindings;
 
enum RotationMode : int;
 
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 {
    friend class Graphics::CursorManager;
 
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;
 
    Common::PrintingManager *_printingManager;
 
    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,
 
        kFeatureDisplayLogFile,
 
        kFeatureClipboardSupport,
 
        kFeatureOpenUrl,
 
        kFeatureTouchpadMode,
 
        kFeatureKbdMouseSpeed,
 
        kFeatureJoystickDeadzone,
 
        kFeatureScalers,
 
        kFeatureShaders,
 
        kFeatureDLC,
 
        kFeatureSystemBrowserDialog,
 
        kFeatureNoQuit,
 
        kFeatureTouchscreen,
 
        kFeatureCpuNEON,
 
        kFeatureCpuSSE2,
 
        kFeatureCpuSSE41,
 
        kFeatureCpuAVX2,
 
        kFeatureCpuAltivec,
 
        kFeatureRotationMode,
 
        kFeatureStaleMousePositionWorkaround,
    };
 
    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 bool setRotationMode(Common::RotationMode rotation) { return false; }
 
    bool setRotationMode(int rotation);
 
    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 presentBuffer() {}
 
    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() const = 0;
 
    virtual int16 getOverlayWidth() const = 0;
 
    virtual Common::Rect getSafeOverlayArea(int16 *width = nullptr, int16 *height = nullptr) const;
 
protected:
    virtual bool showMouse(bool visible) = 0;
 
    virtual void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, const Graphics::PixelFormat *format, const byte *mask, frac_t scaleX, frac_t scaleY) = 0;
 
    virtual void setCursorPalette(const byte *colors, uint start, uint num) {}
 
public:
    virtual bool lockMouse(bool lock) { return false; }
 
    virtual void warpMouse(int x, int y) = 0;
 
    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;
    }
 
    virtual Common::PrintingManager *getPrintingManager() {
        return _printingManager;
    }
 
#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);
 
    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