gui_menu_items.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 M4_GUI_GUI_MENU_ITEMS_H
#define M4_GUI_GUI_MENU_ITEMS_H

#include "graphics/surface.h"
#include "m4/m4_types.h"
#include "m4/graphics/gr_buff.h"
#include "m4/gui/gui_univ.h"

namespace M4 {

namespace Burger {
namespace GUI {

enum options_menu_sprites {
    OM_DIALOG_BOX,

    OM_SLIDER_BTN_NORM,
    OM_SLIDER_BTN_OVER,
    OM_SLIDER_BTN_PRESS,

    OM_SLIDER_BAR,

    OM_DONE_BTN_GREY,
    OM_DONE_BTN_NORM,
    OM_DONE_BTN_OVER,
    OM_DONE_BTN_PRESS,

    OM_CANCEL_BTN_NORM,
    OM_CANCEL_BTN_OVER,
    OM_CANCEL_BTN_PRESS,

    OM_TOTAL_SPRITES
};

} // namespace GUI
} // namespace Burger

namespace Riddle {
namespace GUI {

enum options_menu_sprites {
    OM_DIALOG_BOX,

    OM_SLIDER_BTN_NORM = 5,
    OM_SLIDER_BTN_OVER = 6,
    OM_SLIDER_BTN_PRESS = 7,

    OM_SCROLLING_ON_BTN_NORM = 8,
    OM_SCROLLING_ON_BTN_OVER = 9,
    OM_SCROLLING_ON_BTN_PRESS = 13,

    OM_SCROLLING_OFF_BTN_NORM = 11,
    OM_SCROLLING_OFF_BTN_OVER = 12,
    OM_SCROLLING_OFF_BTN_PRESS = 10,

    OM_TOTAL_SPRITES = 14
};

} // namespace GUI
} // namespace Riddle

namespace GUI {

#define _GM(X) ::M4::g_vars->_menu.X
#define LockMouseSprite mouse_lock_sprite
#define UnlockMouseSprite mouse_unlock_sprite

enum save_load_menu_item_tags {
    SL_TAG_SAVE = 100,
    SL_TAG_SAVE_LABEL,
    SL_TAG_LOAD,
    SL_TAG_LOAD_LABEL,
    SL_TAG_CANCEL,
    SL_TAG_SAVE_TITLE_LABEL,
    SL_TAG_LOAD_TITLE_LABEL,
    SL_TAG_VSLIDER,
    SL_TAG_THUMBNAIL
};

struct menuItem;
struct guiMenu;

typedef bool (*ItemHandlerFunction)(menuItem *theItem, int32 eventType, int32 event, int32 x, int32 y, void **currItem);
typedef void (*DrawFunction)(void *source, guiMenu *dest, int32 x1, int32 y1, int32 x2, int32 y2);
typedef void (*DestroyFunction)(menuItem *theItem);
typedef M4CALLBACK CALLBACK;

typedef M4sprite Sprite;

enum game_menu_sprites {
    GM_DIALOG_BOX,

    GM_BUTTON_GREY,
    GM_BUTTON_NORM,
    GM_BUTTON_OVER,
    GM_BUTTON_PRESS,

    GM_TOTAL_SPRITES
};

struct guiMenu;

struct menuItem {
    enum {
        TEXT_COLOR_GREY_HILITE      = 192,
        TEXT_COLOR_GREY_FOREGROUND  = 210,
        TEXT_COLOR_GREY_SHADOW      = 229,

        TEXT_COLOR_NORM_HILITE      = 3,
        TEXT_COLOR_NORM_FOREGROUND  = 2,
        TEXT_COLOR_NORM_SHADOW      = 1,

        TEXT_COLOR_OVER_HILITE      = 3,
        TEXT_COLOR_OVER_FOREGROUND  = 2,
        TEXT_COLOR_OVER_SHADOW      = 1,

        TEXT_COLOR_PRESS_HILITE     = 3,
        TEXT_COLOR_PRESS_FOREGROUND = 2,
        TEXT_COLOR_PRESS_SHADOW     = 1,
    };

    menuItem *next = nullptr;
    menuItem *prev = nullptr;

    guiMenu *myMenu = nullptr;
    int32 tag = 0;

    int32 x1 = 0, y1 = 0, x2 = 0, y2 = 0;

    bool transparent = false;
    GrBuff *background = nullptr;

    CALLBACK callback = nullptr;
    DrawFunction redraw = nullptr;
    DestroyFunction destroy = nullptr;
    ItemHandlerFunction itemEventHandler = nullptr;

