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 VirtualKeyCharMsg(CVirtualKeyCharMsg *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 VirtualKeyCharMsg(CVirtualKeyCharMsg *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 */