[J-u-boot.git] / boot / scene_menu.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Implementation of a menu in a scene
 *
 * Copyright 2022 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY	LOGC_EXPO

#include <dm.h>
#include <expo.h>
#include <malloc.h>
#include <mapmem.h>
#include <menu.h>
#include <video.h>
#include <video_console.h>
#include <linux/input.h>
#include "scene_internal.h"

static void scene_menuitem_destroy(struct scene_menitem *item)
{
	free(item->name);
	free(item);
}

void scene_menu_destroy(struct scene_obj_menu *menu)
{
	struct scene_menitem *item, *next;

	list_for_each_entry_safe(item, next, &menu->item_head, sibling)
		scene_menuitem_destroy(item);
}

struct scene_menitem *scene_menuitem_find(const struct scene_obj_menu *menu,
					  int id)
{
	struct scene_menitem *item;

	list_for_each_entry(item, &menu->item_head, sibling) {
		if (item->id == id)
			return item;
	}

	return NULL;
}

struct scene_menitem *scene_menuitem_find_seq(const struct scene_obj_menu *menu,
					      uint seq)
{
	struct scene_menitem *item;
	uint i;

	i = 0;
	list_for_each_entry(item, &menu->item_head, sibling) {
		if (i == seq)
			return item;
		i++;
	}

	return NULL;
}

/**
 * update_pointers() - Update the pointer object and handle highlights
 *
 * @menu: Menu to update
 * @id: ID of menu item to select/deselect
 * @point: true if @id is being selected, false if it is being deselected
 */
static int update_pointers(struct scene_obj_menu *menu, uint id, bool point)
{
	struct scene *scn = menu->obj.scene;
	const bool stack = scn->expo->popup;
	const struct scene_menitem *item;
	int ret;

	item = scene_menuitem_find(menu, id);
	if (!item)
		return log_msg_ret("itm", -ENOENT);

	/* adjust the pointer object to point to the selected item */
	if (menu->pointer_id && item && point) {
		struct scene_obj *label;

		label = scene_obj_find(scn, item->label_id, SCENEOBJT_NONE);

		ret = scene_obj_set_pos(scn, menu->pointer_id,
					menu->obj.dim.x + 200, label->dim.y);
		if (ret < 0)
			return log_msg_ret("ptr", ret);
	}

	if (stack) {
		point &= scn->highlight_id == menu->obj.id;
		scene_obj_flag_clrset(scn, item->label_id, SCENEOF_POINT,
				      point ? SCENEOF_POINT : 0);
	}

	return 0;
}

/**
 * menu_point_to_item() - Point to a particular menu item
 *
 * Sets the currently pointed-to / highlighted menu item
 */
static void menu_point_to_item(struct scene_obj_menu *menu, uint item_id)
{
	if (menu->cur_item_id)
		update_pointers(menu, menu->cur_item_id, false);
	menu->cur_item_id = item_id;
	update_pointers(menu, item_id, true);
}

void scene_menu_calc_bbox(struct scene_obj_menu *menu,
			  struct vidconsole_bbox *bbox,
			  struct vidconsole_bbox *label_bbox)
{
	const struct expo_theme *theme = &menu->obj.scene->expo->theme;
	const struct scene_menitem *item;

	bbox->valid = false;
	scene_bbox_union(menu->obj.scene, menu->title_id, 0, bbox);

	label_bbox->valid = false;

	list_for_each_entry(item, &menu->item_head, sibling) {
		scene_bbox_union(menu->obj.scene, item->label_id,
				 theme->menu_inset, bbox);
		scene_bbox_union(menu->obj.scene, item->key_id, 0, bbox);
		scene_bbox_union(menu->obj.scene, item->desc_id, 0, bbox);
		scene_bbox_union(menu->obj.scene, item->preview_id, 0, bbox);

		/* Get the bounding box of all labels */
		scene_bbox_union(menu->obj.scene, item->label_id,
				 theme->menu_inset, label_bbox);
	}

