Gump.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2003-2007  The Pentagram Team
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef GUMP_H_INCLUDED
#define GUMP_H_INCLUDED

#include "Object.h"
#include "Rect.h"
#include "FrameID.h"
#include <list>

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

//
// Class Gump
//
// Desc: Base Gump Class that all other Gumps inherit from
//

class Gump : public Object
{
protected:

        friend class GumpList;

        uint16                          owner;                  // Owner item
        Gump *                          parent;                 // Parent gump
        sint32                          x, y;                   // Gump's position in parent.
                                                                                // Always the upper left corner!

        Pentagram::Rect         dims;                   // The dimensions/coord space of the gump
        uint32                          flags;                  // Gump flags
        sint32                          layer;                  // gump ordering layer

        sint32                          index;                  // 'Index'

        Shape                           *shape;                 // The gumps shape (always painted at 0,0)
        uint32                          framenum;

        std::list<Gump*>        children;               // List of all gumps
        Gump *                          focus_child;    // The child that has focus

        uint16                          notifier;               // Process to notify when we're closing
        uint32                          process_result; // 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, sint32 layer = LAYER_NORMAL);
        virtual ~Gump();

public:

        virtual void                            CreateNotifier();
        void                                            SetNotifyProcess(GumpNotifyProcess* proc);
        GumpNotifyProcess*                      GetNotifyProcess();
        inline uint32                           GetResult() { return process_result; }

        inline void                                     SetShape(Shape *_shape, uint32 _framenum)
                { shape = _shape; framenum = _framenum; }

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

        inline void                                     SetFramenum(uint32 _framenum)
                { framenum = _framenum; }

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

        virtual Gump *                          FindGump(const RunTimeClassType& t,
                                                                                 bool recursive=true,
                                                                                 bool no_inheritance=false);

        template<class T> Gump *        FindGump(bool recursive=true,
                                                                                 bool no_inheritance=false)
                { return FindGump(T::ClassType, recursive, no_inheritance); }

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

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

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

        virtual bool            Run(const uint32 framenum);

        virtual void            CloseItemDependents(void);

        // \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, sint32 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, sint32 lerp_factor, sint32 scalex, sint32 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, sint32 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, sint32 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, sint32 lerp_factor, sint32 scalex, sint32 scaley);

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

public:

        virtual void            Close(bool no_del = false);

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

        virtual void            Move(int x_, int y_) { x = x_; y = y_; }

        virtual void            MoveRelative(int x_, int y_) { 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
        };

        // \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
        //

        virtual void            GetDims(Pentagram::Rect &d) { d = dims; }

        virtual bool            PointOnGump(int mx, int my);

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

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

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

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

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

        virtual void            GumpRectToScreenSpace(int &gx,int &gy, int &gw,int &gh,
                                                                                          RectRoundDir r = ROUND_OUTSIDE);

        virtual void            ScreenSpaceToGumpRect(int &sx,int &sy, int &sw,int &sh,
                                                                                         RectRoundDir r = ROUND_OUTSIDE);

        virtual uint16          TraceObjId(int mx, int my);

        virtual bool            GetLocationOfItem(uint16 itemid, int &gx, int &gy,
                                                                                  sint32 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.
        //
        
        // Return Gump that handled event
        virtual Gump *          OnMouseDown(int button, int mx, int my);
        virtual void            OnMouseUp(int  button, int mx, int my) { }
        virtual void            OnMouseClick(int button, int mx, int my) { }
        virtual void            OnMouseDouble(int button, int mx, int my) { }
        virtual Gump *          OnMouseMotion(int mx, int 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->focus_child==this:false; }

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

        // 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(sint32 i) { index = i; }
        sint32                          GetIndex() { return index; }

        // Dragging
        virtual bool            StartDraggingChild(Gump* gump, int mx, int my);
        virtual void            DraggingChild(Gump* gump, int mx, int my);
        virtual void            StopDraggingChild(Gump* gump);

        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          = 0x01,         // When set, the gump can be dragged
                FLAG_HIDDEN                     = 0x02,         // When set, the gump will not be drawn
                FLAG_CLOSING            = 0x04,         // When set, the gump is closing
                FLAG_CLOSE_AND_DEL      = 0x08,         // When set, the gump is closing and will be deleted
                FLAG_ITEM_DEPENDENT     = 0x10,         // When set, the gump will be deleted on MapChange
                FLAG_DONT_SAVE      = 0x20,             // When set, don't save this gump.
                                                        // Be very careful with this one!
                FLAG_CORE_GUMP      = 0x40,             // core gump (only children are saved)
                FLAG_KEEP_VISIBLE   = 0x80              // Keep this gump on-screen.
                                                                                // (only for ItemRelativeGumps)
        };

        inline bool                     IsHidden()
                { return (flags&FLAG_HIDDEN) || (parent && parent->IsHidden()); }
        bool                            IsDraggable() { return flags&FLAG_DRAGGABLE; }
        virtual void            HideGump() { flags |= FLAG_HIDDEN; }
        virtual void            UnhideGump() { flags &= ~FLAG_HIDDEN; }

        bool mustSave(bool toplevel);

        //
        // 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
        };

        bool loadData(IDataSource* ids, uint32 version);
protected:
        virtual void saveData(ODataSource* ods);
};

#endif //GUMP_H_INCLUDED

---