/**
* get_menu_selection()
*
*/
int get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
#ifdef BOARD_WITH_CPCAP
int level = battery_level();
if (level > 0) {
if ((50 * progress_value) != level / 2) {
progress_value = level / 100.0;
if (level < 20)
ui_print("Low battery ! %3d %%\n", level);
ui_reset_progress();
ui_show_progress(progress_value, 1);
ui_set_progress(1.0);
}
}
#endif
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case ACTION_CANCEL:
chosen_item = GO_BACK;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
static int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
if (key == -1) { // ui_wait_key() timed out
if (ui_text_ever_visible()) {
continue;
} else {
LOGI("timed out waiting for key input; rebooting.\n");
ui_end_menu();
return ITEM_REBOOT;
}
}
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int get_menu_selection(char** headers, char** items, int menu_only, int selected) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items,selected);
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
/* char* key_str = calloc(18,sizeof(char));
sprintf(key_str, "Key %d pressed.\n", key);
ui_print(key_str);*/
if (key == KEY_BACKSPACE || key == KEY_END) {
return(ITEM_BACK);
}
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case ITEM_BACK:
return(ITEM_BACK);
break;
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int get_menu_selection(char** headers, char** items, int menu_only) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items);
int selected = 0;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
if(action == SELECT_BACK)
{
chosen_item = action;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
/**
* Display a menu.
*/
unsigned advance_ui_menu_done(struct ui_menu* menu, struct advance_ui_context* context, unsigned menu_sel)
{
unsigned count, i;
context->state.ui_menu_flag = 1;
free(context->state.ui_menu_map);
context->state.ui_menu_map = menu->map;
context->state.ui_menu_mac = menu->mac;
context->state.ui_menu_sel = menu_sel;
return ui_menu_select(menu);
}
unsigned advance_ui_menu_option_insert(struct ui_menu* menu, const char* text, const char* option)
{
struct ui_menu_entry* entry = &menu->map[menu->mac];
assert(menu->mac < menu->max);
if (menu->mac == menu->max)
return -1;
entry->type = ui_menu_option;
sncpy(entry->text_buffer, sizeof(entry->text_buffer), text);
sncpy(entry->option_buffer, sizeof(entry->option_buffer), option);
++menu->mac;
return ui_menu_select(menu) - 1;
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
int item_count = ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
// Some users with dead enter keys need a way to turn on power to select.
// Jiggering across the wrapping menu is one "secret" way to enable it.
// We can't rely on /cache or /sdcard since they may not be available.
int wrap_count = 0;
while (chosen_item < 0 && chosen_item != GO_BACK) {
int key = ui_wait_key();
int visible = ui_text_visible();
if (key == -1) { // ui_wait_key() timed out
if (ui_text_ever_visible()) {
continue;
} else {
LOGI("timed out waiting for key input; rebooting.\n");
ui_end_menu();
return ITEM_REBOOT;
}
}
int action = ui_handle_key(key, visible);
int old_selected = selected;
selected = ui_get_selected_item();
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
if (ui_is_showing_back_button()) {
if (chosen_item == item_count) {
chosen_item = GO_BACK;
}
}
break;
case NO_ACTION:
break;
case GO_BACK:
chosen_item = GO_BACK;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
ui_clear_key_queue();
return chosen_item;
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
while (chosen_item < 0) {
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case KEY_POWER:
case SELECT_ITEM:
chosen_item = selected;
break;
case UP_A_LEVEL:
if (menu_loc_idx != 0)
{
chosen_item = menu_loc[menu_loc_idx];
}
break;
case HOME_MENU:
if (menu_loc_idx != 0)
{
go_home = 1;
chosen_item = menu_loc[menu_loc_idx];
}
break;
case MENU_MENU:
if (menu_loc_idx == 0)
{
return 3;
} else
{
go_home = 1;
go_menu = 1;
chosen_item = menu_loc[menu_loc_idx];
}
break;
case NO_ACTION:
break;
}
} else if (!menu_only) {
chosen_item = action;
}
}
ui_end_menu();
return chosen_item;
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
int item_count = ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1;
// Some users with dead enter keys need a way to turn on power to select.
// Jiggering across the wrapping menu is one "secret" way to enable it.
// We can't rely on /cache or /sdcard since they may not be available.
int wrap_count = 0;
while (chosen_item < 0 && chosen_item != GO_BACK) {
struct keyStruct *key;
key = ui_wait_key();
int visible = ui_text_visible();
int action;
if(key->code == ABS_MT_POSITION_X)
action = device_handle_mouse(key, visible);
else
action = device_handle_key(key->code, visible);
int old_selected = selected;
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
if (ui_get_showing_back_button()) {
if (chosen_item == item_count) {
chosen_item = GO_BACK;
}
}
break;
case NO_ACTION:
break;
case GO_BACK:
chosen_item = GO_BACK;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
if (abs(selected - old_selected) > 1) {
wrap_count++;
if (wrap_count == 3) {
wrap_count = 0;
if (ui_get_showing_back_button()) {
ui_print("Back menu button disabled.\n");
ui_set_showing_back_button(0);
}
else {
ui_print("Back menu button enabled.\n");
ui_set_showing_back_button(1);
}
}
}
}
ui_end_menu();
ui_clear_key_queue();
return chosen_item;
}
// Button Task Entry Point
static portTASK_FUNCTION(btn_task, param)
{
(void) param;
// local vars
uint32_t btn_states = 0;
uint32_t new_btn_states = 0;
uint32_t pos_edges = 0;
uint32_t neg_edges = 0;
// keeps track of back button long press
BaseType_t last_back_btn_down_tick = xTaskGetTickCount();
bool was_longpress_back = false;
// init button states
btn_states = BTN_RD();
// task loop
while (true)
{
vTaskDelay(BUTTON_POLL_PERIOD_MS/portTICK_PERIOD_MS);
wdg_refresh(s_btn_task_wdg_handler);
// Read buttons, find rising edges, and save new button valuesR
new_btn_states = BTN_RD();
pos_edges = (~btn_states) & new_btn_states;
neg_edges = btn_states & (~new_btn_states);
btn_states = new_btn_states;
// SELECT button up
if(pos_edges & SEL_BTN_MASK)
{
ui_menu_select();
}
// BACK button up
if(pos_edges & BACK_BTN_MASK)
{
// Only execute menu back if not after long press
if(!was_longpress_back)
{
ui_menu_back();
}
was_longpress_back = false;
}
// DOWN button up
if(pos_edges & DOWN_BTN_MASK)
{
ui_increment_menu_position();
}
// BACK button down
if(neg_edges & BACK_BTN_MASK)
{
last_back_btn_down_tick = xTaskGetTickCount();
}
// BACK button long press
if(~btn_states & BACK_BTN_MASK)
{
uint32_t seconds_since_last_depress = seconds_since_last_depress = ((uint32_t)(xTaskGetTickCount() - last_back_btn_down_tick)) * portTICK_PERIOD_MS/1000;
if(seconds_since_last_depress > 5)
{
// Call wipe
if(NULL != s_wipe_callback)
{
s_wipe_callback();
}
// Refresh time latch
last_back_btn_down_tick = xTaskGetTickCount();
was_longpress_back = true;
}
}
}
}
int
get_menu_selection(char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
int item_count = ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1; // NO_ACTION
int wrap_count = 0;
while (chosen_item < 0 && chosen_item != GO_BACK) {
int key = ui_wait_key();
int visible = ui_text_visible();
if (key == -1) { // ui_wait_key() timed out
if (ui_text_ever_visible()) {
continue;
} else {
LOGI("timed out waiting for key input; rebooting.\n");
ui_end_menu();
return ITEM_REBOOT;
}
}
else if (key == -2) { // we are returning from ui_cancel_wait_key(): trigger a GO_BACK
return GO_BACK;
}
int action = ui_handle_key(key, visible);
int old_selected = selected;
selected = ui_get_selected_item();
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
if (ui_is_showing_back_button()) {
if (chosen_item == item_count) {
chosen_item = GO_BACK;
}
}
break;
case NO_ACTION:
break;
case GO_BACK:
chosen_item = GO_BACK;
break;
}
} else if (!menu_only) {
chosen_item = action;
}
if (abs(selected - old_selected) > 1) {
wrap_count++;
if (wrap_count == 5) {
wrap_count = 0;
if (ui_get_rainbow_mode()) {
ui_set_rainbow_mode(0);
ui_print("Rainbow mode disabled\n");
}
else {
ui_set_rainbow_mode(1);
ui_print("Rainbow mode enabled!\n");
}
}
}
}
ui_end_menu();
ui_clear_key_queue();
return chosen_item;
}
int
get_menu_selection(const char** headers, char** items, int menu_only,
int initial_selection) {
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
int item_count = ui_start_menu(headers, items, initial_selection);
int selected = initial_selection;
int chosen_item = -1; // NO_ACTION
#ifdef NOT_ENOUGH_RAINBOWS
int wrap_count = 0;
#endif
while (chosen_item < 0 && chosen_item != GO_BACK) {
int key = ui_wait_key();
int visible = ui_IsTextVisible();
if (key == -1) { // ui_wait_key() timed out, always reboot to main system
LOGI("timed out waiting for key input; rebooting.\n");
ui_end_menu();
reboot_main_system(ANDROID_RB_RESTART, 0, 0);
sleep(5);
LOGE("Failed to reboot system on timed out key input!!\n");
return GO_BACK;
}
else if (key == -2) { // we are returning from ui_cancel_wait_key(): trigger a GO_BACK
return GO_BACK;
}
else if (key == -3) { // an USB device was plugged in (returning from ui_wait_key())
return REFRESH;
}
int action = ui_handle_key(key, visible);
int old_selected = selected;
selected = ui_get_selected_item();
if (action < 0) {
switch (action) {
case HIGHLIGHT_UP:
--selected;
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
++selected;
selected = ui_menu_select(selected);
break;
#ifdef PHILZ_TOUCH_RECOVERY
case HIGHLIGHT_ON_TOUCH:
selected = ui_menu_touch_select();
break;
#endif
case SELECT_ITEM:
chosen_item = selected;
if (ui_is_showing_back_button()) {
if (chosen_item == item_count) {
chosen_item = GO_BACK;
}
}
break;
case NO_ACTION:
break;
case GO_BACK:
chosen_item = GO_BACK;
break;
#ifdef PHILZ_TOUCH_RECOVERY
case GESTURE_ACTIONS:
handle_gesture_actions(headers, items, initial_selection);
break;
#endif
}
} else if (!menu_only) {
chosen_item = action;
}
#ifdef NOT_ENOUGH_RAINBOWS
if (abs(selected - old_selected) > 1) {
wrap_count++;
if (wrap_count == 5) {
wrap_count = 0;
if (ui_get_rainbow_mode()) {
ui_set_rainbow_mode(0);
ui_print("Rainbow mode disabled\n");
}
else {
ui_set_rainbow_mode(1);
ui_print("Rainbow mode enabled!\n");
}
}
}
#endif
}
ui_end_menu();
ui_clear_key_queue();
return chosen_item;
}
static int
get_menu_selection(char** headers, char** items, unsigned char* selectability, int title_length, int start_sel, int menu_only)
{
// throw away keys pressed previously, so user doesn't
// accidentally trigger menu items.
ui_clear_key_queue();
//get no items
int num_items = 0;
while (items[num_items] != NULL)
num_items++;
if (start_sel >= num_items)
start_sel = num_items - 1;
if (start_sel < 0)
start_sel = 0;
ui_start_menu(headers, items, title_length, start_sel);
int selected = start_sel;
int chosen_item = -1;
while (chosen_item < 0)
{
int key = ui_wait_key();
int visible = ui_text_visible();
int action = device_handle_key(key, visible);
if (action < 0)
{
switch (action)
{
case HIGHLIGHT_UP:
while(1)
{
--selected;
//wrap
if (selected < 0)
selected = num_items - 1;
if (selectability[selected])
break;
}
selected = ui_menu_select(selected);
break;
case HIGHLIGHT_DOWN:
while(1)
{
++selected;
//wrap
if (selected >= num_items)
selected = 0;
if (selectability[selected])
break;
}
selected = ui_menu_select(selected);
break;
case SELECT_ITEM:
chosen_item = selected;
break;
case NO_ACTION:
break;
}
}
else if (!menu_only)
chosen_item = action;
}
//check first if to hide menu (don't do on menu changes or tags),
//because the flicker is annoying
//that is implemented elsewhere
//ui_end_menu();
return chosen_item;
}
