userinterface.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 STARK_SERVICES_USER_INTERFACE_H
#define STARK_SERVICES_USER_INTERFACE_H

#include "engines/stark/stark.h"
#include "engines/stark/ui/screen.h"

#include "engines/stark/services/gamemessage.h"

#include "engines/engine.h"

#include "common/keyboard.h"
#include "common/rect.h"
#include "common/str-array.h"
#include "common/stack.h"

namespace Common {
class SeekableReadStream;
class WriteStream;
}

namespace Graphics {
struct Surface;
}

namespace Stark {

namespace Gfx {
class Driver;
}

class DialogBox;
class DiaryIndexScreen;
class GameScreen;
class MainMenuScreen;
class SettingsMenuScreen;
class SaveMenuScreen;
class LoadMenuScreen;
class FMVMenuScreen;
class DiaryPagesScreen;
class DialogScreen;
class Cursor;
class FMVScreen;

enum {
    kThumbnailWidth = 160,
    kThumbnailHeight = 92,
    kThumbnailSize = kThumbnailWidth * kThumbnailHeight * 4
};

class UserInterface {
public:
    explicit UserInterface(StarkEngine *vm, Gfx::Driver *gfx);
    virtual ~UserInterface();

    void init();

    void onGameLoop();

    void render();
    void handleMouseMove(const Common::Point &pos);
    void handleMouseUp();
    void handleClick();
    void handleRightClick();
    void handleDoubleClick();
    void handleEscape();
    void notifyShouldExit() { _exitGame = true; }
    void inventoryOpen(bool open);
    bool shouldExit() { return _exitGame; }

    void requestFMVPlayback(const Common::Path &name);

    void onFMVStopped();

    bool skipFMV();

    void changeScreen(Screen::Name screenName);

    void backPrevScreen();

    void doQueuedScreenChange();

    void requestQuitToMainMenu() { _quitToMainMenu = true; }

    void restoreScreenHistory();

    bool isInGameScreen() const;

    bool isInSaveLoadMenuScreen() const;

    bool isInDiaryIndexScreen() const;

    bool isInventoryOpen() const;

    bool isInteractive() const;

    void setInteractive(bool interactive);

    void notifyInventoryItemEnabled(uint16 itemIndex);

    void notifyDiaryEntryEnabled();

    int16 getSelectedInventoryItem() const;
    void selectInventoryItem(int16 itemIndex);

    void clearLocationDependentState();

    void optionsOpen();

    void markInteractionDenied();

    bool wasInteractionDenied() const;

    void onScreenChanged();

    void saveGameScreenThumbnail();

    void freeGameScreenThumbnail();

    const Graphics::Surface *getGameWindowThumbnail() const;

    template<class T>
    void confirm(const Common::String &message, T *instance, void (T::*confirmCallBack)());
    template<class T>
    void confirm(GameMessage::TextKey key, T *instance, void (T::*confirmCallBack)());
    void confirm(const Common::String &message, Common::Functor0<void> *confirmCallBack);
    void confirm(GameMessage::TextKey key, Common::Functor0<void> *confirmCallBack);

    void toggleScreen(Screen::Name screenName);

    bool hasToggleSubtitleRequest() { return _shouldToggleSubtitle; }
    void performToggleSubtitle();

    void handleActions(Common::CustomEventType customType);
    void handleKeyPress(const Common::KeyState &keyState);

private:
    Screen *getScreenByName(Screen::Name screenName) const;

    void cycleInventory(bool forward);

    StarkEngine *_vm;
    GameScreen *_gameScreen;
    FMVScreen *_fmvScreen;
    DiaryIndexScreen *_diaryIndexScreen;
    MainMenuScreen *_mainMenuScreen;
    SettingsMenuScreen *_settingsMenuScreen;
    SaveMenuScreen *_saveMenuScreen;
    LoadMenuScreen *_loadMenuScreen;
    FMVMenuScreen *_fmvMenuScreen;
    DiaryPagesScreen *_diaryPagesScreen;
    DialogScreen *_dialogScreen;
    Screen *_currentScreen;
    Common::Stack<Screen::Name> _prevScreenNameStack;

    DialogBox *_modalDialog;
    Cursor *_cursor;

    Gfx::Driver *_gfx;
    bool _exitGame;
    bool _quitToMainMenu;
    PauseToken _gamePauseToken;

    bool _interactive;
    bool _interactionAttemptDenied;

    bool _shouldToggleSubtitle;

    // TODO: Generalize to all screen changes
    bool _shouldGoBackToPreviousScreen;
    Common::Path _shouldPlayFmv;

    Graphics::Surface *_gameWindowThumbnail;
};

template<class T>
void UserInterface::confirm(GameMessage::TextKey key, T *instance, void (T::*confirmCallBack)()) {
    confirm(key, new Common::Functor0Mem<void, T>(instance, confirmCallBack));
}

template<class T>
void UserInterface::confirm(const Common::String &message, T *instance, void (T::*confirmCallBack)()) {
    confirm(message, new Common::Functor0Mem<void, T>(instance, confirmCallBack));
}

} // End of namespace Stark

#endif // STARK_SERVICES_USER_INTERFACE_H