	/*
	 * subtract the final menuitem's gap to keep the insert the same top
	 * and bottom
	 */
	label_bbox->y1 -= theme->menuitem_gap_y;
}

int scene_menu_calc_dims(struct scene_obj_menu *menu)
{
	struct vidconsole_bbox bbox, label_bbox;
	const struct scene_menitem *item;

	scene_menu_calc_bbox(menu, &bbox, &label_bbox);

	/* Make all labels the same size */
	if (label_bbox.valid) {
		list_for_each_entry(item, &menu->item_head, sibling) {
			scene_obj_set_size(menu->obj.scene, item->label_id,
					   label_bbox.x1 - label_bbox.x0,
					   label_bbox.y1 - label_bbox.y0);
		}
	}

	if (bbox.valid) {
		menu->obj.dim.w = bbox.x1 - bbox.x0;
		menu->obj.dim.h = bbox.y1 - bbox.y0;
	}

	return 0;
}

int scene_menu_arrange(struct scene *scn, struct scene_obj_menu *menu)
{
	const bool open = menu->obj.flags & SCENEOF_OPEN;
	struct expo *exp = scn->expo;
	const bool stack = exp->popup;
	const struct expo_theme *theme = &exp->theme;
	struct scene_menitem *item;
	uint sel_id;
	int x, y;
	int ret;

	x = menu->obj.dim.x;
	y = menu->obj.dim.y;
	if (menu->title_id) {
		ret = scene_obj_set_pos(scn, menu->title_id, menu->obj.dim.x, y);
		if (ret < 0)
			return log_msg_ret("tit", ret);

		ret = scene_obj_get_hw(scn, menu->title_id, NULL);
		if (ret < 0)
			return log_msg_ret("hei", ret);

		if (stack)
			x += 200;
		else
			y += ret * 2;
	}

	/*
	 * Currently everything is hard-coded to particular columns so this
	 * won't work on small displays and looks strange if the font size is
	 * small. This can be updated once text measuring is supported in
	 * vidconsole
	 */
	sel_id = menu->cur_item_id;
	list_for_each_entry(item, &menu->item_head, sibling) {
		bool selected;
		int height;

		ret = scene_obj_get_hw(scn, item->label_id, NULL);
		if (ret < 0)
			return log_msg_ret("get", ret);
		height = ret;

		if (item->flags & SCENEMIF_GAP_BEFORE)
			y += height;

		/* select an item if not done already */
		if (!sel_id)
			sel_id = item->id;

		selected = sel_id == item->id;

		/*
		 * Put the label on the left, then leave a space for the
		 * pointer, then the key and the description
		 */
		ret = scene_obj_set_pos(scn, item->label_id,
					x + theme->menu_inset, y);
		if (ret < 0)
			return log_msg_ret("nam", ret);
		scene_obj_set_hide(scn, item->label_id,
				   stack && !open && !selected);

		if (item->key_id) {
			ret = scene_obj_set_pos(scn, item->key_id, x + 230, y);
			if (ret < 0)
				return log_msg_ret("key", ret);
		}

		if (item->desc_id) {
			ret = scene_obj_set_pos(scn, item->desc_id, x + 280, y);
			if (ret < 0)
				return log_msg_ret("des", ret);
		}

		if (item->preview_id) {
			bool hide;

			/*
			 * put all previews on top of each other, on the right
			 * size of the display
			 */
			ret = scene_obj_set_pos(scn, item->preview_id, -4, y);
			if (ret < 0)
				return log_msg_ret("prev", ret);

			hide = menu->cur_item_id != item->id;
			ret = scene_obj_set_hide(scn, item->preview_id, hide);
			if (ret < 0)
				return log_msg_ret("hid", ret);
		}

		if (!stack || open)
			y += height + theme->menuitem_gap_y;
	}

	if (sel_id)
		menu_point_to_item(menu, sel_id);

	return 0;
}

