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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* 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 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.
*
* $URL$
* $Id$
*
*/
#ifndef COMMON_EVENTS_H
#define COMMON_EVENTS_H
#include "common/keyboard.h"
#include "common/rect.h"
#include "common/system.h"
#include "common/noncopyable.h"
namespace Common {
/**
* The types of events backends may generate.
* @see Event
*
* @todo Merge EVENT_LBUTTONDOWN, EVENT_RBUTTONDOWN and EVENT_WHEELDOWN;
* likewise EVENT_LBUTTONUP, EVENT_RBUTTONUP, EVENT_WHEELUP.
* To do that, we just have to add a field to the Event which
* indicates which button was pressed.
*/
enum EventType {
/** A key was pressed, details in Event::kbd. */
EVENT_KEYDOWN = 1,
/** A key was released, details in Event::kbd. */
EVENT_KEYUP = 2,
/** The mouse moved, details in Event::mouse. */
EVENT_MOUSEMOVE = 3,
EVENT_LBUTTONDOWN = 4,
EVENT_LBUTTONUP = 5,
EVENT_RBUTTONDOWN = 6,
EVENT_RBUTTONUP = 7,
EVENT_WHEELUP = 8,
EVENT_WHEELDOWN = 9,
EVENT_MBUTTONDOWN = 13,
EVENT_MBUTTONUP = 14,
EVENT_QUIT = 10,
EVENT_SCREEN_CHANGED = 11,
/**
* The backend requests the agi engine's predictive dialog to be shown.
* TODO: Fingolfin suggests that it would be of better value to expand
* on this notion by generalizing its use. For example the backend could
* use events to ask for the save game dialog or to pause the engine.
* An associated enumerated type can accomplish this.
**/
EVENT_PREDICTIVE_DIALOG = 12
};
/**
* Data structure for an event. A pointer to an instance of Event
* can be passed to pollEvent.
* @todo Rework/document this structure. It should be made 100% clear which
* field is valid for which event type.
* Implementation wise, we might want to use the classic
* union-of-structs trick. It goes roughly like this:
* struct BasicEvent {
* EventType type;
* };
* struct MouseMovedEvent : BasicEvent {
* Common::Point pos;
* };
* struct MouseButtonEvent : MouseMovedEvent {
* int button;
* };
* struct KeyEvent : BasicEvent {
* ...
* };
* ...
* union Event {
* EventType type;
* MouseMovedEvent mouse;
* MouseButtonEvent button;
* KeyEvent key;
* ...
* };
*/
struct Event {
/** The type of the event. */
EventType type;
/** Flag to indicate if the event is real or synthetic. E.g. keyboard
* repeat events are synthetic.
*/
bool synthetic;
/**
* Keyboard data; only valid for keyboard events (EVENT_KEYDOWN and
* EVENT_KEYUP). For all other event types, content is undefined.
*/
KeyState kbd;
/**
* The mouse coordinates, in virtual screen coordinates. Only valid
* for mouse events.
* Virtual screen coordinates means: the coordinate system of the
* screen area as defined by the most recent call to initSize().
*/
Common::Point mouse;
};
/**
* The EventManager provides user input events to the client code.
* In addition, it keeps track of the state of various input devices,
* like keys, mouse position and buttons.
*/
class EventManager : NonCopyable {
public:
EventManager() {}
virtual ~EventManager() {}
enum {
LBUTTON = 1 << 0,
RBUTTON = 1 << 1
};
/**
* Get the next event in the event queue.
* @param event point to an Event struct, which will be filled with the event data.
* @return true if an event was retrieved.
*/
virtual bool pollEvent(Common::Event &event) = 0;
/**
* Pushes a "fake" event into the event queue
*/
virtual void pushEvent(const Common::Event &event) = 0;
/** Register random source so it can be serialized in game test purposes **/
virtual void registerRandomSource(Common::RandomSource &rnd, const char *name) = 0;
virtual void processMillis(uint32 &millis) = 0;
/** Return the current mouse position */
virtual Common::Point getMousePos() const = 0;
/**
* Return a bitmask with the button states:
* - bit 0: left button up=1, down=0
* - bit 1: right button up=1, down=0
*/
virtual int getButtonState() const = 0;
/** Get a bitmask with the current modifier state */
virtual int getModifierState() const = 0;
/**
* Should the application terminate? Set to true if we
* received an EVENT_QUIT.
*/
virtual int shouldQuit() const = 0;
// Optional: check whether a given key is currently pressed ????
//virtual bool isKeyPressed(int keycode) = 0;
// TODO: Keyboard repeat support?
// TODO: Consider removing OSystem::getScreenChangeID and
// replacing it by a generic getScreenChangeID method here
};
} // End of namespace Common
#endif
|
