apps/plugins/lib/oldmenuapi.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Robert E. Hak
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 /*
  22 2005 Kevin Ferrare :
  23  - Multi screen support
  24  - Rewrote/removed a lot of code now useless with the new gui API
  25 */
  26 #include <stdbool.h>
  27 #include <stdlib.h>
  28
  29 #include "plugin.h"
  30 #include "oldmenuapi.h"
  31
  32 const struct plugin_api *rb = NULL;
  33
  34 struct menu {
  35     struct menu_item* items;
  36     int (*callback)(int, int);
  37     struct gui_synclist synclist;
  38 };
  39
  40 #define MAX_MENUS 6
  41
  42 static struct menu menus[MAX_MENUS];
  43 static bool inuse[MAX_MENUS] = { false };
  44
  45 static char * menu_get_itemname(int selected_item, void * data,
  46                                 char *buffer, size_t buffer_len)
  47 {
  48     (void)buffer; (void)buffer_len;
  49     struct menu *local_menus=(struct menu *)data;
  50     return(local_menus->items[selected_item].desc);
  51 }
  52
  53 static int menu_find_free(void)
  54 {
  55     int i;
  56     /* Tries to find an unused slot to put the new menu */
  57     for ( i=0; i<MAX_MENUS; i++ ) {
  58         if ( !inuse[i] ) {
  59             inuse[i] = true;
  60             break;
  61         }
  62     }
  63     if ( i == MAX_MENUS ) {
  64         DEBUGF("Out of menus!\n");
  65         return -1;
  66     }
  67     return(i);
  68 }
  69
  70 int menu_init(const struct plugin_api *api, const struct menu_item* mitems,
  71               int count, int (*callback)(int, int),
  72               const char *button1, const char *button2, const char *button3)
  73 {
  74     int menu=menu_find_free();
  75     rb = api;
  76     if(menu==-1)/* Out of menus */
  77         return -1;
  78     menus[menu].items = (struct menu_item*)mitems; /* de-const */
  79     rb->gui_synclist_init(&(menus[menu].synclist),
  80                           &menu_get_itemname, &menus[menu], false, 1, NULL);
  81     rb->gui_synclist_set_icon_callback(&(menus[menu].synclist), NULL);
  82     rb->gui_synclist_set_nb_items(&(menus[menu].synclist), count);
  83     menus[menu].callback = callback;
  84     (void)button1;
  85     (void)button2;
  86     (void)button3;
  87     return menu;
  88 }
  89
  90 void menu_exit(int m)
  91 {
  92     inuse[m] = false;
  93 }
  94
  95 int menu_show(int m)
  96 {
  97     bool exit = false;
  98     int key;
  99
 100     rb->gui_synclist_draw(&(menus[m].synclist));
 101     rb->gui_syncstatusbar_draw(rb->statusbars, true);
 102     while (!exit) {
 103         key = rb->get_action(CONTEXT_MAINMENU,HZ/2);
 104         /*
 105          * "short-circuit" the default keypresses by running the
 106          * callback function
 107          * The callback may return a new key value, often this will be
 108          * BUTTON_NONE or the same key value, but it's perfectly legal
 109          * to "simulate" key presses by returning another value.
 110          */
 111         if( menus[m].callback != NULL )
 112             key = menus[m].callback(key, m);
 113         rb->gui_synclist_do_button(&(menus[m].synclist), &key,LIST_WRAP_UNLESS_HELD);
 114         switch( key ) {
 115             case ACTION_STD_OK:
 116                 return rb->gui_synclist_get_sel_pos(&(menus[m].synclist));
 117
 118             case ACTION_STD_CANCEL:
 119             case ACTION_STD_MENU:
 120             case SYS_POWEROFF:
 121                 exit = true;
 122                 break;
 123
 124             default:
 125                 if(rb->default_event_handler(key) == SYS_USB_CONNECTED)
 126                     return MENU_ATTACHED_USB;
 127                 break;
 128         }
 129         rb->gui_syncstatusbar_draw(rb->statusbars, false);
 130     }
 131     return MENU_SELECTED_EXIT;
 132 }
 133
 134
 135 bool menu_run(int m)
 136 {
 137     int selected;
 138     while (1) {
 139         switch (selected=menu_show(m))
 140         {
 141             case MENU_SELECTED_EXIT:
 142                 return false;
 143
 144             case MENU_ATTACHED_USB:
 145                 return true;
 146
 147             default:
 148             {
 149                 if (menus[m].items[selected].function &&
 150                     menus[m].items[selected].function())
 151                     return  true;
 152                 rb->gui_syncstatusbar_draw(rb->statusbars, true);
 153             }
 154         }
 155     }
 156     return false;
 157 }
 158
 159 /*
 160  *  Property function - return the current cursor for "menu"
 161  */
 162
 163 int menu_cursor(int menu)
 164 {
 165     return rb->gui_synclist_get_sel_pos(&(menus[menu].synclist));
 166 }
 167
 168 /*
 169  *  Property function - return the "menu" description at "position"
 170  */
 171
 172 char* menu_description(int menu, int position)
 173 {
 174     return menus[menu].items[position].desc;
 175 }
 176
 177 /*
 178  *  Delete the element "position" from the menu items in "menu"
 179  */
 180
 181 void menu_delete(int menu, int position)
 182 {
 183     int i;
 184     int nb_items=rb->gui_synclist_get_nb_items(&(menus[menu].synclist));
 185     /* copy the menu item from the one below */
 186     for( i = position; i < nb_items - 1; i++)
 187         menus[menu].items[i] = menus[menu].items[i + 1];
 188
 189     rb->gui_synclist_del_item(&(menus[menu].synclist));
 190 }
 191
 192 void menu_insert(int menu, int position, char *desc, bool (*function) (void))
 193 {
 194     int i;
 195     int nb_items=rb->gui_synclist_get_nb_items(&(menus[menu].synclist));
 196     if(position < 0)
 197        position = nb_items;
 198
 199     /* Move the items below one position forward */
 200     for( i = nb_items; i > position; i--)
 201        menus[menu].items[i] = menus[menu].items[i - 1];
 202
 203     /* Update the current item */
 204     menus[menu].items[position].desc = (unsigned char *)desc;
 205     menus[menu].items[position].function = function;
 206     rb->gui_synclist_add_item(&(menus[menu].synclist));
 207 }
 208
 209 /*
 210  *  Property function - return the "count" of menu items in "menu"
 211  */
 212
 213 int menu_count(int menu)
 214 {
 215     return rb->gui_synclist_get_nb_items(&(menus[menu].synclist));
 216 }
 217
 218 /*
 219  * Allows to set the cursor position. Doesn't redraw by itself.
 220  */
 221
 222 void menu_set_cursor(int menu, int position)
 223 {
 224     rb->gui_synclist_select_item(&(menus[menu].synclist), position);
 225 }
 226 #if 0
 227 void menu_talk_selected(int m)
 228 {
 229     if(rb->global_settings->talk_menu)
 230     {
 231         int selected=rb->gui_synclist_get_sel_pos(&(menus[m].synclist));
 232         int voice_id = P2ID(menus[m].items[selected].desc);
 233         if (voice_id >= 0) /* valid ID given? */
 234             talk_id(voice_id, false); /* say it */
 235     }
 236 }
 237 #endif
 238 void menu_draw(int m)
 239 {
 240     rb->gui_synclist_draw(&(menus[m].synclist));
 241 }