scene_menu.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Implementation of a menu in a scene
  4. *
  5. * Copyright 2022 Google LLC
  6. * Written by Simon Glass <sjg@chromium.org>
  7. */
  8. #define LOG_CATEGORY LOGC_EXPO
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <expo.h>
  12. #include <malloc.h>
  13. #include <mapmem.h>
  14. #include <menu.h>
  15. #include <video.h>
  16. #include <video_console.h>
  17. #include <linux/input.h>
  18. #include "scene_internal.h"
  19. static void scene_menuitem_destroy(struct scene_menitem *item)
  20. {
  21. free(item->name);
  22. free(item);
  23. }
  24. void scene_menu_destroy(struct scene_obj_menu *menu)
  25. {
  26. struct scene_menitem *item, *next;
  27. list_for_each_entry_safe(item, next, &menu->item_head, sibling)
  28. scene_menuitem_destroy(item);
  29. }
  30. static struct scene_menitem *scene_menuitem_find(struct scene_obj_menu *menu,
  31. int id)
  32. {
  33. struct scene_menitem *item;
  34. list_for_each_entry(item, &menu->item_head, sibling) {
  35. if (item->id == id)
  36. return item;
  37. }
  38. return NULL;
  39. }
  40. /**
  41. * update_pointers() - Update the pointer object and handle highlights
  42. *
  43. * @menu: Menu to update
  44. * @id: ID of menu item to select/deselect
  45. * @point: true if @id is being selected, false if it is being deselected
  46. */
  47. static int update_pointers(struct scene_obj_menu *menu, uint id, bool point)
  48. {
  49. struct scene *scn = menu->obj.scene;
  50. const bool stack = scn->expo->popup;
  51. const struct scene_menitem *item;
  52. int ret;
  53. item = scene_menuitem_find(menu, id);
  54. if (!item)
  55. return log_msg_ret("itm", -ENOENT);
  56. /* adjust the pointer object to point to the selected item */
  57. if (menu->pointer_id && item && point) {
  58. struct scene_obj *label;
  59. label = scene_obj_find(scn, item->label_id, SCENEOBJT_NONE);
  60. ret = scene_obj_set_pos(scn, menu->pointer_id,
  61. menu->obj.dim.x + 200, label->dim.y);
  62. if (ret < 0)
  63. return log_msg_ret("ptr", ret);
  64. }
  65. if (stack) {
  66. point &= scn->highlight_id == menu->obj.id;
  67. scene_obj_flag_clrset(scn, item->label_id, SCENEOF_POINT,
  68. point ? SCENEOF_POINT : 0);
  69. }
  70. return 0;
  71. }
  72. /**
  73. * menu_point_to_item() - Point to a particular menu item
  74. *
  75. * Sets the currently pointed-to / highlighted menu item
  76. */
  77. static void menu_point_to_item(struct scene_obj_menu *menu, uint item_id)
  78. {
  79. if (menu->cur_item_id)
  80. update_pointers(menu, menu->cur_item_id, false);
  81. menu->cur_item_id = item_id;
  82. update_pointers(menu, item_id, true);
  83. }
  84. static int scene_bbox_union(struct scene *scn, uint id, int inset,
  85. struct vidconsole_bbox *bbox)
  86. {
  87. struct scene_obj *obj;
  88. if (!id)
  89. return 0;
  90. obj = scene_obj_find(scn, id, SCENEOBJT_NONE);
  91. if (!obj)
  92. return log_msg_ret("obj", -ENOENT);
  93. if (bbox->valid) {
  94. bbox->x0 = min(bbox->x0, obj->dim.x - inset);
  95. bbox->y0 = min(bbox->y0, obj->dim.y);
  96. bbox->x1 = max(bbox->x1, obj->dim.x + obj->dim.w + inset);
  97. bbox->y1 = max(bbox->y1, obj->dim.y + obj->dim.h);
  98. } else {
  99. bbox->x0 = obj->dim.x - inset;
  100. bbox->y0 = obj->dim.y;
  101. bbox->x1 = obj->dim.x + obj->dim.w + inset;
  102. bbox->y1 = obj->dim.y + obj->dim.h;
  103. bbox->valid = true;
  104. }
  105. return 0;
  106. }
  107. /**
  108. * scene_menu_calc_bbox() - Calculate bounding boxes for the menu
  109. *
  110. * @menu: Menu to process
  111. * @bbox: Returns bounding box of menu including prompts
  112. * @label_bbox: Returns bounding box of labels
  113. */
  114. static void scene_menu_calc_bbox(struct scene_obj_menu *menu,
  115. struct vidconsole_bbox *bbox,
  116. struct vidconsole_bbox *label_bbox)
  117. {
  118. const struct expo_theme *theme = &menu->obj.scene->expo->theme;
  119. const struct scene_menitem *item;
  120. bbox->valid = false;
  121. scene_bbox_union(menu->obj.scene, menu->title_id, 0, bbox);
  122. label_bbox->valid = false;
  123. list_for_each_entry(item, &menu->item_head, sibling) {
  124. scene_bbox_union(menu->obj.scene, item->label_id,
  125. theme->menu_inset, bbox);
  126. scene_bbox_union(menu->obj.scene, item->key_id, 0, bbox);
  127. scene_bbox_union(menu->obj.scene, item->desc_id, 0, bbox);
  128. scene_bbox_union(menu->obj.scene, item->preview_id, 0, bbox);
  129. /* Get the bounding box of all labels */
  130. scene_bbox_union(menu->obj.scene, item->label_id,
  131. theme->menu_inset, label_bbox);
  132. }
  133. /*
  134. * subtract the final menuitem's gap to keep the insert the same top
  135. * and bottom
  136. */
  137. label_bbox->y1 -= theme->menuitem_gap_y;
  138. }
  139. int scene_menu_calc_dims(struct scene_obj_menu *menu)
  140. {
  141. struct vidconsole_bbox bbox, label_bbox;
  142. const struct scene_menitem *item;
  143. scene_menu_calc_bbox(menu, &bbox, &label_bbox);
  144. /* Make all labels the same size */
  145. if (label_bbox.valid) {
  146. list_for_each_entry(item, &menu->item_head, sibling) {
  147. scene_obj_set_size(menu->obj.scene, item->label_id,
  148. label_bbox.x1 - label_bbox.x0,
  149. label_bbox.y1 - label_bbox.y0);
  150. }
  151. }
  152. if (bbox.valid) {
  153. menu->obj.dim.w = bbox.x1 - bbox.x0;
  154. menu->obj.dim.h = bbox.y1 - bbox.y0;
  155. }
  156. return 0;
  157. }
  158. int scene_menu_arrange(struct scene *scn, struct scene_obj_menu *menu)
  159. {
  160. const bool open = menu->obj.flags & SCENEOF_OPEN;
  161. struct expo *exp = scn->expo;
  162. const bool stack = exp->popup;
  163. const struct expo_theme *theme = &exp->theme;
  164. struct scene_menitem *item;
  165. uint sel_id;
  166. int x, y;
  167. int ret;
  168. x = menu->obj.dim.x;
  169. y = menu->obj.dim.y;
  170. if (menu->title_id) {
  171. ret = scene_obj_set_pos(scn, menu->title_id, menu->obj.dim.x, y);
  172. if (ret < 0)
  173. return log_msg_ret("tit", ret);
  174. ret = scene_obj_get_hw(scn, menu->title_id, NULL);
  175. if (ret < 0)
  176. return log_msg_ret("hei", ret);
  177. if (stack)
  178. x += 200;
  179. else
  180. y += ret * 2;
  181. }
  182. /*
  183. * Currently everything is hard-coded to particular columns so this
  184. * won't work on small displays and looks strange if the font size is
  185. * small. This can be updated once text measuring is supported in
  186. * vidconsole
  187. */
  188. sel_id = menu->cur_item_id;
  189. list_for_each_entry(item, &menu->item_head, sibling) {
  190. bool selected;
  191. int height;
  192. ret = scene_obj_get_hw(scn, item->label_id, NULL);
  193. if (ret < 0)
  194. return log_msg_ret("get", ret);
  195. height = ret;
  196. if (item->flags & SCENEMIF_GAP_BEFORE)
  197. y += height;
  198. /* select an item if not done already */
  199. if (!sel_id)
  200. sel_id = item->id;
  201. selected = sel_id == item->id;
  202. /*
  203. * Put the label on the left, then leave a space for the
  204. * pointer, then the key and the description
  205. */
  206. ret = scene_obj_set_pos(scn, item->label_id,
  207. x + theme->menu_inset, y);
  208. if (ret < 0)
  209. return log_msg_ret("nam", ret);
  210. scene_obj_set_hide(scn, item->label_id,
  211. stack && !open && !selected);
  212. if (item->key_id) {
  213. ret = scene_obj_set_pos(scn, item->key_id, x + 230, y);
  214. if (ret < 0)
  215. return log_msg_ret("key", ret);
  216. }
  217. if (item->desc_id) {
  218. ret = scene_obj_set_pos(scn, item->desc_id, x + 280, y);
  219. if (ret < 0)
  220. return log_msg_ret("des", ret);
  221. }
  222. if (item->preview_id) {
  223. bool hide;
  224. /*
  225. * put all previews on top of each other, on the right
  226. * size of the display
  227. */
  228. ret = scene_obj_set_pos(scn, item->preview_id, -4, y);
  229. if (ret < 0)
  230. return log_msg_ret("prev", ret);
  231. hide = menu->cur_item_id != item->id;
  232. ret = scene_obj_set_hide(scn, item->preview_id, hide);
  233. if (ret < 0)
  234. return log_msg_ret("hid", ret);
  235. }
  236. if (!stack || open)
  237. y += height + theme->menuitem_gap_y;
  238. }
  239. if (sel_id)
  240. menu_point_to_item(menu, sel_id);
  241. return 0;
  242. }
  243. int scene_menu(struct scene *scn, const char *name, uint id,
  244. struct scene_obj_menu **menup)
  245. {
  246. struct scene_obj_menu *menu;
  247. int ret;
  248. ret = scene_obj_add(scn, name, id, SCENEOBJT_MENU,
  249. sizeof(struct scene_obj_menu),
  250. (struct scene_obj **)&menu);
  251. if (ret < 0)
  252. return log_msg_ret("obj", -ENOMEM);
  253. if (menup)
  254. *menup = menu;
  255. INIT_LIST_HEAD(&menu->item_head);
  256. return menu->obj.id;
  257. }
  258. static struct scene_menitem *scene_menu_find_key(struct scene *scn,
  259. struct scene_obj_menu *menu,
  260. int key)
  261. {
  262. struct scene_menitem *item;
  263. list_for_each_entry(item, &menu->item_head, sibling) {
  264. if (item->key_id) {
  265. struct scene_obj_txt *txt;
  266. const char *str;
  267. txt = scene_obj_find(scn, item->key_id, SCENEOBJT_TEXT);
  268. if (txt) {
  269. str = expo_get_str(scn->expo, txt->str_id);
  270. if (str && *str == key)
  271. return item;
  272. }
  273. }
  274. }
  275. return NULL;
  276. }
  277. int scene_menu_send_key(struct scene *scn, struct scene_obj_menu *menu, int key,
  278. struct expo_action *event)
  279. {
  280. const bool open = menu->obj.flags & SCENEOF_OPEN;
  281. struct scene_menitem *item, *cur, *key_item;
  282. cur = NULL;
  283. key_item = NULL;
  284. if (!list_empty(&menu->item_head)) {
  285. list_for_each_entry(item, &menu->item_head, sibling) {
  286. /* select an item if not done already */
  287. if (menu->cur_item_id == item->id) {
  288. cur = item;
  289. break;
  290. }
  291. }
  292. }
  293. if (!cur)
  294. return -ENOTTY;
  295. switch (key) {
  296. case BKEY_UP:
  297. if (item != list_first_entry(&menu->item_head,
  298. struct scene_menitem, sibling)) {
  299. item = list_entry(item->sibling.prev,
  300. struct scene_menitem, sibling);
  301. event->type = EXPOACT_POINT_ITEM;
  302. event->select.id = item->id;
  303. log_debug("up to item %d\n", event->select.id);
  304. }
  305. break;
  306. case BKEY_DOWN:
  307. if (!list_is_last(&item->sibling, &menu->item_head)) {
  308. item = list_entry(item->sibling.next,
  309. struct scene_menitem, sibling);
  310. event->type = EXPOACT_POINT_ITEM;
  311. event->select.id = item->id;
  312. log_debug("down to item %d\n", event->select.id);
  313. }
  314. break;
  315. case BKEY_SELECT:
  316. event->type = EXPOACT_SELECT;
  317. event->select.id = item->id;
  318. log_debug("select item %d\n", event->select.id);
  319. break;
  320. case BKEY_QUIT:
  321. if (scn->expo->popup && open) {
  322. event->type = EXPOACT_CLOSE;
  323. event->select.id = menu->obj.id;
  324. } else {
  325. event->type = EXPOACT_QUIT;
  326. log_debug("menu quit\n");
  327. }
  328. break;
  329. case '0'...'9':
  330. key_item = scene_menu_find_key(scn, menu, key);
  331. if (key_item) {
  332. event->type = EXPOACT_SELECT;
  333. event->select.id = key_item->id;
  334. }
  335. break;
  336. }
  337. menu_point_to_item(menu, item->id);
  338. return 0;
  339. }
  340. int scene_menuitem(struct scene *scn, uint menu_id, const char *name, uint id,
  341. uint key_id, uint label_id, uint desc_id, uint preview_id,
  342. uint flags, struct scene_menitem **itemp)
  343. {
  344. struct scene_obj_menu *menu;
  345. struct scene_menitem *item;
  346. menu = scene_obj_find(scn, menu_id, SCENEOBJT_MENU);
  347. if (!menu)
  348. return log_msg_ret("find", -ENOENT);
  349. /* Check that the text ID is valid */
  350. if (!scene_obj_find(scn, label_id, SCENEOBJT_TEXT))
  351. return log_msg_ret("txt", -EINVAL);
  352. item = calloc(1, sizeof(struct scene_obj_menu));
  353. if (!item)
  354. return log_msg_ret("item", -ENOMEM);
  355. item->name = strdup(name);
  356. if (!item->name) {
  357. free(item);
  358. return log_msg_ret("name", -ENOMEM);
  359. }
  360. item->id = resolve_id(scn->expo, id);
  361. item->key_id = key_id;
  362. item->label_id = label_id;
  363. item->desc_id = desc_id;
  364. item->preview_id = preview_id;
  365. item->flags = flags;
  366. list_add_tail(&item->sibling, &menu->item_head);
  367. if (itemp)
  368. *itemp = item;
  369. return item->id;
  370. }
  371. int scene_menu_set_title(struct scene *scn, uint id, uint title_id)
  372. {
  373. struct scene_obj_menu *menu;
  374. struct scene_obj_txt *txt;
  375. menu = scene_obj_find(scn, id, SCENEOBJT_MENU);
  376. if (!menu)
  377. return log_msg_ret("menu", -ENOENT);
  378. /* Check that the ID is valid */
  379. if (title_id) {
  380. txt = scene_obj_find(scn, title_id, SCENEOBJT_TEXT);
  381. if (!txt)
  382. return log_msg_ret("txt", -EINVAL);
  383. }
  384. menu->title_id = title_id;
  385. return 0;
  386. }
  387. int scene_menu_set_pointer(struct scene *scn, uint id, uint pointer_id)
  388. {
  389. struct scene_obj_menu *menu;
  390. struct scene_obj *obj;
  391. menu = scene_obj_find(scn, id, SCENEOBJT_MENU);
  392. if (!menu)
  393. return log_msg_ret("menu", -ENOENT);
  394. /* Check that the ID is valid */
  395. if (pointer_id) {
  396. obj = scene_obj_find(scn, pointer_id, SCENEOBJT_NONE);
  397. if (!obj)
  398. return log_msg_ret("obj", -EINVAL);
  399. }
  400. menu->pointer_id = pointer_id;
  401. return 0;
  402. }
  403. int scene_menu_display(struct scene_obj_menu *menu)
  404. {
  405. struct scene *scn = menu->obj.scene;
  406. struct scene_obj_txt *pointer;
  407. struct expo *exp = scn->expo;
  408. struct scene_menitem *item;
  409. const char *pstr;
  410. printf("U-Boot : Boot Menu\n\n");
  411. if (menu->title_id) {
  412. struct scene_obj_txt *txt;
  413. const char *str;
  414. txt = scene_obj_find(scn, menu->title_id, SCENEOBJT_TEXT);
  415. if (!txt)
  416. return log_msg_ret("txt", -EINVAL);
  417. str = expo_get_str(exp, txt->str_id);
  418. printf("%s\n\n", str);
  419. }
  420. if (list_empty(&menu->item_head))
  421. return 0;
  422. pointer = scene_obj_find(scn, menu->pointer_id, SCENEOBJT_TEXT);
  423. pstr = expo_get_str(scn->expo, pointer->str_id);
  424. list_for_each_entry(item, &menu->item_head, sibling) {
  425. struct scene_obj_txt *key = NULL, *label = NULL;
  426. struct scene_obj_txt *desc = NULL;
  427. const char *kstr = NULL, *lstr = NULL, *dstr = NULL;
  428. key = scene_obj_find(scn, item->key_id, SCENEOBJT_TEXT);
  429. if (key)
  430. kstr = expo_get_str(exp, key->str_id);
  431. label = scene_obj_find(scn, item->label_id, SCENEOBJT_TEXT);
  432. if (label)
  433. lstr = expo_get_str(exp, label->str_id);
  434. desc = scene_obj_find(scn, item->desc_id, SCENEOBJT_TEXT);
  435. if (desc)
  436. dstr = expo_get_str(exp, desc->str_id);
  437. printf("%3s %3s %-10s %s\n",
  438. pointer && menu->cur_item_id == item->id ? pstr : "",
  439. kstr, lstr, dstr);
  440. }
  441. return -ENOTSUPP;
  442. }
  443. void scene_menu_render(struct scene_obj_menu *menu)
  444. {
  445. struct expo *exp = menu->obj.scene->expo;
  446. const struct expo_theme *theme = &exp->theme;
  447. struct vidconsole_bbox bbox, label_bbox;
  448. struct udevice *dev = exp->display;
  449. struct video_priv *vid_priv;
  450. struct udevice *cons = exp->cons;
  451. struct vidconsole_colour old;
  452. enum colour_idx fore, back;
  453. if (CONFIG_IS_ENABLED(SYS_WHITE_ON_BLACK)) {
  454. fore = VID_BLACK;
  455. back = VID_WHITE;
  456. } else {
  457. fore = VID_LIGHT_GRAY;
  458. back = VID_BLACK;
  459. }
  460. scene_menu_calc_bbox(menu, &bbox, &label_bbox);
  461. vidconsole_push_colour(cons, fore, back, &old);
  462. vid_priv = dev_get_uclass_priv(dev);
  463. video_fill_part(dev, label_bbox.x0 - theme->menu_inset,
  464. label_bbox.y0 - theme->menu_inset,
  465. label_bbox.x1, label_bbox.y1 + theme->menu_inset,
  466. vid_priv->colour_fg);
  467. vidconsole_pop_colour(cons, &old);
  468. }
  469. int scene_menu_render_deps(struct scene *scn, struct scene_obj_menu *menu)
  470. {
  471. struct scene_menitem *item;
  472. scene_render_deps(scn, menu->title_id);
  473. scene_render_deps(scn, menu->cur_item_id);
  474. scene_render_deps(scn, menu->pointer_id);
  475. list_for_each_entry(item, &menu->item_head, sibling) {
  476. scene_render_deps(scn, item->key_id);
  477. scene_render_deps(scn, item->label_id);
  478. scene_render_deps(scn, item->desc_id);
  479. }
  480. return 0;
  481. }