int scene_menu(struct scene *scn, const char *name, uint id,
	       struct scene_obj_menu **menup)
{
	struct scene_obj_menu *menu;
	int ret;

	ret = scene_obj_add(scn, name, id, SCENEOBJT_MENU,
			    sizeof(struct scene_obj_menu),
			    (struct scene_obj **)&menu);
	if (ret < 0)
		return log_msg_ret("obj", -ENOMEM);

	if (menup)
		*menup = menu;
	INIT_LIST_HEAD(&menu->item_head);

	return menu->obj.id;
}

static struct scene_menitem *scene_menu_find_key(struct scene *scn,
						  struct scene_obj_menu *menu,
						  int key)
{
	struct scene_menitem *item;

	list_for_each_entry(item, &menu->item_head, sibling) {
		if (item->key_id) {
			struct scene_obj_txt *txt;
			const char *str;

			txt = scene_obj_find(scn, item->key_id, SCENEOBJT_TEXT);
			if (txt) {
				str = expo_get_str(scn->expo, txt->str_id);
				if (str && *str == key)
					return item;
			}
		}
	}

	return NULL;
}

int scene_menu_send_key(struct scene *scn, struct scene_obj_menu *menu, int key,
			struct expo_action *event)
{
	const bool open = menu->obj.flags & SCENEOF_OPEN;
	struct scene_menitem *item, *cur, *key_item;

	cur = NULL;
	key_item = NULL;

	if (!list_empty(&menu->item_head)) {
		list_for_each_entry(item, &menu->item_head, sibling) {
			/* select an item if not done already */
			if (menu->cur_item_id == item->id) {
				cur = item;
				break;
			}
		}
	}

	if (!cur)
		return -ENOTTY;

	switch (key) {
	case BKEY_UP:
		if (item != list_first_entry(&menu->item_head,
					     struct scene_menitem, sibling)) {
			item = list_entry(item->sibling.prev,
					  struct scene_menitem, sibling);
			event->type = EXPOACT_POINT_ITEM;
			event->select.id = item->id;
			log_debug("up to item %d\n", event->select.id);
		}
		break;
	case BKEY_DOWN:
		if (!list_is_last(&item->sibling, &menu->item_head)) {
			item = list_entry(item->sibling.next,
					  struct scene_menitem, sibling);
			event->type = EXPOACT_POINT_ITEM;
			event->select.id = item->id;
			log_debug("down to item %d\n", event->select.id);
		}
		break;
	case BKEY_SELECT:
		event->type = EXPOACT_SELECT;
		event->select.id = item->id;
		log_debug("select item %d\n", event->select.id);
		break;
	case BKEY_QUIT:
		if (scn->expo->popup && open) {
			event->type = EXPOACT_CLOSE;
			event->select.id = menu->obj.id;
		} else {
			event->type = EXPOACT_QUIT;
			log_debug("menu quit\n");
		}
		break;
	case '0'...'9':
		key_item = scene_menu_find_key(scn, menu, key);
		if (key_item) {
			event->type = EXPOACT_SELECT;
			event->select.id = key_item->id;
		}
		break;
	}

	menu_point_to_item(menu, item->id);

	return 0;
}

int scene_menuitem(struct scene *scn, uint menu_id, const char *name, uint id,
		   uint key_id, uint label_id, uint desc_id, uint preview_id,
		   uint flags, struct scene_menitem **itemp)
{
	struct scene_obj_menu *menu;
	struct scene_menitem *item;

	menu = scene_obj_find(scn, menu_id, SCENEOBJT_MENU);
	if (!menu)
		return log_msg_ret("find", -ENOENT);

	/* Check that the text ID is valid */
	if (!scene_obj_find(scn, label_id, SCENEOBJT_TEXT))
		return log_msg_ret("txt", -EINVAL);

	item = calloc(1, sizeof(struct scene_menitem));
	if (!item)
		return log_msg_ret("item", -ENOMEM);
	item->name = strdup(name);
	if (!item->name) {
		free(item);
		return log_msg_ret("name", -ENOMEM);
	}

	item->id = resolve_id(scn->expo, id);
	item->key_id = key_id;
	item->label_id = label_id;
	item->desc_id = desc_id;
	item->preview_id = preview_id;
	item->flags = flags;
	list_add_tail(&item->sibling, &menu->item_head);

	if (itemp)
		*itemp = item;

	return item->id;
}

