gump.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 ULTIMA8_GUMPS_GUMP_H
#define ULTIMA8_GUMPS_GUMP_H

#include "common/rect.h"
#include "ultima/ultima8/gfx/frame_id.h"
#include "ultima/ultima8/kernel/object.h"
#include "ultima/ultima8/misc/classtype.h"

namespace Ultima {
namespace Ultima8 {

class RenderSurface;
class Shape;
class Item;
class GumpNotifyProcess;

class Gump;
typedef bool (*FindGumpPredicate)(const Gump *g);
template<class T> inline bool IsOfType(const Gump *g) { return dynamic_cast<const T*>(g) != nullptr; }

class Gump : public Object {
protected:
    uint16 _owner;        // Owner item
    Gump *_parent;        // Parent gump
    int32 _x, _y;         // Gump's position in parent.
    // Always the upper left corner!

    Common::Rect32 _dims; // The dimensions/coord space of the gump
    uint32 _flags;        // Gump flags
    int32 _layer;         // gump ordering layer

    int32 _index;         // 'Index'

    const Shape *_shape;  // The gumps shape (always painted at 0,0)
    uint32 _frameNum;

    Common::List<Gump *> _children;      // List of all gumps
    Gump               *_focusChild;  // The child that has focus

    uint16              _notifier;      // Process to notify when we're closing
    uint32              _processResult; // Result for the notifier process

public:
    ENABLE_RUNTIME_CLASSTYPE()
    Gump();
    Gump(int x, int y, int width, int height, uint16 owner = 0,
         uint32 flags = 0, int32 layer = LAYER_NORMAL);
    ~Gump() override;

public:

    virtual void                CreateNotifier();
    void                        SetNotifyProcess(GumpNotifyProcess *proc);
    GumpNotifyProcess          *GetNotifyProcess();
    inline uint32               GetResult() {
        return _processResult;
    }
    void                        SetResult(uint32 res) {
        _processResult = res;
    }

    inline void SetShape(const Shape *shape, uint32 frameNum) {
        _shape = shape;
        _frameNum = frameNum;
    }

    void                        SetShape(FrameID frame, bool adjustsize = false);

    void                        UpdateDimsFromShape();

    inline void                 Set_frameNum(uint32 frameNum) {
        _frameNum = frameNum;
    }

    virtual void                InitGump(Gump *newparent, bool take_focus = true);

    virtual Gump               *FindGump(FindGumpPredicate predicate, bool recursive = true);

    template<class T> Gump     *FindGump(bool recursive = true) {
        return FindGump(&IsOfType<T>, recursive);
    }

    template<int T> static bool FindByIndex(const Gump *g) { return g->GetIndex() == T; }

    virtual Gump       *FindGump(int mx, int my);

    virtual bool GetMouseCursor(int32 mx, int32 my, Shape &shape, int32 &frame);

    // Notify gumps the render surface changed.
    virtual void        RenderSurfaceChanged();

    virtual void        run();

    virtual void        CloseItemDependents();

    // \param surf The RenderSurface to paint to
    // \param lerp_factor The lerp_factor to paint at (0-256)
    // \param scaled Set if the gump is being drawn scaled.
    virtual void        Paint(RenderSurface *surf, int32 lerp_factor, bool scaled);

    // \param surf The RenderSurface to paint to
    // \param lerp_factor The lerp_factor to paint at (0-256)
    // \param scalex Fixed point scaling factor for x coord
    // \param scaley Fixed point scaling factor for y coord
    virtual void        PaintCompositing(RenderSurface *surf, int32 lerp_factor, int32 scalex, int32 scaley);

protected:

    // \param surf The RenderSurface to paint to
    // \param lerp_factor The lerp_factor to paint at (0-256)
    // \param scaled Set if the gump is being drawn scaled.
    virtual void        PaintThis(RenderSurface *surf, int32 lerp_factor, bool scaled);

    // \param surf The RenderSurface to paint to
    // \param lerp_factor The lerp_factor to paint at (0-256)
    // \param scaled Set if the gump is being drawn scaled.
    virtual void        PaintChildren(RenderSurface *surf, int32 lerp_factor, bool scaled);

    // \param surf The RenderSurface to paint to
    // \param lerp_factor The lerp_factor to paint at (0-256)
    // \param scalex Fixed point scaling factor for x coord
    // \param scaley Fixed point scaling factor for y coord
    virtual void        PaintComposited(RenderSurface *surf, int32 lerp_factor, int32 scalex, int32 scaley);

