gui.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/>.
 *
 */

/*
 * Based on
 * WebVenture (c) 2010, Sean Kasun
 * https://github.com/mrkite/webventure, http://seancode.com/webventure/
 *
 * Used with explicit permission from the author
 */

#ifndef MACVENTURE_GUI_H
#define MACVENTURE_GUI_H

#include "graphics/macgui/macwindowmanager.h"
#include "graphics/macgui/macwindow.h"
#include "graphics/macgui/macmenu.h"

#include "graphics/font.h"

#include "common/timer.h"

#include "macventure/macventure.h"
#include "macventure/container.h"
#include "macventure/image.h"
#include "macventure/prebuilt_dialogs.h"
#include "macventure/dialog.h"
#include "macventure/controls.h"
#include "macventure/windows.h"

namespace MacVenture {

using namespace Graphics::MacGUIConstants;
using namespace Graphics::MacWindowConstants;
class MacVentureEngine;
typedef uint32 ObjID;

class Cursor;
class ConsoleText;
class CommandButton;
class ImageAsset;
class Dialog;
struct InventoryCallbackStruct;

BorderBounds borderBounds(MVWindowType type);
Graphics::BorderOffsets borderOffsets(MVWindowType type);

enum MenuAction {
    kMenuActionAbout,
    kMenuActionNew,
    kMenuActionOpen,
    kMenuActionSave,
    kMenuActionSaveAs,
    kMenuActionQuit,
    kMenuActionUndo,
    kMenuActionCut,
    kMenuActionCopy,
    kMenuActionPaste,
    kMenuActionClear,
    kMenuActionCleanUp,
    kMenuActionMessUp,

    kMenuActionCommand
};

struct DraggedObj {
    ObjID id;
    Common::Point pos;
    Common::Point mouseOffset;
    Common::Point startPos;
    WindowReference startWin;
    bool hasMoved;
};

class Gui {

public:
    Gui(MacVentureEngine *engine, Common::MacResManager *resman);
    ~Gui();

    void reloadInternals();

    void draw();
    void markRedraw();
    void drawMenu();
    void drawTitle();

    void loadDiploma();

    void clearControls();
    bool processEvent(Common::Event &event);
    void handleMenuAction(MenuAction action);
    void updateWindow(WindowReference winID, bool containerOpen);
    void invertWindowColors(WindowReference winID);

    WindowReference createInventoryWindow(ObjID objRef);
    bool tryCloseWindow(WindowReference winID);
    bool tryCloseWindowRec(WindowReference winID, bool runControl = false);
    void resetWindows(); // Close and destroy inventory and main game windows
    void closeAllWindows();

    void highlightExitButton(ObjID objID);

    Common::Point getObjMeasures(ObjID obj);

    WindowReference getObjWindow(ObjID objID);
    WindowReference findObjWindow(ObjID objID);

    // Event processors
    bool processCommandEvents(WindowClick click, Common::Event &event);
    bool processMainGameEvents(WindowClick click, Common::Event &event);
    bool processOutConsoleEvents(WindowClick click, Common::Event &event);
    bool processSelfEvents(WindowClick click, Common::Event &event);
    bool processExitsEvents(WindowClick click, Common::Event &event);
    bool processDiplomaEvents(WindowClick click, Common::Event &event);
    bool processDiplomaKey(Common::Event &event);
    void printDiploma();
    bool processInventoryEvents(WindowReference ref, WindowClick click, Common::Event &event);

    const WindowData& getWindowData(WindowReference reference);
    Graphics::MacWindow *findWindow(WindowReference reference);

    Graphics::MacWindowManager *getMacWindowManager() { return &_wm; }
    const Graphics::Font& getCurrentFont();

    // Clicks
    void select(Common::Point cursorPosition, bool shiftPressed, bool isDoubleClick);
    void handleSingleClick();
    void handleDoubleClick();

    // Modifiers
    void bringToFront(WindowReference window);
    void setWindowTitle(WindowReference winID, const Common::String &string);
    void updateWindowInfo(WindowReference ref, ObjID objID, const Common::Array<ObjID> &children);
    void ensureInventoryOpen(WindowReference reference, ObjID id);