int scene_menu_set_title(struct scene *scn, uint id, uint title_id)
{
	struct scene_obj_menu *menu;
	struct scene_obj_txt *txt;

	menu = scene_obj_find(scn, id, SCENEOBJT_MENU);
	if (!menu)
		return log_msg_ret("menu", -ENOENT);

	/* Check that the ID is valid */
	if (title_id) {
		txt = scene_obj_find(scn, title_id, SCENEOBJT_TEXT);
		if (!txt)
			return log_msg_ret("txt", -EINVAL);
	}

	menu->title_id = title_id;

	return 0;
}

int scene_menu_set_pointer(struct scene *scn, uint id, uint pointer_id)
{
	struct scene_obj_menu *menu;
	struct scene_obj *obj;

	menu = scene_obj_find(scn, id, SCENEOBJT_MENU);
	if (!menu)
		return log_msg_ret("menu", -ENOENT);

	/* Check that the ID is valid */
	if (pointer_id) {
		obj = scene_obj_find(scn, pointer_id, SCENEOBJT_NONE);
		if (!obj)
			return log_msg_ret("obj", -EINVAL);
	}

	menu->pointer_id = pointer_id;

	return 0;
}

int scene_menu_display(struct scene_obj_menu *menu)
{
	struct scene *scn = menu->obj.scene;
	struct scene_obj_txt *pointer;
	struct expo *exp = scn->expo;
	struct scene_menitem *item;
	const char *pstr;

	printf("U-Boot    :    Boot Menu\n\n");
	if (menu->title_id) {
		struct scene_obj_txt *txt;
		const char *str;

		txt = scene_obj_find(scn, menu->title_id, SCENEOBJT_TEXT);
		if (!txt)
			return log_msg_ret("txt", -EINVAL);

		str = expo_get_str(exp, txt->str_id);
		printf("%s\n\n", str);
	}

	if (list_empty(&menu->item_head))
		return 0;

	pointer = scene_obj_find(scn, menu->pointer_id, SCENEOBJT_TEXT);
	pstr = expo_get_str(scn->expo, pointer->str_id);

	list_for_each_entry(item, &menu->item_head, sibling) {
		struct scene_obj_txt *key = NULL, *label = NULL;
		struct scene_obj_txt *desc = NULL;
		const char *kstr = NULL, *lstr = NULL, *dstr = NULL;

		key = scene_obj_find(scn, item->key_id, SCENEOBJT_TEXT);
		if (key)
			kstr = expo_get_str(exp, key->str_id);

		label = scene_obj_find(scn, item->label_id, SCENEOBJT_TEXT);
		if (label)
			lstr = expo_get_str(exp, label->str_id);

		desc = scene_obj_find(scn, item->desc_id, SCENEOBJT_TEXT);
		if (desc)
			dstr = expo_get_str(exp, desc->str_id);

		printf("%3s  %3s  %-10s  %s\n",
		       pointer && menu->cur_item_id == item->id ? pstr : "",
		       kstr, lstr, dstr);
	}

	return -ENOTSUPP;
}

int scene_menu_render_deps(struct scene *scn, struct scene_obj_menu *menu)
{
	struct scene_menitem *item;

	scene_render_deps(scn, menu->title_id);
	scene_render_deps(scn, menu->cur_item_id);
	scene_render_deps(scn, menu->pointer_id);

	list_for_each_entry(item, &menu->item_head, sibling) {
		scene_render_deps(scn, item->key_id);
		scene_render_deps(scn, item->label_id);
		scene_render_deps(scn, item->desc_id);
	}

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