    static void destroyItem(menuItem *theItem);
    static bool cursorInsideItem(menuItem *myItem, int32 cursorX, int32 cursorY);
};

struct menuItemMsg : public menuItem {
private:
    static void drawMsg(menuItemMsg *myItem, guiMenu *myMenu, int32 x, int32 y, int32, int32);

public:
    int32 itemFlags = 0;

    static menuItemMsg *msgAdd(guiMenu *myMenu, int32 tag, int32 x, int32 y, int32 w, int32 h, bool transparent = false);
    static void disableMsg(menuItemMsg *myItem, int32 tag, guiMenu *myMenu);
    static void enableMsg(menuItemMsg *myItem, int32 tag, guiMenu *myMenu);
};

struct menuItemButton : public menuItem {
private:
    static void drawButton(menuItemButton *myItem, guiMenu *myMenu,
        int32 x, int32 y, int32, int32);

public:
    enum button_states {
        BTN_STATE_NORM = 0,
        BTN_STATE_OVER = 1,
        BTN_STATE_PRESS = 2,
        BTN_STATE_GREY = 3
    };

    enum button_types {
        BTN_TYPE_GM_GENERIC,

        // Burger
        BTN_TYPE_SL_SAVE,
        BTN_TYPE_SL_LOAD,
        BTN_TYPE_SL_CANCEL,
        BTN_TYPE_SL_TEXT,
        BTN_TYPE_OM_DONE,
        BTN_TYPE_OM_CANCEL,

        // Riddle
        BTN_TYPE_OM_SCROLLING_ON,
        BTN_TYPE_OM_SCROLLING_OFF
    };

    int32 itemFlags = 0;
    int32 buttonType = 0;
    const char *prompt = nullptr;
    menuItem *assocItem = nullptr;
    int32 specialTag = 0;

    static menuItemButton *add(guiMenu *myMenu, int32 tag, int32 x, int32 y, int32 w, int32 h, CALLBACK callback = nullptr,
        int32 buttonType = 0, bool ghosted = false, bool transparent = false,
        const char *prompt = nullptr, ItemHandlerFunction i_handler = (ItemHandlerFunction)handler);
    static void disableButton(menuItemButton *myItem, int32 tag, guiMenu *myMenu);
    static void enableButton(menuItemButton *myItem, int32 tag, guiMenu *myMenu);
    static bool handler(menuItemButton *theItem, int32 eventType, int32 event,
        int32 x, int32 y, void **currItem);
};

struct menuItemHSlider : public menuItem {
private:
    static void drawHSlider(menuItemHSlider *myItem, guiMenu *myMenu, int32 x, int32 y, int32, int32);
    static bool handler(menuItemHSlider *myItem, int32 eventType, int32 event, int32 x, int32 y, void **currItem);

public:
    int32 itemFlags = 0;

    int32 thumbW = 0, thumbH = 0;
    int32 thumbX = 0, maxThumbX = 0;

    int32 percent = 0;

    enum {
        H_THUMB_NORM = 0,
        H_THUMB_OVER = 1,
        H_THUMB_PRESS = 2
    };

    static menuItemHSlider *add(guiMenu *myMenu, int32 tag,
        int32 x, int32 y, int32 w, int32 h, int32 initPercent = 0,
        CALLBACK callback = nullptr, bool transparent = false);
};

struct menuItemVSlider : public menuItem {
private:
    static int32 whereIsCursor(menuItemVSlider *myVSlider, int32 y);

public:
    int32 itemFlags = 0;

    int32 thumbW = 0, thumbH = 0;
    int32 thumbY = 0, minThumbY = 0, maxThumbY = 0;

    int32 percent = 0;

    enum {
        VS_NORM = 0x0000,
        VS_OVER = 0x0001,
        VS_PRESS = 0x0002,
        VS_GREY = 0x0003,
        VS_STATUS = 0x000f,
        VS_UP = 0x0010,
        VS_PAGE_UP = 0x0020,
        VS_THUMB = 0x0030,
        VS_PAGE_DOWN = 0x0040,
        VS_DOWN = 0x0050,
        VS_COMPONENT = 0x00f0
    };

    static menuItemVSlider *add(guiMenu *myMenu, int32 tag, int32 x, int32 y, int32 w, int32 h,
        int32 initPercent = 0, CALLBACK callback = nullptr, bool transparent = false);
    static void disableVSlider(menuItemVSlider *myItem, int32 tag, guiMenu *myMenu);
    static void enableVSlider(menuItemVSlider *myItem, int32 tag, guiMenu *myMenu);
    static void drawVSlider(menuItemVSlider *myItem, guiMenu *myMenu, int32 x, int32 y, int32, int32);
    static bool handler(menuItemVSlider *myItem, int32 eventType, int32 event, int32 x, int32 y, void **currItem);
};

struct menuItemTextField : public menuItem {
    int32 itemFlags = 0;

