1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/* 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.
*
* Additional copyright for this file:
* Copyright (C) 1995-1997 Presto Studios, Inc.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef PEGASUS_ELEMENTS_H
#define PEGASUS_ELEMENTS_H
#include "common/rect.h"
#include "common/str.h"
#include "common/system.h"
#include "graphics/pict.h"
#include "graphics/surface.h"
#include "pegasus/pegasus.h"
#include "pegasus/util.h"
namespace Pegasus {
class DisplayElement : public IDObject {
friend class GraphicsManager;
public:
DisplayElement(const tDisplayElementID);
virtual ~DisplayElement();
void setDisplayOrder(const tDisplayOrder);
tDisplayOrder getDisplayOrder() const { return _elementOrder; }
bool validToDraw(tDisplayOrder, tDisplayOrder);
virtual void draw(const Common::Rect&) {}
bool isDisplaying() { return _elementIsDisplaying; }
virtual void startDisplaying();
virtual void stopDisplaying();
virtual void show();
virtual void hide();
bool isVisible() { return _elementIsVisible; }
// triggerRedraw only triggers a draw if the element is displaying and visible.
void triggerRedraw();
void setTriggeredElement(DisplayElement *);
virtual void setBounds(const tCoordType, const tCoordType, const tCoordType, const tCoordType);
virtual void setBounds(const Common::Rect&);
virtual void getBounds(Common::Rect&) const;
virtual void sizeElement(const tCoordType, const tCoordType);
virtual void moveElementTo(const tCoordType, const tCoordType);
virtual void moveElement(const tCoordType, const tCoordType);
virtual void getLocation(tCoordType&, tCoordType&) const;
virtual void getCenter(tCoordType&, tCoordType&) const;
virtual void centerElementAt(const tCoordType, const tCoordType);
protected:
Common::Rect _bounds;
bool _elementIsVisible;
DisplayElement *_triggeredElement;
// Used only by PegasusEngine
bool _elementIsDisplaying;
tDisplayOrder _elementOrder;
DisplayElement *_nextElement;
};
// I'm using the proper "highlight" instead of the evil
// QuickDraw "hilite" :P (deal with it!)
class DropHighlight : public DisplayElement {
public:
DropHighlight(const tDisplayElementID);
virtual ~DropHighlight() {}
void setHighlightColor(const uint32 &highlight) { _highlightColor = highlight; }
void getHighlightColor(uint32 &highlight) const { highlight = _highlightColor; }
void setHighlightThickness(const uint16 thickness) { _thickness = thickness; }
uint16 getHighlightThickness() const { return _thickness; }
void setHighlightCornerDiameter(const uint16 diameter) { _cornerDiameter = diameter; }
uint16 getHighlightCornerDiameter() const { return _cornerDiameter; }
virtual void draw(const Common::Rect&);
protected:
uint32 _highlightColor;
uint16 _thickness;
uint16 _cornerDiameter;
};
class EnergyBar : public DisplayElement {
public:
EnergyBar(const tDisplayElementID);
virtual ~EnergyBar() {}
void getBarColor(uint32 &color) const { color = _barColor; }
void setBarColor(const uint32 &color) { _barColor = color; }
long getEnergyLevel() const { return _energyLevel; }
void setEnergyLevel(const uint32);
long getMaxEnergy() const { return _maxEnergy; }
void setMaxEnergy(const uint32);
virtual void setBounds(const Common::Rect&);
virtual void draw(const Common::Rect&);
protected:
void calcLevelRect(Common::Rect&) const;
void checkRedraw();
uint32 _energyLevel;
uint32 _maxEnergy;
Common::Rect _levelRect;
uint32 _barColor;
};
} // End of namespace Pegasus
#endif
|