    static inline int32 ScaleCoord(int32 c, int32 factor) {
        return ((c * factor) + (1 << 15)) >> 16;
    }
    static inline int32 UnscaleCoord(int32 c, int32 factor) {
        return (c << 16) / factor;
    }

public:

    virtual void        Close(bool no_del = false);

    bool                IsClosing() const {
        return (_flags & FLAG_CLOSING) != 0;
    }

    virtual void        Move(int32 x, int32 y) {
        _x = x;
        _y = y;
    }

    virtual void        MoveRelative(int x, int y) {
        _x += x;
        _y += y;
    }

    void getLocation(int32 &x, int32 &y) const {
        x = _x;
        y = _y;
    }

    enum Position {
        CENTER = 1,
        TOP_LEFT = 2,
        TOP_RIGHT = 3,
        BOTTOM_LEFT = 4,
        BOTTOM_RIGHT = 5,
        TOP_CENTER = 6,
        BOTTOM_CENTER = 7,
        LEFT_CENTER = 8,
        RIGHT_CENTER = 9
    };

    // \param pos the postition on the parent gump
    // \param xoffset an offset from the position on the x-axis
    // \param yoffset an offset from the position on the y-axis
    virtual void        setRelativePosition(Position pos, int xoffset = 0, int yoffset = 0);

    //
    // Points and Coords
    //

    const Common::Rect32 &getDims() const {
        return _dims;
    }

    void setDims(const Common::Rect32 &d) {
        _dims = d;
    }

    virtual bool PointOnGump(int mx, int my);

    enum PointRoundDir {
        ROUND_TOPLEFT = 0,
        ROUND_BOTTOMRIGHT = 1
    };
    enum RectRoundDir {
        ROUND_INSIDE,
        ROUND_OUTSIDE
    };

    virtual void ScreenSpaceToGump(int32 &sx, int32 &sy,
        PointRoundDir r = ROUND_TOPLEFT);

    virtual void GumpToScreenSpace(int32 &gx, int32 &gy,
        PointRoundDir r = ROUND_TOPLEFT);

    virtual void ParentToGump(int32 &px, int32 &py,
        PointRoundDir r = ROUND_TOPLEFT);

    virtual void GumpToParent(int32 &gx, int32 &gy,
        PointRoundDir r = ROUND_TOPLEFT);

    virtual void GumpRectToScreenSpace(Common::Rect32 &gr, RectRoundDir r = ROUND_OUTSIDE);

    virtual void ScreenSpaceToGumpRect(Common::Rect32 &sr, RectRoundDir r = ROUND_OUTSIDE);

    virtual uint16 TraceObjId(int32 mx, int32 my);

    virtual bool GetLocationOfItem(uint16 itemid, int32 &gx, int32 &gy,
        int32 lerp_factor = 256);


    //
    // Some event handlers. In theory they 'should' be able to be mapped to
    // Usecode classes.
    //
    // mx and my are relative to parents position
    //
    // onMouseDown returns the Gump that handled the Input, if it was handled.
    // The MouseUp,MouseDouble events will be sent to the same gump.
    //
    // onMouseMotion works like onMouseDown,
    // but independently of the other methods.
    //
    // Unhandled input will be passed down to the next lower gump.
    //
    // A mouse click on a gump will make it focus, IF it wants it.
    //
    // It is often preferrable to handle both click and double events
    // rather than only the up event to avoid unintended clicks after
    // performing intended action.

    // Return Gump that handled event
    virtual Gump       *onMouseDown(int button, int32 mx, int32 my);
    virtual void        onMouseUp(int button, int32 mx, int32 my) { }
    virtual void        onMouseClick(int button, int32 mx, int32 my) { }
    virtual void        onMouseDouble(int button, int32 mx, int32 my) { }
    virtual Gump       *onMouseMotion(int32 mx, int32 my);

    // onMouseOver is only call when the mouse first passes over the gump
    // onMouseLeft is call as the mouse leaves the gump.
    virtual void        onMouseOver() { };
    virtual void        onMouseLeft() { };