    void addChild(WindowReference target, ObjID child);
    void removeChild(WindowReference target, ObjID child);

    void clearDraggedObjects();

    void clearExits();
    void unselectExits();
    void updateExit(ObjID id);
    void resetExitBackgroundPattern();

    Common::String getConsoleText() const;
    void setConsoleText(const Common::String &text);

    void printText(const Common::String &text);
    void scrollConsoleToRow(uint row);
    uint getConsoleRowCount();
    uint getConsoleVisibleRows();

    void setWaitCursor(bool wait);

    //Dialog interactions
    void showPrebuiltDialog(PrebuiltDialogs type, const Common::String &title = "");
    bool isDialogOpen();

    void getTextFromUser(Common::String &title);
    void setTextInput(const Common::String &str);
    void closeDialog();

    void loadGame();
    void saveGame();
    void newGame();
    void quitGame();

    void createInnerSurface(Graphics::ManagedSurface *innerSurface, Graphics::ManagedSurface *outerSurface, const BorderBounds &borders);

private:
    bool decodeStartupScreen();
    bool decodeTitleScreen();
    bool displayTitleScreenAndWait(uint32 ms);

private: // Attributes

    MacVentureEngine *_engine;
    Common::MacResManager *_resourceManager;

    Graphics::ManagedSurface _screen;
    Graphics::MacWindowManager _wm;

    WindowReference _activeWinRef;

    Common::List<WindowData> *_windowData;
    Common::Array<CommandButton> *_controlData;
    Common::Array<CommandButton> *_exitsData;

    Graphics::MacWindow *_controlsWindow;
    Graphics::MacWindow *_mainGameWindow;
    Graphics::MacTextWindow *_outConsoleWindow;
    Graphics::MacWindow *_selfWindow;
    Graphics::MacWindow *_exitsWindow;
    Graphics::MacWindow *_diplomaWindow;

    struct InventoryWindowData {
        Graphics::MacWindow *win;
        WindowReference ref;
        InventoryCallbackStruct *callbackData;
    };
    Common::Array<InventoryWindowData> _inventoryWindows;
    Common::HashMap<ObjID, WindowReference> _objToInvRef;

    Graphics::MacMenu *_menu;
    Dialog *_dialog;

    Container *_graphics;
    Common::HashMap<ObjID, ImageAsset*> _assets;
    ImageAsset *_diplomaImage;
    Common::String _diplomaName;
    Common::Rect _diplomaNameBounds;
    uint16 _diplomaFontId;
    uint16 _diplomaFontSize;

    Common::Array<DraggedObj> _draggedObjects;
    Common::Array<Graphics::ManagedSurface> _draggedSurfaces;

    Cursor *_cursor;

    ConsoleText *_consoleText;

    bool _needsRedraw;

    WindowReference _lassoWinRef;
    Common::Point _lassoStart;
    Common::Point _lassoEnd;
    bool _lassoBeingDrawn;

private: // Methods

    // Initializers
    void initGUI();
    void initWindows();
    void assignObjReferences(); // Mainly guesswork

    // Loaders
    bool loadMenus();
    bool loadWindows();
    bool loadControls();
    void loadBorders(Graphics::MacWindow *target, MVWindowType type);
    void loadBorder(Graphics::MacWindow *target, MVWindowType type, bool active);
    void loadGraphics();
    void clearAssets();

    // Drawers
    void drawWindows();
    void drawCommandsWindow();
    void drawDiplomaWindow();
    void drawMainGameWindow();
    void drawSelfWindow();
    void drawInventories();
    void drawExitsWindow();
    void drawConsoleWindow();

    void drawDraggedObjects();
    void drawObjectsInWindow(const WindowData &targetData, Graphics::ManagedSurface *surface);
    void drawWindowTitle(WindowReference target, Graphics::ManagedSurface *surface);
    void drawDialog();

    void moveDraggedObjects(Common::Point target);

    // Finders
    WindowReference findWindowAtPoint(Common::Point point);
    Common::Point getGlobalScrolledSurfacePosition(WindowReference reference);
    WindowData& findWindowData(WindowReference reference);

