src/util/gui/menu.c (view raw)
1/* Copyright (c) 2013-2015 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "menu.h"
7
8#include "util/gui.h"
9#include "util/gui/font.h"
10
11#ifdef _3DS
12#include <3ds.h>
13#endif
14
15DEFINE_VECTOR(GUIMenuItemList, struct GUIMenuItem);
16
17enum GUIMenuExitReason GUIShowMenu(struct GUIParams* params, struct GUIMenu* menu, struct GUIMenuItem** item) {
18 size_t start = 0;
19 size_t lineHeight = GUIFontHeight(params->font);
20 size_t pageSize = params->height / lineHeight;
21 if (pageSize > 4) {
22 pageSize -= 4;
23 } else {
24 pageSize = 1;
25 }
26 int cursorOverItem = 0;
27
28 GUIInvalidateKeys(params);
29 while (true) {
30#ifdef _3DS
31 if (!aptMainLoop()) {
32 return GUI_MENU_EXIT_CANCEL;
33 }
34#endif
35 uint32_t newInput = 0;
36 GUIPollInput(params, &newInput, 0);
37 unsigned cx, cy;
38 enum GUICursorState cursor = GUIPollCursor(params, &cx, &cy);
39
40 if (newInput & (1 << GUI_INPUT_UP) && menu->index > 0) {
41 --menu->index;
42 }
43 if (newInput & (1 << GUI_INPUT_DOWN) && menu->index < GUIMenuItemListSize(&menu->items) - 1) {
44 ++menu->index;
45 }
46 if (newInput & (1 << GUI_INPUT_LEFT)) {
47 struct GUIMenuItem* item = GUIMenuItemListGetPointer(&menu->items, menu->index);
48 if (item->validStates) {
49 if (item->state > 0) {
50 unsigned oldState = item->state;
51 do {
52 --item->state;
53 } while (!item->validStates[item->state] && item->state > 0);
54 if (!item->validStates[item->state]) {
55 item->state = oldState;
56 }
57 }
58 } else if (menu->index >= pageSize) {
59 menu->index -= pageSize;
60 } else {
61 menu->index = 0;
62 }
63 }
64 if (newInput & (1 << GUI_INPUT_RIGHT)) {
65 struct GUIMenuItem* item = GUIMenuItemListGetPointer(&menu->items, menu->index);
66 if (item->validStates) {
67 if (item->state < item->nStates - 1) {
68 unsigned oldState = item->state;
69 do {
70 ++item->state;
71 } while (!item->validStates[item->state] && item->state < item->nStates - 1);
72 if (!item->validStates[item->state]) {
73 item->state = oldState;
74 }
75 }
76 } else if (menu->index + pageSize < GUIMenuItemListSize(&menu->items)) {
77 menu->index += pageSize;
78 } else {
79 menu->index = GUIMenuItemListSize(&menu->items) - 1;
80 }
81 }
82 if (cursor != GUI_CURSOR_NOT_PRESENT) {
83 if (cx < params->width - 16) {
84 int index = (cy / lineHeight) - 2;
85 if (index >= 0 && index + start < GUIMenuItemListSize(&menu->items)) {
86 if (menu->index != index + start || !cursorOverItem) {
87 cursorOverItem = 1;
88 }
89 menu->index = index + start;
90 } else {
91 cursorOverItem = 0;
92 }
93 } else if (cursor == GUI_CURSOR_DOWN || cursor == GUI_CURSOR_DRAGGING) {
94 if (cy <= 2 * lineHeight && cy > lineHeight && menu->index > 0) {
95 --menu->index;
96 } else if (cy <= params->height && cy > params->height - lineHeight && menu->index < GUIMenuItemListSize(&menu->items) - 1) {
97 ++menu->index;
98 } else if (cy <= params->height - lineHeight && cy > 2 * lineHeight) {
99 size_t location = cy - 2 * lineHeight;
100 location *= GUIMenuItemListSize(&menu->items) - 1;
101 menu->index = location / (params->height - 3 * lineHeight);
102 }
103 }
104 }
105
106 if (menu->index < start) {
107 start = menu->index;
108 }
109 while ((menu->index - start + 4) * lineHeight > params->height) {
110 ++start;
111 }
112 if (newInput & (1 << GUI_INPUT_CANCEL)) {
113 break;
114 }
115 if (newInput & (1 << GUI_INPUT_SELECT) || (cursorOverItem == 2 && cursor == GUI_CURSOR_CLICKED)) {
116 *item = GUIMenuItemListGetPointer(&menu->items, menu->index);
117 if ((*item)->submenu) {
118 enum GUIMenuExitReason reason = GUIShowMenu(params, (*item)->submenu, item);
119 if (reason != GUI_MENU_EXIT_BACK) {
120 return reason;
121 }
122 } else {
123 return GUI_MENU_EXIT_ACCEPT;
124 }
125 }
126 if (cursorOverItem == 1 && (cursor == GUI_CURSOR_UP || cursor == GUI_CURSOR_NOT_PRESENT)) {
127 cursorOverItem = 2;
128 }
129 if (newInput & (1 << GUI_INPUT_BACK)) {
130 return GUI_MENU_EXIT_BACK;
131 }
132
133 params->drawStart();
134 if (menu->background) {
135 menu->background->draw(menu->background, GUIMenuItemListGetPointer(&menu->items, menu->index)->data);
136 }
137 if (params->guiPrepare) {
138 params->guiPrepare();
139 }
140 unsigned y = lineHeight;
141 GUIFontPrint(params->font, 0, y, GUI_ALIGN_LEFT, 0xFFFFFFFF, menu->title);
142 if (menu->subtitle) {
143 GUIFontPrint(params->font, 0, y * 2, GUI_ALIGN_LEFT, 0xFFFFFFFF, menu->subtitle);
144 }
145 y += 2 * lineHeight;
146 size_t itemsPerScreen = (params->height - y) / lineHeight;
147 size_t i;
148 for (i = start; i < GUIMenuItemListSize(&menu->items); ++i) {
149 int color = 0xE0A0A0A0;
150 if (i == menu->index) {
151 color = 0xFFFFFFFF;
152 GUIFontDrawIcon(params->font, lineHeight * 0.8f, y, GUI_ALIGN_BOTTOM | GUI_ALIGN_RIGHT, GUI_ORIENT_0, 0xFFFFFFFF, GUI_ICON_POINTER);
153 }
154 struct GUIMenuItem* item = GUIMenuItemListGetPointer(&menu->items, i);
155 GUIFontPrint(params->font, lineHeight, y, GUI_ALIGN_LEFT, color, item->title);
156 if (item->validStates && item->validStates[item->state]) {
157 GUIFontPrintf(params->font, params->width, y, GUI_ALIGN_RIGHT, color, "%s ", item->validStates[item->state]);
158 }
159 y += lineHeight;
160 if (y + lineHeight > params->height) {
161 break;
162 }
163 }
164
165 if (itemsPerScreen < GUIMenuItemListSize(&menu->items)) {
166 size_t top = 2 * lineHeight;
167 size_t bottom = params->height - 8;
168 unsigned w;
169 unsigned right;
170 GUIFontIconMetrics(params->font, GUI_ICON_SCROLLBAR_BUTTON, &right, 0);
171 GUIFontIconMetrics(params->font, GUI_ICON_SCROLLBAR_TRACK, &w, 0);
172 right = (right - w) / 2;
173 GUIFontDrawIcon(params->font, params->width - 8, top, GUI_ALIGN_HCENTER | GUI_ALIGN_BOTTOM, GUI_ORIENT_VMIRROR, 0xFFFFFFFF, GUI_ICON_SCROLLBAR_BUTTON);
174 GUIFontDrawIconSize(params->font, params->width - right - 8, top, 0, bottom - top, 0xFFFFFFFF, GUI_ICON_SCROLLBAR_TRACK);
175 GUIFontDrawIcon(params->font, params->width - 8, bottom, GUI_ALIGN_HCENTER | GUI_ALIGN_TOP, GUI_ORIENT_0, 0xFFFFFFFF, GUI_ICON_SCROLLBAR_BUTTON);
176
177 y = menu->index * (bottom - top - 16) / GUIMenuItemListSize(&menu->items);
178 GUIFontDrawIcon(params->font, params->width - 8, top + y, GUI_ALIGN_HCENTER | GUI_ALIGN_TOP, GUI_ORIENT_0, 0xFFFFFFFF, GUI_ICON_SCROLLBAR_THUMB);
179 }
180
181 GUIDrawBattery(params);
182 GUIDrawClock(params);
183
184 if (cursor != GUI_CURSOR_NOT_PRESENT) {
185 GUIFontDrawIcon(params->font, cx, cy, GUI_ALIGN_HCENTER | GUI_ALIGN_TOP, GUI_ORIENT_0, 0xFFFFFFFF, GUI_ICON_CURSOR);
186 }
187
188 if (params->guiFinish) {
189 params->guiFinish();
190 }
191 params->drawEnd();
192 }
193 return GUI_MENU_EXIT_CANCEL;
194}
195
196enum GUICursorState GUIPollCursor(struct GUIParams* params, unsigned* x, unsigned* y) {
197 if (!params->pollCursor) {
198 return GUI_CURSOR_NOT_PRESENT;
199 }
200 enum GUICursorState state = params->pollCursor(x, y);
201 if (params->cursorState == GUI_CURSOR_DOWN) {
202 int dragX = *x - params->cx;
203 int dragY = *y - params->cy;
204 if (dragX * dragX + dragY * dragY > 25) {
205 params->cursorState = GUI_CURSOR_DRAGGING;
206 return GUI_CURSOR_DRAGGING;
207 }
208 if (state == GUI_CURSOR_UP || state == GUI_CURSOR_NOT_PRESENT) {
209 params->cursorState = GUI_CURSOR_UP;
210 return GUI_CURSOR_CLICKED;
211 }
212 } else {
213 params->cx = *x;
214 params->cy = *y;
215 }
216 if (params->cursorState == GUI_CURSOR_DRAGGING) {
217 if (state == GUI_CURSOR_UP || state == GUI_CURSOR_NOT_PRESENT) {
218 params->cursorState = GUI_CURSOR_UP;
219 return GUI_CURSOR_UP;
220 }
221 return GUI_CURSOR_DRAGGING;
222 }
223 params->cursorState = state;
224 return params->cursorState;
225}
226
227void GUIInvalidateKeys(struct GUIParams* params) {
228 for (int i = 0; i < GUI_INPUT_MAX; ++i) {
229 params->inputHistory[i] = 0;
230 }
231}
232
233void GUIDrawBattery(struct GUIParams* params) {
234 if (!params->batteryState) {
235 return;
236 }
237 int state = params->batteryState();
238 uint32_t color = 0xFF000000;
239 if (state == (BATTERY_CHARGING | BATTERY_FULL)) {
240 color |= 0xFFC060;
241 } else if (state & BATTERY_CHARGING) {
242 color |= 0x60FF60;
243 } else if (state >= BATTERY_HALF) {
244 color |= 0xFFFFFF;
245 } else if (state == BATTERY_LOW) {
246 color |= 0x30FFFF;
247 } else {
248 color |= 0x3030FF;
249 }
250
251 enum GUIIcon batteryIcon;
252 switch (state & ~BATTERY_CHARGING) {
253 case BATTERY_EMPTY:
254 batteryIcon = GUI_ICON_BATTERY_EMPTY;
255 break;
256 case BATTERY_LOW:
257 batteryIcon = GUI_ICON_BATTERY_LOW;
258 break;
259 case BATTERY_HALF:
260 batteryIcon = GUI_ICON_BATTERY_HALF;
261 break;
262 case BATTERY_HIGH:
263 batteryIcon = GUI_ICON_BATTERY_HIGH;
264 break;
265 case BATTERY_FULL:
266 batteryIcon = GUI_ICON_BATTERY_FULL;
267 break;
268 default:
269 batteryIcon = GUI_ICON_BATTERY_EMPTY;
270 break;
271 }
272
273 GUIFontDrawIcon(params->font, params->width, 0, GUI_ALIGN_RIGHT, GUI_ORIENT_0, color, batteryIcon);
274}
275
276void GUIDrawClock(struct GUIParams* params) {
277 char buffer[32];
278 time_t t = time(0);
279 struct tm tm;
280 localtime_r(&t, &tm);
281 strftime(buffer, sizeof(buffer), "%H:%M:%S", &tm);
282 GUIFontPrint(params->font, params->width / 2, GUIFontHeight(params->font), GUI_ALIGN_HCENTER, 0xFFFFFFFF, buffer);
283}