pet_glyphs.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 TITANIC_PET_GLYPHS_H
#define TITANIC_PET_GLYPHS_H
 
#include "common/keyboard.h"
#include "titanic/core/list.h"
#include "titanic/messages/mouse_messages.h"
#include "titanic/pet_control/pet_gfx_element.h"
#include "titanic/support/rect.h"
 
namespace Titanic {
 
#define TOTAL_GLYPHS 7
 
class CPetGlyphs;
class CPetSection;
class CTextControl;
 
enum GlyphActionMode { ACTION_REMOVE = 0, ACTION_REMOVED = 1, ACTION_CHANGE = 2 };
 
enum GlyphFlag { GFLAG_1 = 1, GFLAG_2 = 2, GFLAG_4 = 4, GFLAG_8 = 8, GFLAG_16 = 16 };
 
class CGlyphAction {
protected:
    GlyphActionMode _mode;
public:
    CGlyphAction() : _mode(ACTION_REMOVED) {}
    CGlyphAction(GlyphActionMode mode) : _mode(mode) {}
 
    GlyphActionMode getMode() const { return _mode; }
};
 
class CPetGlyph : public ListItem {
protected:
    CPetSection *getPetSection() const;
public:
    CPetGfxElement _element;
    CPetGlyphs *_owner;
public:
    CPetGlyph() : ListItem(), _owner(nullptr) {}
 
    virtual bool setup(CPetControl *petControl, CPetGlyphs *owner);
 
    virtual bool reset() { return false; }
 
    virtual void enter() {}
 
    virtual void leave() {}
 
    virtual void drawAt(CScreenManager *screenManager, const Point &pt, bool isHighlighted);
 
    virtual void draw2(CScreenManager *screenManager) {}
 
    virtual void updateTooltip();
 
    virtual Rect getBounds() const { return Rect(); }
 
    virtual bool MouseButtonDownMsg(const Point &pt) { return false; }
 
    virtual bool MouseDragStartMsg(CMouseDragStartMsg *msg) { return false; }
 
    virtual bool MouseDragMoveMsg(CMouseDragMoveMsg *msg) { return false; }
 
    virtual bool MouseDragEndMsg(CMouseDragEndMsg *msg) { return false; }
 
    virtual bool MouseButtonUpMsg(const Point &pt) { return false; }
 
    virtual bool MouseDoubleClickMsg(const CMouseDoubleClickMsg *msg) { return false; }
 
    virtual bool KeyCharMsg(int key) { return false; }
 
    virtual bool ActionMsg(CActionMsg *msg) {return false; }
 
    virtual void unhighlightCurrent() {}
 
    virtual void highlightCurrent(const Point &pt) {}
 
    virtual void glyphFocused(const Point &topLeft, bool flag) {}
 
    virtual void selectGlyph(const Point &topLeft, const Point &pt) {}
 
    virtual bool dragGlyph(const Point &topLeft, CMouseDragStartMsg *msg) { return false; }
 
    virtual bool contains(const Point &delta, const Point &pt);
 
    virtual void getTooltip(CTextControl *text) {}
 
    virtual void saveGlyph(SimpleFile *file, int indent) {}
 
    virtual bool proc33(CPetGlyph *glyph) { return true; }
 
    virtual bool isValid() const { return true; }
 
    virtual bool enterHighlighted() { return false; }
 
    virtual void leaveHighlighted() {}
 
    virtual CGameObject *getObjectAt() { return nullptr; }
 
    virtual bool doAction(CGlyphAction *action) { return true; }
 
    void translate(const Point &pt) { _element.translate(pt.x, pt.y); }
 
    void translateBack(const Point &pt) { _element.translate(-pt.x, -pt.y); }
 
    CPetGlyphs *getOwner() { return _owner; }
 
    CPetControl *getPetControl() const;
 
    void setName(const CString &name, CPetControl *petControl);
 
    bool isHighlighted() const;
};
 
class CPetGlyphs : public List<CPetGlyph> {
private:
    Point getPosition(int index) const;
 
    Rect getRect(int index) const;
 
    int getHighlightedIndex(int index) const;
 
    int getItemIndex(int index) const;
 
    void setSelectedIndex(int index);
 
    CPetGlyph *getGlyph(int index) const;
 
    void setFirstVisible(int index);
 
    void makePetDirty();
 
    bool areItemsValid() const;
protected:
    int _firstVisibleIndex;
    int _totalGlyphs;
    int _numVisibleGlyphs;
    int _highlightIndex;
    int _field1C;
    int _flags;
    CPetGlyph *_dragGlyph;
    CPetSection *_owner;
    CPetGfxElement _selection;
    CPetGfxElement _scrollLeft;
    CPetGfxElement _scrollRight;
protected:
    void changeHighlight(int index);
public:
    CPetGlyphs();
 
    void setNumVisible(int total);
 
    void clear();
 
 
    virtual void setup(int numVisible, CPetSection *owner);
 
    virtual void reset();
 
    virtual void enter();
 
    virtual void leave();
 
    void setFlags(int flags) { _flags = flags; }
 
    void draw(CScreenManager *screenManager);
 
    void highlight(int index);
 
    void highlight(const CPetGlyph *glyph);
 
    CPetSection *getOwner() const { return _owner; }
 
    CPetControl *getPetControl() const;
 
    bool MouseButtonDownMsg(const Point &pt);
 
    bool MouseButtonUpMsg(const Point &pt);
 
    bool MouseDoubleClickMsg(const Point &pt) { return true; }
 
    bool MouseDragStartMsg(CMouseDragStartMsg *msg);
 
    bool MouseDragMoveMsg(CMouseDragMoveMsg *msg);
 
    bool MouseDragEndMsg(CMouseDragEndMsg *msg);
 
    bool KeyCharMsg(int key);
 
    bool ActionMsg(CActionMsg *msg);
 
    bool enterHighlighted();
 
    void leaveHighlighted();
 
    void startDragging(CPetGlyph *glyph, CMouseDragStartMsg *msg);
 
    void endDragging();
 
    void resetHighlight() { changeHighlight(-1); }
 
    bool highlighted14();
 
    int indexOf(const CPetGlyph *glyph) const;
 
    void scrollToStart() { _firstVisibleIndex = 0; }
 
    void scrollLeft();
 
    void scrollRight();
 
    void incSelection();
 
    void decSelection();
 
    CGameObject *getObjectAt(const Point &pt) const;
 
    bool isGlyphHighlighted(const CPetGlyph *glyph) const;
 
    int getHighlightIndex() const { return _highlightIndex; }
 
    Point getHighlightedGlyphPos() const;
 
    void removeInvalid();
};
 
} // End of namespace Titanic
 
#endif /* TITANIC_PET_GLYPHS_H */