    int32 specialTag = 0;
    int32 pixWidth = 0;

    char prompt[80] = { 0 };
    char *promptEnd = nullptr;

    char *cursor = nullptr;

    enum {
        TF_NORM = 0,
        TF_OVER = 1,
        TF_GREY = 2
    };

    static menuItemTextField *add(guiMenu *myMenu, int32 tag, int32 x, int32 y, int32 w, int32 h, int32 initFlags,
        const char *prompt = nullptr, int32 specialtag = 0, CALLBACK callback = nullptr, bool transparent = false);
    static bool handler(menuItemTextField *myItem, int32 eventType, int32 event, int32 x, int32 y, void **currItem);
    static void drawTextField(menuItemTextField *myItem, guiMenu *myMenu, int32 x, int32 y, int32, int32);
};

struct guiMenu {
private:
    static void show(void *s, void *r, void *b, int32 destX, int32 destY);
    static bool eventHandler(guiMenu *theMenu, int32 eventType, int32 parm1, int32 parm2, int32 parm3, bool *currScreen);

public:
    GrBuff *menuBuffer = nullptr;
    menuItem *itemList = nullptr;
    CALLBACK cb_return = nullptr;
    CALLBACK cb_esc = nullptr;
    EventHandler menuEventHandler = nullptr;

    static bool initialize(RGB8 *myPalette);
    static void shutdown(bool fadeToColor);
    static guiMenu *create(Sprite *backgroundSprite, int32 x1, int32 y1, int32 scrnFlags);
    static void destroy(guiMenu *myMenu);
    static void configure(guiMenu *myMenu, CALLBACK cb_return, CALLBACK cb_esc);
    static GrBuff *copyBackground(guiMenu *myMenu, int32 x, int32 y, int32 w, int32 h);
    static menuItem *getItem(int32 tag, guiMenu *myMenu);
    static void itemDelete(menuItem *myItem, int32 tag, guiMenu *myMenu);
    static void itemRefresh(menuItem *myItem, int32 tag, guiMenu *myMenu);

    static bool loadSprites(const char *series, int32 numSprites);
    static void unloadSprites();
};

struct MenuGlobals {
    //GLOBAL VARS
    bool menuSystemInitialized = false;
    bool buttonClosesDialog = false;
    bool interfaceWasVisible = false;
    RGB8 *menuPalette = nullptr;
    bool dumpedCodes = false;
    bool dumpedBackground = false;

    menuItem *menuCurrItem = nullptr;

    guiMenu *gameMenu = nullptr;
    guiMenu *opMenu = nullptr;
    guiMenu *slMenu = nullptr;
    guiMenu *errMenu = nullptr;

    //menu sprite series vars
    char *menuSeriesResource = nullptr;
    MemHandle menuSeriesHandle = nullptr;
    int32 menuSeriesOffset = 0;
    int32 menuSeriesPalOffset = 0;

    Font *menuFont = nullptr;

    // menu sprites array (used to hold all the sprites for the current menu, spriteCount is set tot he number of sprites in the series)
    int32 spriteCount = 0;
    Sprite **menuSprites = nullptr;

    // VARS SPECIFIC TO THE GAME MENUS SYSTEM
    // An array of slot titles used by the save/load menus
    char **slotTitles = nullptr;
    bool *slotInUse = nullptr;
    int32 firstSlotIndex = 0;   // Slot at the top of the list on menu
    int32 slotSelected = -1;    // Slot currently selected 
    bool deleteSaveDesc = false;

    Sprite **thumbNails = nullptr;
    Sprite *saveLoadThumbNail = nullptr;    // Original used for menu display
    Graphics::Surface _thumbnail;           // ScummVM version used for savegame
    int32 sizeofThumbData = -1;
    int32 thumbIndex = 0;

    bool currMenuIsSave = true;         // Used to determine load or save menu
    bool saveLoadFromHotkey = false;    // Come from hotkey, not through game menu
    bool gameMenuFromMain = false;      // Come from main menu, not through escape

    int32 remember_digi_volume = 0;     // For cancelling out of the options menu
    int32 remember_digestability = 0;   // For cancelling out of the options menu

    ~MenuGlobals() {
        _thumbnail.free();
    }
};

extern void gui_DrawSprite(Sprite *mySprite, Buffer *myBuff, int32 x, int32 y);

//======================================
//
//      gamemenu module defines
//
#define MENU_DEPTH          9   // video depth for menu popup boxes
#define MAX_SLOTS           99  // number of save games you can have
#define MAX_SLOTS_SHOWN     8   // number of slots in the scrolling field

} // namespace GUI
} // namespace M4

#endif