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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#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 "graphics/pixelformat.h"
#include "graphics/pixelbuffer.h"
#include "graphics/mode.h"

namespace Audio {
class Mixer;
}

namespace Graphics {
struct Surface;
}

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

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;    
};

namespace LogMessageType {
enum Type {
    kInfo,    
    kError,   
    kWarning, 
    kDebug    
};

} // End of namespace LogMessageType

class OSystem : Common::NonCopyable {
    friend class Common::Encoding;
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

#if defined(USE_TTS)

    Common::TextToSpeechManager *_textToSpeechManager;
#endif

#if defined(USE_SYSDIALOGS)

    Common::DialogManager *_dialogManager;
#endif

    FilesystemFactory *_fsFactory;

    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 Feature {
        kFeatureFullscreenMode,

        kFeatureAspectRatioCorrection,

        kFeatureFilteringMode,

        kFeatureStretchMode,

        kFeatureVirtualKeyboard,

        kFeatureCursorPalette,

        kFeatureOverlaySupportsAlpha,

        kFeatureIconifyWindow,

        kFeatureOpenGLForGame,

        kFeatureVSync,

        kFeatureFullscreenToggleKeepsContext,

        kFeatureDisplayLogFile,

        kFeatureClipboardSupport,

        kFeatureOpenUrl,

        kFeatureOnScreenControl,

        kFeatureTouchpadMode,

        kFeatureSwapMenuAndBackButtons,

        kFeatureKbdMouseSpeed,

        kFeatureJoystickDeadzone,

        kFeatureShader,

        kFeatureSystemBrowserDialog,

        kFeatureNoQuit
    };

    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; }

    virtual void resetGraphicsScale() {}

#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 const GraphicsMode *getSupportedShaders() const {
        static const OSystem::GraphicsMode no_shader[2] = {{"NONE", "Normal (no shader)", 0}, {nullptr, nullptr, 0}};
        return no_shader;
    }

    virtual int getDefaultShader() const { return 0; }

    virtual bool setShader(int id) { return false; }

    bool setShader(const char *name);

    virtual int getShader() const { return 0; }

    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 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)  
    };

    virtual TransactionError endGFXTransaction() { return kTransactionSuccess; }

    virtual int16 getHeight() = 0;

    virtual int16 getWidth() = 0;

    virtual PaletteManager *getPaletteManager() = 0;

    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 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() = 0;

    virtual void hideOverlay() = 0;

    virtual bool isOverlayVisible() const = 0;

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

    virtual void clearOverlay() = 0;

    virtual void grabOverlay(void *buf, int pitch) = 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) = 0;

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

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

    virtual void delayMillis(uint msecs) = 0;

    virtual void getTimeAndDate(TimeDate &t) 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; }

    typedef struct OpaqueMutex *MutexRef;

    virtual MutexRef createMutex() = 0;

    virtual void lockMutex(MutexRef mutex) = 0;

    virtual void unlockMutex(MutexRef mutex) = 0;

    virtual void deleteMutex(MutexRef mutex) = 0;

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

    inline AudioCDManager *getAudioCDManager() {
        return _audiocdManager;
    }

    virtual void quit() = 0;

    virtual void fatalError();

    virtual void setWindowCaption(const char *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

#if defined(USE_TTS)

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

#if defined(USE_SYSDIALOGS)

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

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

    virtual Common::SeekableReadStream *createConfigReadStream();

    virtual Common::WriteStream *createConfigWriteStream();

    virtual Common::String getDefaultConfigFileName();

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

    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();


protected:

    virtual char *convertEncoding(const char *to, const char *from, const char *string, size_t length) { return nullptr; }
};


extern OSystem *g_system;

#endif