menumodule.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 NEVERHOOD_MENUMODULE_H
#define NEVERHOOD_MENUMODULE_H

#include "common/str.h"
#include "common/str-array.h"
#include "neverhood/neverhood.h"
#include "neverhood/module.h"
#include "neverhood/scene.h"

namespace Neverhood {

struct SavegameItem {
    int slotNum;
    Common::String description;
};

typedef Common::Array<SavegameItem> SavegameList;

class MenuModule : public Module {
public:
    MenuModule(NeverhoodEngine *vm, Module *parentModule, int which);
    ~MenuModule() override;
    void setLoadgameInfo(uint index);
    void setLoadgameSlot(int slot);
    void setSavegameInfo(const Common::String &description, uint index, bool newSavegame);
    void setDeletegameInfo(uint index);
    void refreshSaveGameList();
protected:
    int _sceneNum;
    byte *_savedPaletteData;
    SavegameList *_savegameList;
    Common::String _savegameDescription;
    int _savegameSlot;
    void createScene(int sceneNum, int which);
    void updateScene();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
    void createLoadGameMenu();
    void createSaveGameMenu();
    void createDeleteGameMenu();
    void handleLoadGameMenuAction(bool doLoad);
    void handleSaveGameMenuAction(bool doSave, bool doQuery);
    void handleDeleteGameMenuAction(bool doDelete);
    void loadSavegameList();
};

class MenuButton : public StaticSprite {
public:
    MenuButton(NeverhoodEngine *vm, Scene *parentScene, uint buttonIndex, uint32 fileHash, const NRect &collisionBounds);
protected:
    Scene *_parentScene;
    int _countdown;
    uint _buttonIndex;
    void update();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
};

class MainMenu : public Scene {
public:
    MainMenu(NeverhoodEngine *vm, Module *parentModule);
    bool hasMakingOf() const;
protected:
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
};

class CreditsScene : public Scene {
public:
    CreditsScene(NeverhoodEngine *vm, Module *parentModule, bool canAbort);
    ~CreditsScene() override;
protected:
    int _screenIndex;
    int _countdown;
    MusicResource *_musicResource;
    uint32 _ticksTime;
    uint32 _ticksDuration;
    bool _canAbort;
    void update();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
};

class Widget;
class GameStateMenu;

class Widget : public StaticSprite {
public:
    Widget(NeverhoodEngine *vm, int16 x, int16 y, GameStateMenu *parentScene,
        int baseObjectPriority, int baseSurfacePriority);
    virtual void onClick();
    virtual void setPosition(int16 x, int16 y);
    virtual void refreshPosition();
    virtual void initialize();
    virtual int16 getWidth();
    virtual int16 getHeight();
    virtual void enterWidget();
    virtual void exitWidget();
protected:
    GameStateMenu *_parentScene;
    int _baseObjectPriority;
    int _baseSurfacePriority;
    void update();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
};

class TextLabelWidget : public Widget {
public:
    TextLabelWidget(NeverhoodEngine *vm, int16 x, int16 y, GameStateMenu *parentScene,
            int baseObjectPriority, int baseSurfacePriority,
            const byte *string, int stringLen, const Common::SharedPtr<BaseSurface> &drawSurface, int16 tx, int16 ty, const Common::SharedPtr<FontSurface> &fontSurface);
    void initialize() override;
    int16 getWidth() override;
    int16 getHeight() override;
    void drawString(int maxStringLength);
    void clear();
    void setString(const byte *string, int stringLen);
    Common::SharedPtr<FontSurface> getFontSurface() const { return _fontSurface; }
protected:
    Common::SharedPtr<BaseSurface> _drawSurface;
    int16 _tx, _ty;
    Common::SharedPtr<FontSurface> _fontSurface;
    const byte *_string;
    int _stringLen;
};

class TextEditWidget : public Widget {
public:
    TextEditWidget(NeverhoodEngine *vm, int16 x, int16 y, GameStateMenu *parentScene,
        int maxStringLength, const Common::SharedPtr<FontSurface> &fontSurface, uint32 fileHash, const NRect &rect);
    ~TextEditWidget() override;
    void onClick() override;
    void initialize() override;
    void enterWidget() override;
    void exitWidget() override;
    void setCursor(uint32 cursorFileHash, int16 cursorWidth, int16 cursorHeight);
    void drawCursor();
    void updateString();
    Common::String& getString();
    void setString(const Common::String &string);
    void handleAsciiKey(char ch);
    void handleKeyDown(Common::KeyCode keyCode);
    void refresh();
    void setReadOnly(bool value) { _readOnly = value; }
    bool isReadOnly() const { return _readOnly; }
    bool isModified() const { return _modified; }
protected:
    NRect _rect;
    uint32 _fileHash;
    int _maxVisibleChars;
    int _maxStringLength;
    int _cursorPos;
    int _cursorTicks;
    Common::String _entryString;
    Common::SharedPtr<FontSurface> _fontSurface;
    TextLabelWidget *_textLabelWidget;
    BaseSurface *_cursorSurface;
    uint32 _cursorFileHash;
    int16 _cursorWidth, _cursorHeight;
    bool _modified;
    bool _readOnly;
    void update();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
};

class SavegameListBox : public Widget {
public:
    SavegameListBox(NeverhoodEngine *vm, int16 x, int16 y, GameStateMenu *parentScene,
        SavegameList *savegameList, const Common::SharedPtr<FontSurface> &fontSurface, uint32 bgFileHash, const NRect &rect);
    void onClick() override;
    void initialize() override;
    void buildItems();
    void drawItems();
    void refresh();
    void scrollUp();
    void scrollDown();
    void pageUp();
    void pageDown();
    uint getCurrIndex() const { return _currIndex; }
protected:
    const NRect _rect;
    uint32 _bgFileHash;
    int _maxStringLength;
    Common::Array<TextLabelWidget*> _textLabelItems;
    int _firstVisibleItem;
    int _lastVisibleItem;
    SavegameList *_savegameList;
    Common::SharedPtr<FontSurface> _fontSurface;
    uint _currIndex;
    int _maxVisibleItemsCount;
};

class GameStateMenu : public Scene {
public:
    GameStateMenu(NeverhoodEngine *vm, Module *parentModule, SavegameList *savegameList,
        const uint32 *buttonFileHashes, const NRect *buttonCollisionBounds,
        uint32 backgroundFileHash, uint32 fontFileHash,
        uint32 mouseFileHash, const NRect *mouseRect,
        uint32 listBoxBackgroundFileHash, int16 listBoxX, int16 listBoxY, const NRect &listBoxRect,
        uint32 textEditBackgroundFileHash, uint32 textEditCursorFileHash, int16 textEditX, int16 textEditY, const NRect &textEditRect,
        uint32 textFileHash1, uint32 textFileHash2);
    NPoint getMousePos();
    virtual void setCurrWidget(Widget *newWidget);
    virtual Widget *getCurrWidget() { return _currWidget; }
    virtual void refreshDescriptionEdit();
protected:
    Widget *_currWidget;
    SavegameList *_savegameList;
    Common::SharedPtr<FontSurface> _fontSurface;
    SavegameListBox *_listBox;
    TextEditWidget *_textEditWidget;
    Common::String _savegameDescription;
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
    virtual void performAction();
    int scummVMSaveLoadDialog(bool isSave, Common::String &saveDesc);
};

class SaveGameMenu : public GameStateMenu {
public:
    SaveGameMenu(NeverhoodEngine *vm, Module *parentModule, SavegameList *savegameList);
protected:
    void performAction() override;
};

class LoadGameMenu : public GameStateMenu {
public:
    LoadGameMenu(NeverhoodEngine *vm, Module *parentModule, SavegameList *savegameList);
protected:
    void performAction() override;
};

class DeleteGameMenu : public GameStateMenu {
public:
    DeleteGameMenu(NeverhoodEngine *vm, Module *parentModule, SavegameList *savegameList);
protected:
    void performAction() override;
};

class QueryOverwriteMenu : public Scene {
public:
    QueryOverwriteMenu(NeverhoodEngine *vm, Module *parentModule, const Common::String &description);
protected:
    void update();
    uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
    void displayOverwriteStrings(const Common::String &description);
};

} // End of namespace Neverhood

#endif /* NEVERHOOD_MENUMODULE_H */