apps/gui/option_select.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Kevin Ferrare
  11  * Copyright (C) 2007 by Jonathan Gordon
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "config.h"
  25 #include "option_select.h"
  26 #include "sprintf.h"
  27 #include "kernel.h"
  28 #include "lang.h"
  29 #include "talk.h"
  30 #include "settings_list.h"
  31 #include "sound.h"
  32 #include "list.h"
  33 #include "action.h"
  34 #include "statusbar.h"
  35 #include "misc.h"
  36 #include "splash.h"
  37 #include "menu.h"
  38 #include "quickscreen.h"
  39
  40 #if defined (HAVE_SCROLLWHEEL)      || \
  41     (CONFIG_KEYPAD == IPOD_3G_PAD)  || \
  42     (CONFIG_KEYPAD == IPOD_4G_PAD)  || \
  43     (CONFIG_KEYPAD == IPOD_1G2G_PAD) || \
  44     (CONFIG_KEYPAD == PLAYER_PAD)
  45 /* Define this if your target makes sense to have
  46    smaller values at the top of the list increasing down the list */
  47 #define ASCENDING_INT_SETTINGS
  48 #endif
  49
  50 static int selection_to_val(const struct settings_list *setting, int selection);
  51 int option_value_as_int(const struct settings_list *setting)
  52 {
  53     int type = (setting->flags & F_T_MASK);
  54     int temp = 0;
  55     if (type == F_T_BOOL)
  56         temp = *(bool*)setting->setting?1:0;
  57     else if (type == F_T_UINT || type == F_T_INT)
  58         temp = *(int*)setting->setting;
  59     return temp;
  60 }
  61 static const char *unit_strings[] =
  62 {
  63     [UNIT_INT] = "",    [UNIT_MS]  = "ms",
  64     [UNIT_SEC] = "s",   [UNIT_MIN] = "min",
  65     [UNIT_HOUR]= "hr",  [UNIT_KHZ] = "kHz",
  66     [UNIT_DB]  = "dB",  [UNIT_PERCENT] = "%",
  67     [UNIT_MAH] = "mAh", [UNIT_PIXEL] = "px",
  68     [UNIT_PER_SEC] = "per sec",
  69     [UNIT_HERTZ] = "Hz",
  70     [UNIT_MB]  = "MB",  [UNIT_KBIT]  = "kb/s",
  71     [UNIT_PM_TICK] = "units/10ms",
  72 };
  73 /* these two vars are needed so arbitrary values can be added to the
  74    TABLE_SETTING settings if the F_ALLOW_ARBITRARY_VALS flag is set */
  75 static int table_setting_oldval = 0, table_setting_array_position = 0;
  76 char *option_get_valuestring(const struct settings_list *setting,
  77                              char *buffer, int buf_len,
  78                              intptr_t temp_var)
  79 {
  80     if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
  81     {
  82         bool val = (bool)temp_var;
  83         strncpy(buffer, str(val? setting->bool_setting->lang_yes :
  84                                  setting->bool_setting->lang_no), buf_len);
  85     }
  86 #if 0 /* probably dont need this one */
  87     else if ((setting->flags & F_FILENAME) == F_FILENAME)
  88     {
  89         struct filename_setting *info = setting->filename_setting;
  90         snprintf(buffer, buf_len, "%s%s%s", info->prefix,
  91                  (char*)temp_var, info->suffix);
  92     }
  93 #endif
  94     else if (((setting->flags & F_INT_SETTING) == F_INT_SETTING) ||
  95              ((setting->flags & F_TABLE_SETTING) == F_TABLE_SETTING))
  96     {
  97         const struct int_setting *int_info = setting->int_setting;
  98         const struct table_setting *tbl_info = setting->table_setting;
  99         const char *unit;
 100         void (*formatter)(char*, size_t, int, const char*);
 101         if ((setting->flags & F_INT_SETTING) == F_INT_SETTING)
 102         {
 103             formatter = int_info->formatter;
 104             unit = unit_strings[int_info->unit];
 105         }
 106         else
 107         {
 108             formatter = tbl_info->formatter;
 109             unit = unit_strings[tbl_info->unit];
 110         }
 111         if (formatter)
 112             formatter(buffer, buf_len, (int)temp_var, unit);
 113         else
 114             snprintf(buffer, buf_len, "%d %s", (int)temp_var, unit?unit:"");
 115     }
 116     else if ((setting->flags & F_T_SOUND) == F_T_SOUND)
 117     {
 118         char sign = ' ', *unit;
 119         unit = (char*)sound_unit(setting->sound_setting->setting);
 120         if (sound_numdecimals(setting->sound_setting->setting))
 121         {
 122             int integer, dec;
 123             int val = sound_val2phys(setting->sound_setting->setting,
 124                                  (int)temp_var);
 125             if(val < 0)
 126             {
 127                 sign = '-';
 128                 val = abs(val);
 129             }
 130             integer = val / 10; dec = val % 10;
 131             snprintf(buffer, buf_len, "%c%d.%d %s", sign, integer, dec, unit);
 132         }
 133         else
 134             snprintf(buffer, buf_len, "%d %s", (int)temp_var, unit);
 135     }
 136     else if ((setting->flags & F_CHOICE_SETTING) == F_CHOICE_SETTING)
 137     {
 138         if (setting->flags & F_CHOICETALKS)
 139         {
 140             int setting_id;
 141             const struct choice_setting *info = setting->choice_setting;
 142             if (info->talks[(int)temp_var] < LANG_LAST_INDEX_IN_ARRAY)
 143             {
 144                 strncpy(buffer, str(info->talks[(int)temp_var]), buf_len);
 145             }
 146             else
 147             {
 148                 find_setting(setting->setting, &setting_id);
 149                 cfg_int_to_string(setting_id, (int)temp_var, buffer, buf_len);
 150             }
 151         }
 152         else
 153         {
 154             int value= (int)temp_var;
 155             char *val = P2STR(setting->choice_setting->desc[value]);
 156             strncpy(buffer, val, buf_len);
 157         }
 158     }
 159     return buffer;
 160 }
 161 void option_talk_value(const struct settings_list *setting, int value, bool enqueue)
 162 {
 163     if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
 164     {
 165         bool val = value==1?true:false;
 166         talk_id(val? setting->bool_setting->lang_yes :
 167                 setting->bool_setting->lang_no, enqueue);
 168     }
 169 #if 0 /* probably dont need this one */
 170     else if ((setting->flags & F_FILENAME) == F_FILENAME)
 171     {
 172 }
 173 #endif
 174     else if (((setting->flags & F_INT_SETTING) == F_INT_SETTING) ||
 175                ((setting->flags & F_TABLE_SETTING) == F_TABLE_SETTING))
 176     {
 177         const struct int_setting *int_info = setting->int_setting;
 178         const struct table_setting *tbl_info = setting->table_setting;
 179         int unit;
 180         int32_t (*get_talk_id)(int, int);
 181         if ((setting->flags & F_INT_SETTING) == F_INT_SETTING)
 182         {
 183             unit = int_info->unit;
 184             get_talk_id = int_info->get_talk_id;
 185         }
 186         else
 187         {
 188             unit = tbl_info->unit;
 189             get_talk_id = tbl_info->get_talk_id;
 190         }
 191         if (get_talk_id)
 192             talk_id(get_talk_id(value, unit), enqueue);
 193         else
 194             talk_value(value, unit, enqueue);
 195     }
 196     else if ((setting->flags & F_T_SOUND) == F_T_SOUND)
 197     {
 198         int talkunit = UNIT_INT;
 199         const char *unit = sound_unit(setting->sound_setting->setting);
 200         if (!strcmp(unit, "dB"))
 201             talkunit = UNIT_DB;
 202         else if (!strcmp(unit, "%"))
 203             talkunit = UNIT_PERCENT;
 204         else if (!strcmp(unit, "Hz"))
 205             talkunit = UNIT_HERTZ;
 206         talk_value(value, talkunit, false);
 207     }
 208     else if ((setting->flags & F_CHOICE_SETTING) == F_CHOICE_SETTING)
 209     {
 210         if (setting->flags & F_CHOICETALKS)
 211         {
 212             talk_id(setting->choice_setting->talks[value], enqueue);
 213         }
 214         else
 215         {
 216             talk_id(P2ID(setting->choice_setting->desc[value]), enqueue);
 217         }
 218     }
 219 }
 220
 221 static int option_talk(int selected_item, void * data)
 222 {
 223     struct settings_list *setting = (struct settings_list *)data;
 224     int temp_var = selection_to_val(setting, selected_item);
 225     option_talk_value(setting, temp_var, false);
 226     return 0;
 227 }
 228
 229 #if defined(HAVE_QUICKSCREEN) || defined(HAVE_RECORDING)
 230    /* only the quickscreen and recording trigger needs this */
 231 void option_select_next_val(const struct settings_list *setting,
 232                             bool previous, bool apply)
 233 {
 234     int val = 0;
 235     int *value = setting->setting;
 236     if ((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING)
 237     {
 238         *(bool*)value = !*(bool*)value;
 239         if (apply && setting->bool_setting->option_callback)
 240             setting->bool_setting->option_callback(*(bool*)value);
 241         return;
 242     }
 243     else if ((setting->flags & F_INT_SETTING) == F_INT_SETTING)
 244     {
 245         struct int_setting *info = (struct int_setting *)setting->int_setting;
 246         int step = info->step;
 247         if (step < 0)
 248             step = -step;
 249         if (!previous)
 250         {
 251             val = *value + step;
 252             if (val > info->max)
 253                 val = info->min;
 254         }
 255         else
 256         {
 257             val = *value - step;
 258             if (val < info->min)
 259                 val = info->max;
 260         }
 261         if (apply && info->option_callback)
 262             info->option_callback(val);
 263     }
 264     else if ((setting->flags & F_T_SOUND) == F_T_SOUND)
 265     {
 266         int setting_id = setting->sound_setting->setting;
 267         int steps = sound_steps(setting_id);
 268         int min = sound_min(setting_id);
 269         int max = sound_max(setting_id);
 270         if (!previous)
 271         {
 272             val = *value + steps;
 273             if (val >= max)
 274                 val = min;
 275         }
 276         else
 277         {
 278             val = *value - steps;
 279             if (val < min)
 280                 val = max;
 281         }
 282     }
 283     else if ((setting->flags & F_CHOICE_SETTING) == F_CHOICE_SETTING)
 284     {
 285         struct choice_setting *info = (struct choice_setting *)setting->choice_setting;
 286         val = *value + 1;
 287         if (!previous)
 288         {
 289             val = *value + 1;
 290             if (val >= info->count)
 291                 val = 0;
 292         }
 293         else
 294         {
 295             val = *value - 1;
 296             if (val < 0)
 297                 val = info->count-1;
 298         }
 299         if (apply && info->option_callback)
 300             info->option_callback(val);
 301     }
 302     else if ((setting->flags & F_TABLE_SETTING) == F_TABLE_SETTING)
 303     {
 304         const struct table_setting *tbl_info = setting->table_setting;
 305         int i, add;
 306         add = previous?tbl_info->count-1:1;
 307         for (i=0; i<tbl_info->count;i++)
 308         {
 309             if ((*value == tbl_info->values[i]) ||
 310                   (settings->flags&F_ALLOW_ARBITRARY_VALS &&
 311                     *value < tbl_info->values[i]))
 312             {
 313                 val = tbl_info->values[(i+add)%tbl_info->count];
 314                 break;
 315             }
 316         }
 317     }
 318     *value = val;
 319 }
 320 #endif
 321
 322 static int selection_to_val(const struct settings_list *setting, int selection)
 323 {
 324     int min = 0, max = 0, step = 1;
 325     if (((setting->flags & F_BOOL_SETTING) == F_BOOL_SETTING) ||
 326           ((setting->flags & F_CHOICE_SETTING) == F_CHOICE_SETTING))
 327         return selection;
 328     else if ((setting->flags & F_TABLE_SETTING) == F_TABLE_SETTING)
 329     {
 330         const struct table_setting *info = setting->table_setting;
 331         if (setting->flags&F_ALLOW_ARBITRARY_VALS &&
 332             table_setting_array_position != -1    &&
 333             (selection >= table_setting_array_position))
 334         {
 335             if (selection == table_setting_array_position)
 336                 return table_setting_oldval;
 337             return info->values[selection-1];
 338         }
 339         else
 340             return info->values[selection];
 341     }
 342     else if ((setting->flags & F_T_SOUND) == F_T_SOUND)
 343     {
 344         int setting_id = setting->sound_setting->setting;
 345 #ifndef ASCENDING_INT_SETTINGS
 346         step = sound_steps(setting_id);
 347         max = sound_max(setting_id);
 348         min = sound_min(setting_id);
 349 #else
 350         step = -sound_steps(setting_id);
 351         min = sound_max(setting_id);
 352         max = sound_min(setting_id);
 353 #endif
 354     }
 355     else if ((setting->flags & F_INT_SETTING) == F_INT_SETTING)
 356     {
 357         const struct int_setting *info = setting->int_setting;
 358 #ifndef ASCENDING_INT_SETTINGS
 359         min = info->min;
 360         max = info->max;
 361         step = info->step;
 362 #else
 363         max = info->min;
 364         min = info->max;
 365         step = -info->step;
 366 #endif
 367     }
 368     return max- (selection * step);
 369 }
 370 static char * value_setting_get_name_cb(int selected_item,
 371                                         void * data,
 372                                         char *buffer,
 373                                         size_t buffer_len)
 374 {
 375     selected_item = selection_to_val(data, selected_item);
 376     return option_get_valuestring(data, buffer, buffer_len, selected_item);
 377 }
 378
 379 /* wrapper to convert from int param to bool param in option_screen */
 380 static void (*boolfunction)(bool);
 381 static void bool_funcwrapper(int value)
 382 {
 383     if (value)
 384         boolfunction(true);
 385     else
 386         boolfunction(false);
 387 }
 388
 389 static void val_to_selection(const struct settings_list *setting, int oldvalue,
 390                              int *nb_items, int *selected,
 391                              void (**function)(int))
 392 {
 393     int var_type = setting->flags&F_T_MASK;
 394     /* set the number of items and current selection */
 395     if (var_type == F_T_INT || var_type == F_T_UINT)
 396     {
 397         if (setting->flags&F_CHOICE_SETTING)
 398         {
 399             *nb_items = setting->choice_setting->count;
 400             *selected = oldvalue;
 401             *function = setting->choice_setting->option_callback;
 402         }
 403         else if (setting->flags&F_TABLE_SETTING)
 404         {
 405             const struct table_setting *info = setting->table_setting;
 406             int i;
 407             *nb_items = info->count;
 408             *selected = -1;
 409             table_setting_array_position = -1;
 410             for (i=0;*selected==-1 && i<*nb_items;i++)
 411             {
 412                 if (setting->flags&F_ALLOW_ARBITRARY_VALS &&
 413                     (oldvalue < info->values[i]))
 414                 {
 415                     table_setting_oldval = oldvalue;
 416                     table_setting_array_position = i;
 417                     *selected = i;
 418                     (*nb_items)++;
 419                 }
 420                 else if (oldvalue == info->values[i])
 421                     *selected = i;
 422             }
 423             *function = info->option_callback;
 424         }
 425         else if (setting->flags&F_T_SOUND)
 426         {
 427             int setting_id = setting->sound_setting->setting;
 428             int steps = sound_steps(setting_id);
 429             int min = sound_min(setting_id);
 430             int max = sound_max(setting_id);
 431             *nb_items = (max-min)/steps + 1;
 432 #ifndef ASCENDING_INT_SETTINGS
 433             *selected = (max - oldvalue) / steps;
 434 #else
 435             *selected = (oldvalue - min) / steps;
 436 #endif
 437             *function = sound_get_fn(setting_id);
 438         }
 439         else
 440         {
 441             const struct int_setting *info = setting->int_setting;
 442             int min, max, step;
 443             max = info->max;
 444             min = info->min;
 445             step = info->step;
 446             *nb_items = (max-min)/step + 1;
 447 #ifndef ASCENDING_INT_SETTINGS
 448             *selected = (max - oldvalue) / step;
 449 #else
 450             *selected = (oldvalue - min) / step;
 451 #endif
 452             *function = info->option_callback;
 453         }
 454     }
 455     else if (var_type == F_T_BOOL)
 456     {
 457         *selected = oldvalue;
 458         *nb_items = 2;
 459         boolfunction = setting->bool_setting->option_callback;
 460         if (boolfunction)
 461             *function = bool_funcwrapper;
 462     }
 463 }
 464
 465 bool option_screen(const struct settings_list *setting,
 466                    struct viewport parent[NB_SCREENS],
 467                    bool use_temp_var, unsigned char* option_title)
 468 {
 469     int action;
 470     bool done = false;
 471     struct gui_synclist lists;
 472     int oldvalue, nb_items = 0, selected = 0, temp_var;
 473     int *variable;
 474     bool allow_wrap = setting->flags & F_NO_WRAP ? false : true;
 475     int var_type = setting->flags&F_T_MASK;
 476     void (*function)(int) = NULL;
 477     char *title;
 478     if (var_type == F_T_INT || var_type == F_T_UINT)
 479     {
 480         variable = use_temp_var ? &temp_var: (int*)setting->setting;
 481         temp_var = oldvalue = *(int*)setting->setting;
 482     }
 483     else if (var_type == F_T_BOOL)
 484     {
 485         /* bools always use the temp variable...
 486         if use_temp_var is false it will be copied to setting->setting every change */
 487         variable = &temp_var;
 488         temp_var = oldvalue = *(bool*)setting->setting?1:0;
 489     }
 490     else return false; /* only int/bools can go here */
 491     gui_synclist_init(&lists, value_setting_get_name_cb,
 492                       (void*)setting, false, 1, parent);
 493     if (setting->lang_id == -1)
 494         title = (char*)setting->cfg_vals;
 495     else
 496         title = P2STR(option_title);
 497
 498     gui_synclist_set_title(&lists, title, Icon_Questionmark);
 499     gui_synclist_set_icon_callback(&lists, NULL);
 500     if(global_settings.talk_menu)
 501         gui_synclist_set_voice_callback(&lists, option_talk);
 502
 503     val_to_selection(setting, oldvalue, &nb_items, &selected, &function);
 504     gui_synclist_set_nb_items(&lists, nb_items);
 505     gui_synclist_select_item(&lists, selected);
 506
 507     gui_synclist_limit_scroll(&lists, true);
 508     gui_synclist_draw(&lists);
 509     /* talk the item */
 510     gui_synclist_speak_item(&lists);
 511     gui_syncstatusbar_draw(&statusbars, false);
 512     while (!done)
 513     {
 514         if (list_do_action(CONTEXT_LIST, TIMEOUT_BLOCK,
 515                            &lists, &action,
 516             allow_wrap? LIST_WRAP_UNLESS_HELD: LIST_WRAP_OFF))
 517         {
 518             /* setting changed */
 519             selected = gui_synclist_get_sel_pos(&lists);
 520             *variable = selection_to_val(setting, selected);
 521             if (var_type == F_T_BOOL && !use_temp_var)
 522                 *(bool*)setting->setting = (*variable==1);
 523         }
 524         else if (action == ACTION_NONE)
 525             continue;
 526         else if (action == ACTION_STD_CANCEL)
 527         {
 528             /* setting canceled, restore old value if changed */
 529             if (*variable != oldvalue)
 530             {
 531                 *variable = oldvalue;
 532                 if (var_type == F_T_BOOL && !use_temp_var)
 533                     *(bool*)setting->setting = (oldvalue==1);
 534                 splash(HZ/2, ID2P(LANG_CANCEL));
 535             }
 536             done = true;
 537         }
 538         else if (action == ACTION_STD_CONTEXT)
 539         {
 540             /* reset setting to default */
 541             reset_setting(setting, variable);
 542             if (var_type == F_T_BOOL && !use_temp_var)
 543                 *(bool*)setting->setting = (*variable==1);
 544             val_to_selection(setting, *variable, &nb_items,
 545                                 &selected, &function);
 546             gui_synclist_select_item(&lists, selected);
 547             gui_synclist_draw(&lists);
 548             gui_synclist_speak_item(&lists);
 549         }
 550         else if (action == ACTION_STD_OK)
 551         {
 552             /* setting accepted, store now if it used a temp var */
 553             if (use_temp_var)
 554             {
 555                 if (var_type == F_T_INT || var_type == F_T_UINT)
 556                     *(int*)setting->setting = *variable;
 557                 else
 558                     *(bool*)setting->setting = (*variable==1);
 559             }
 560             settings_save();
 561             done = true;
 562         }
 563         else if(default_event_handler(action) == SYS_USB_CONNECTED)
 564             return true;
 565         gui_syncstatusbar_draw(&statusbars, false);
 566         /* callback */
 567         if ( function )
 568             function(*variable);
 569     }
 570     return false;
 571 }
 572