    // Keyboard input gets sent to the FocusGump. Or if there isn't one, it
    // will instead get sent to the default key handler. TextInput requires
    // that text mode be enabled. Return true if handled, false if not.
    // Default, returns false, unless handled by focus child
    virtual bool        OnKeyDown(int key, int mod);
    virtual bool        OnKeyUp(int key);
    virtual bool        OnTextInput(int unicode);

    // This is for detecting focus changes for keyboard input. Gets called true
    // when the this gump is being set as the focus focus gump. It is called
    // false when focus is being taken away.
    virtual void        OnFocus(bool /*gain*/) { }

    // Makes this gump the focus
    virtual void        MakeFocus();

    // Is this gump the focus?
    inline bool         IsFocus() {
        return _parent ? _parent->_focusChild == this : false;
    }

    // Get the child in focus
    inline Gump        *GetFocusChild() {
        return _focusChild;
    }

    // Find a new Child to be the focus
    void                FindNewFocusChild();


    //
    // Child gump related
    //

    virtual void AddChild(Gump *, bool take_focus = true);

    virtual void RemoveChild(Gump *);

    virtual void MoveChildToFront(Gump *);

    inline Gump *GetParent() {
        return _parent;
    }

    Gump *GetRootGump();

    virtual void ChildNotify(Gump *child, uint32 message) { }
    void SetIndex(int32 i) {
        _index = i;
    }
    int32 GetIndex() const {
        return _index;
    }

    virtual bool onDragStart(int32 mx, int32 my);
    virtual void onDragStop(int32 mx, int32 my);
    virtual void onDrag(int32 mx, int32 my);

    virtual bool StartDraggingItem(Item *item, int mx, int my) {
        return false;
    }

    virtual bool DraggingItem(Item *item, int mx, int my) {
        return false;
    }

    virtual void DraggingItemLeftGump(Item *item) { }

    virtual void StopDraggingItem(Item *item, bool moved) { }

    virtual void DropItem(Item *item, int mx, int my) { }

public:

    //
    // Gump Flags
    //
    enum GumpFlags {
        FLAG_DRAGGABLE      = 0x0001,     // When set, the gump can be dragged
        FLAG_HIDDEN         = 0x0002,     // When set, the gump will not be drawn
        FLAG_CLOSING        = 0x0004,     // When set, the gump is closing
        FLAG_CLOSE_AND_DEL  = 0x0008,     // When set, the gump is closing and will be deleted
        FLAG_ITEM_DEPENDENT = 0x0010,     // When set, the gump will be deleted on MapChange
        FLAG_DONT_SAVE      = 0x0020,     // When set, don't save this gump. Be very careful with this one!
        FLAG_CORE_GUMP      = 0x0040,     // core gump (only children are saved)
        FLAG_KEEP_VISIBLE   = 0x0080,     // Keep this gump on-screen. (only for ItemRelativeGumps)
        FLAG_PREVENT_SAVE   = 0x0100      // When set, prevent game from saving
    };

    inline bool hasFlags(uint flags) const {
        return (_flags & flags) != 0;
    }

    inline bool IsHidden() const {
        return (_flags & FLAG_HIDDEN) || (_parent && _parent->IsHidden());
    }
    bool IsDraggable() const {
        return _flags & FLAG_DRAGGABLE;
    }
    virtual void HideGump() {
        _flags |= FLAG_HIDDEN;
    }
    virtual void UnhideGump() {
        _flags &= ~FLAG_HIDDEN;
    }
    void SetVisibility(bool visible) {
        if (visible)
            UnhideGump();
        else
            HideGump();
    }

    bool mustSave(bool toplevel) const;

    //
    // Gump Layers
    //
    enum GumpLayers {
        LAYER_DESKTOP       = -16,      // Layer for Desktop 'bottom most'
        LAYER_GAMEMAP       = -8,       // Layer for the World Gump
        LAYER_NORMAL        = 0,        // Layer for Normal gumps
        LAYER_ABOVE_NORMAL  = 8,        // Layer for Always on top Gumps
        LAYER_MODAL         = 12,       // Layer for Modal Gumps
        LAYER_CONSOLE       = 16        // Layer for the console
    };

    enum Message {
        GUMP_CLOSING = 0x100
    };

    bool loadData(Common::ReadStream *rs, uint32 version);
    void saveData(Common::WriteStream *ws) override;
};

} // End of namespace Ultima8
} // End of namespace Ultima

#endif