    // Utils
    void checkSelect(const WindowData &data, Common::Point pos, const Common::Rect &clickRect, WindowReference ref, bool shiftPressed, bool isDoubleClick);
    bool canBeSelected(ObjID obj, const Common::Rect &clickRect, WindowReference ref);
    bool isRectInsideObject(Common::Rect target, ObjID obj);
    void selectDraggable(ObjID child, WindowReference origin, Common::Point startPos);
    void handleDragRelease(bool shiftPressed, bool isDoubleClick);
    Common::Rect calculateLassoRect(Graphics::MacWindow *win);
    Common::Rect calculateClickRect(Common::Point clickPos, Common::Rect windowBounds);
    Common::Point localizeTravelledDistance(Common::Point point, WindowReference origin, WindowReference target);
    void removeInventoryWindow(WindowReference ref);

    void ensureAssetLoaded(ObjID obj);

};

struct InventoryCallbackStruct {
    Gui *gui;
    WindowReference ref;
};

enum ClickState {
    kCursorIdle = 0,
    kCursorSCStart = 1,
    kCursorSCDrag = 2,
    kCursorDCStart = 3,
    kCursorDCDo = 4,
    kCursorSCSink = 5,
    kCursorStateCount
};

enum CursorInput { // Columns for the FSM transition table
    kButtonDownCol = 0,
    kButtonUpCol = 1,
    kTickCol = 2,
    kCursorInputCount
};

class Cursor {

public:
    Cursor(Gui *gui);
    ~Cursor();

    void tick();
    bool processEvent(const Common::Event &event);
    Common::Point getPos();
    bool canSelectDraggable();

private:

    void changeState(CursorInput input);
    void executeStateIn();
    void executeStateOut();


private:
    Gui *_gui;

    Common::Point _pos;
    ClickState _state;
    bool _shiftPressed;
};



enum {
    kConsoleLeftOffset = 2
};

class ConsoleText {

public:

    ConsoleText(Gui *gui) {
        _gui = gui;
        _lines.push_back("");
        updateScroll();
    }

    ~ConsoleText() {

    }

    void printLine(const Common::String &str, int maxW) {
        Common::StringArray wrappedLines;
        int textW = maxW;
        const Graphics::Font *font = &_gui->getCurrentFont();

        font->wordWrapText(str, textW, wrappedLines);

        if (wrappedLines.empty()) // Sometimes we have empty lines
            _lines.push_back("");

        for (Common::StringArray::const_iterator j = wrappedLines.begin(); j != wrappedLines.end(); ++j) {
            _lines.push_back(*j);
        }

        updateScroll();
    }

    void renderInto(Graphics::ManagedSurface *target, const BorderBounds borders, int textOffset) {
        target->fillRect(target->getBounds(), kColorWhite);

        Graphics::ManagedSurface *composeSurface = new Graphics::ManagedSurface();
        _gui->createInnerSurface(composeSurface, target, borders);
        composeSurface->clear(kColorGreen);

        const Graphics::Font *font = &_gui->getCurrentFont();
        int y = target->h - font->getFontHeight();
        for (uint i = _scrollPos; i != 0; i--) {
            font->drawString(target, _lines[i], textOffset, y, font->getStringWidth(_lines[i]), kColorBlack);

            if (y < font->getFontHeight())  // Do not draw off-screen
                break;

            y -= font->getFontHeight();
        }

        Common::Point composePosition = Common::Point(borders.leftOffset, borders.topOffset);
        target->transBlitFrom(*composeSurface, composePosition, kColorGreen);
        delete composeSurface;
    }

    void updateScroll() {
        _scrollPos = _lines.size() - 1;
    }

    void scrollDown() {
        if (_scrollPos < (int)(_lines.size() - 1)) {
            _scrollPos++;
        }
    }

    void scrollUp() {
        if (_scrollPos > 0) {
            _scrollPos--;
        }
    }


private:

    Gui *_gui;

    Common::StringArray _lines;
    int _scrollPos;

};

} // End of namespace MacVenture

#endif