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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
|
/* ScummVM - Scumm Interpreter
* Copyright (C) 2002-2003 The ScummVM project
*
* 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.
*
* $Header$
*/
#include "stdafx.h"
#include "PopUpWidget.h"
#include "dialog.h"
#include "newgui.h"
#include "base/engine.h"
#define UP_DOWN_BOX_HEIGHT 10
// Little up/down arrow
static uint32 up_down_arrows[8] = {
0x00000000,
0x00001000,
0x00011100,
0x00111110,
0x00000000,
0x00111110,
0x00011100,
0x00001000,
};
const Common::String PopUpWidget::emptyStr;
//
// PopUpDialog
//
class PopUpDialog : public Dialog {
protected:
PopUpWidget *_popUpBoss;
int _clickX, _clickY;
byte *_buffer;
int _selection;
uint32 _openTime;
public:
PopUpDialog(PopUpWidget *boss, int clickX, int clickY);
void drawDialog();
// void handleMouseDown(int x, int y, int button, int clickCount);
void handleMouseUp(int x, int y, int button, int clickCount);
void handleMouseWheel(int x, int y, int direction); // Scroll through entries with scroll wheel
void handleMouseMoved(int x, int y, int button); // Redraw selections depending on mouse position
void handleKeyDown(uint16 ascii, int keycode, int modifiers); // Scroll through entries with arrow keys etc.
// void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
protected:
void drawMenuEntry(int entry, bool hilite);
int findItem(int x, int y) const;
void setSelection(int item);
bool isMouseDown();
void moveUp();
void moveDown();
};
PopUpDialog::PopUpDialog(PopUpWidget *boss, int clickX, int clickY)
: Dialog(0, 0, 16, 16),
_popUpBoss(boss) {
// Copy the selection index
_selection = _popUpBoss->_selectedItem;
// Calculate real popup dimensions
_x = _popUpBoss->_boss->getX() + _popUpBoss->_x;
_y = _popUpBoss->_boss->getY() + _popUpBoss->_y - _popUpBoss->_selectedItem * kLineHeight;
_h = _popUpBoss->_entries.size() * kLineHeight + 2;
_w = _popUpBoss->_w - 10;
// Perform clipping / switch to scrolling mode if we don't fit on the screen
// FIXME - hard coded screen height 200. We really need an API in OSystem to query the
// screen height, and also OSystem should send out notification messages when the screen
// resolution changes... we could generalize CommandReceiver and CommandSender.
if (_h >= 200)
_h = 199;
if (_y < 0)
_y = 0;
else if (_y + _h >= 200)
_y = 199 - _h;
// TODO - implement scrolling if we had to move the menu, or if there are too many entries
// Remember original mouse position
_clickX = clickX - _x;
_clickY = clickY - _y;
// Time the popup was opened
_openTime = g_system->get_msecs();
}
void PopUpDialog::drawDialog() {
// Draw the menu border
g_gui.hLine(_x, _y, _x+_w - 1, g_gui._color);
g_gui.hLine(_x, _y + _h - 1, _x + _w - 1, g_gui._shadowcolor);
g_gui.vLine(_x, _y, _y+_h - 1, g_gui._color);
g_gui.vLine(_x + _w - 1, _y, _y + _h - 1, g_gui._shadowcolor);
// Draw the entries
int count = _popUpBoss->_entries.size();
for (int i = 0; i < count; i++) {
drawMenuEntry(i, i == _selection);
}
g_gui.addDirtyRect(_x, _y, _w, _h);
}
void PopUpDialog::handleMouseUp(int x, int y, int button, int clickCount) {
// Mouse was released. If it wasn't moved much since the original mouse down,
// let the popup stay open. If it did move, assume the user made his selection.
int dist = (_clickX - x) * (_clickX - x) + (_clickY - y) * (_clickY - y);
if (dist > 3 * 3 || g_system->get_msecs() - _openTime > 300) {
setResult(_selection);
close();
}
_clickX = -1;
_clickY = -1;
_openTime = (uint32)-1;
}
void PopUpDialog::handleMouseWheel(int x, int y, int direction) {
if (direction < 0)
moveUp();
else if (direction > 0)
moveDown();
}
void PopUpDialog::handleMouseMoved(int x, int y, int button) {
// Compute over which item the mouse is...
int item = findItem(x, y);
if (item >= 0 && _popUpBoss->_entries[item].name.size() == 0)
item = -1;
if (item == -1 && !isMouseDown())
return;
// ...and update the selection accordingly
setSelection(item);
}
void PopUpDialog::handleKeyDown(uint16 ascii, int keycode, int modifiers) {
if (keycode == 27) { // escape
close();
return;
}
if (isMouseDown())
return;
switch (keycode) {
case '\n': // enter/return
case '\r':
setResult(_selection);
close();
break;
case 256+17: // up arrow
moveUp();
break;
case 256+18: // down arrow
moveDown();
break;
case 256+22: // home
setSelection(0);
break;
case 256+23: // end
setSelection(_popUpBoss->_entries.size()-1);
break;
}
}
int PopUpDialog::findItem(int x, int y) const {
if (x >= 0 && x < _w && y >= 0 && y < _h) {
return (y-2) / kLineHeight;
}
return -1;
}
void PopUpDialog::setSelection(int item) {
if (item != _selection) {
// Undraw old selection
if (_selection >= 0)
drawMenuEntry(_selection, false);
// Change selection
_selection = item;
// Draw new selection
if (item >= 0)
drawMenuEntry(item, true);
}
}
bool PopUpDialog::isMouseDown() {
// TODO/FIXME - need a way to determine whether any mouse buttons are pressed or not.
// Sure, we could just count mouse button up/down events, but that is cumbersome and
// error prone. Would be much nicer to add an API to OSystem for this...
return false;
}
void PopUpDialog::moveUp() {
if (_selection < 0) {
setSelection(_popUpBoss->_entries.size() - 1);
} else if (_selection > 0) {
int item = _selection;
do {
item--;
} while (item >= 0 && _popUpBoss->_entries[item].name.size() == 0);
if (item >= 0)
setSelection(item);
}
}
void PopUpDialog::moveDown() {
int lastItem = _popUpBoss->_entries.size() - 1;
if (_selection < 0) {
setSelection(0);
} else if (_selection < lastItem) {
int item = _selection;
do {
item++;
} while (item <= lastItem && _popUpBoss->_entries[item].name.size() == 0);
if (item <= lastItem)
setSelection(item);
}
}
void PopUpDialog::drawMenuEntry(int entry, bool hilite) {
// Draw one entry of the popup menu, including selection
assert(entry >= 0);
int x = _x + 1;
int y = _y + 1 + kLineHeight * entry;
int w = _w - 2;
Common::String &name = _popUpBoss->_entries[entry].name;
g_gui.fillRect(x, y, w, kLineHeight, hilite ? g_gui._textcolorhi : g_gui._bgcolor);
if (name.size() == 0) {
// Draw a seperator
g_gui.hLine(x, y + kLineHeight / 2, x + w - 1, g_gui._color);
g_gui.hLine(x + 1, y + 1 + kLineHeight / 2, x + w - 1, g_gui._shadowcolor);
} else {
g_gui.drawString(name, x + 1, y + 2, w - 2, hilite ? g_gui._bgcolor : g_gui._textcolor);
}
g_gui.addDirtyRect(x, y, w, kLineHeight);
}
#pragma mark -
//
// PopUpWidget
//
PopUpWidget::PopUpWidget(GuiObject *boss, int x, int y, int w, int h)
: Widget(boss, x, y - 1, w, h + 2), CommandSender(boss) {
_flags = WIDGET_ENABLED | WIDGET_CLEARBG | WIDGET_RETAIN_FOCUS;
_type = 'POPU';
_selectedItem = -1;
}
void PopUpWidget::handleMouseDown(int x, int y, int button, int clickCount) {
if (isEnabled()) {
PopUpDialog popupDialog(this, x + _x + _boss->getX(), y + _y + _boss->getY());
int newSel = popupDialog.runModal();
if (newSel != -1 && _selectedItem != newSel) {
_selectedItem = newSel;
sendCommand(kPopUpItemSelectedCmd, _entries[_selectedItem].tag);
}
}
}
void PopUpWidget::appendEntry(const String &entry, uint32 tag) {
Entry e;
e.name = entry;
e.tag = tag;
_entries.push_back(e);
}
void PopUpWidget::clearEntries() {
_entries.clear();
_selectedItem = -1;
}
void PopUpWidget::setSelected(int item) {
// FIXME
if (item != _selectedItem) {
if (item >= 0 && item < _entries.size()) {
_selectedItem = item;
} else {
_selectedItem = -1;
}
}
}
void PopUpWidget::drawWidget(bool hilite) {
NewGui *gui = &g_gui;
// Draw a thin frame around us.
// TODO - should look different than the EditTextWidget fram
gui->hLine(_x, _y, _x + _w - 1, gui->_color);
gui->hLine(_x, _y +_h-1, _x + _w - 1, gui->_shadowcolor);
gui->vLine(_x, _y, _y+_h-1, gui->_color);
gui->vLine(_x + _w - 1, _y, _y +_h - 1, gui->_shadowcolor);
// Draw an arrow pointing down at the right end to signal this is a dropdown/popup
gui->drawBitmap(up_down_arrows, _x+_w - 10, _y+2, !isEnabled() ? gui->_color : hilite ? gui->_textcolorhi : gui->_textcolor);
// Draw the selected entry, if any
if (_selectedItem >= 0) {
int align = (gui->getStringWidth(_entries[_selectedItem].name) > _w-6) ? kTextAlignRight : kTextAlignLeft;
gui->drawString(_entries[_selectedItem].name, _x+2, _y+3, _w-6, !isEnabled() ? gui->_color : gui->_textcolor, align);
}
}
|