apps/menus/main_menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdbool.h>
  21 #include <stddef.h>
  22 #include <limits.h>
  23 #include "config.h"
  24 #include "string.h"
  25 #include "lang.h"
  26 #include "action.h"
  27 #include "settings.h"
  28 #include "powermgmt.h"
  29 #include "menu.h"
  30 #include "misc.h"
  31 #include "exported_menus.h"
  32 #include "tree.h"
  33 #ifdef HAVE_RECORDING
  34 #include "recording.h"
  35 #endif
  36 #include "bookmark.h"
  37 #include "yesno.h"
  38 #include "keyboard.h"
  39 #include "screens.h"
  40 #include "plugin.h"
  41 #include "talk.h"
  42 #include "buffer.h"
  43 #include "splash.h"
  44 #include "debug_menu.h"
  45 #if defined(SIMULATOR) && defined(ROCKBOX_HAS_LOGF)
  46 #include "logfdisp.h"
  47 #endif
  48 #include "version.h"
  49 #include "time.h"
  50
  51 static const struct browse_folder_info config = {ROCKBOX_DIR, SHOW_CFG};
  52
  53 /***********************************/
  54 /*    MANAGE SETTINGS MENU        */
  55
  56 static int reset_settings(void)
  57 {
  58     const unsigned char *lines[]={ID2P(LANG_RESET_ASK)};
  59     const unsigned char *yes_lines[]={
  60         str(LANG_SETTINGS),
  61         ID2P(LANG_RESET_DONE_CLEAR)
  62     };
  63     const unsigned char *no_lines[]={yes_lines[0], ID2P(LANG_CANCEL)};
  64     struct text_message message={(char **)lines, 1};
  65     struct text_message yes_message={(char **)yes_lines, 2};
  66     struct text_message no_message={(char **)no_lines, 2};
  67
  68     switch(gui_syncyesno_run(&message, &yes_message, &no_message))
  69     {
  70         case YESNO_YES:
  71             settings_write_config(CONFIGFILE ".bak", SETTINGS_SAVE_CHANGED);
  72             settings_reset();
  73             settings_apply(true);
  74             settings_save();
  75             break;
  76         case YESNO_NO:
  77             break;
  78         case YESNO_USB:
  79             return 1;
  80     }
  81     return 0;
  82 }
  83 static int write_settings_file(void* param)
  84 {
  85     return settings_save_config((intptr_t)param);
  86 }
  87
  88 MENUITEM_FUNCTION(browse_configs, MENU_FUNC_USEPARAM, ID2P(LANG_CUSTOM_CFG),
  89         browse_folder, (void*)&config, NULL, Icon_NOICON);
  90 MENUITEM_FUNCTION(save_settings_item, MENU_FUNC_USEPARAM, ID2P(LANG_SAVE_SETTINGS),
  91         write_settings_file, (void*)SETTINGS_SAVE_ALL, NULL, Icon_NOICON);
  92 MENUITEM_FUNCTION(save_theme_item, MENU_FUNC_USEPARAM, ID2P(LANG_SAVE_THEME),
  93         write_settings_file, (void*)SETTINGS_SAVE_THEME, NULL, Icon_NOICON);
  94 MENUITEM_FUNCTION(save_sound_item, MENU_FUNC_USEPARAM, ID2P(LANG_SAVE_SOUND),
  95         write_settings_file, (void*)SETTINGS_SAVE_SOUND, NULL, Icon_NOICON);
  96 MENUITEM_FUNCTION(reset_settings_item, 0, ID2P(LANG_RESET),
  97                   reset_settings, NULL, NULL, Icon_NOICON);
  98
  99 MAKE_MENU(manage_settings, ID2P(LANG_MANAGE_MENU), NULL, Icon_Config,
 100           &browse_configs, &reset_settings_item,
 101           &save_settings_item, &save_sound_item, &save_theme_item);
 102 /*    MANAGE SETTINGS MENU        */
 103 /**********************************/
 104
 105 /***********************************/
 106 /*      INFO MENU                  */
 107
 108 static bool show_credits(void)
 109 {
 110     if (plugin_load(VIEWERS_DIR "/credits.rock",NULL) != PLUGIN_OK)
 111     {
 112         /* show the rockbox logo and version untill a button is pressed */
 113         show_logo();
 114         get_action(CONTEXT_STD, TIMEOUT_BLOCK);
 115     }
 116     return false;
 117 }
 118
 119 #ifdef HAVE_LCD_CHARCELLS
 120 #define SIZE_FMT "%s%s"
 121 #else
 122 #define SIZE_FMT "%s %s"
 123 #endif
 124 struct info_data
 125
 126 {
 127     bool new_data;
 128     unsigned long size;
 129     unsigned long free;
 130 #ifdef HAVE_MULTIVOLUME
 131     unsigned long size2;
 132     unsigned long free2;
 133 #endif
 134 };
 135 enum infoscreenorder
 136 {
 137     INFO_BATTERY = 0,
 138     INFO_DISK1, /* capacity or internal capacity/free on hotswap */
 139     INFO_DISK2, /* free space or external capacity/free on hotswap */
 140     INFO_BUFFER,
 141     INFO_VERSION,
 142 #if CONFIG_RTC
 143     INFO_DATE,
 144     INFO_TIME,
 145 #endif
 146     INFO_COUNT
 147 };
 148
 149
 150 static char* info_getname(int selected_item, void *data, char *buffer)
 151 {
 152     struct info_data *info = (struct info_data*)data;
 153 #if CONFIG_RTC
 154     struct tm *tm;
 155 #endif
 156     const unsigned char *kbyte_units[] =
 157     {
 158         ID2P(LANG_KILOBYTE),
 159         ID2P(LANG_MEGABYTE),
 160         ID2P(LANG_GIGABYTE)
 161     };
 162     char s1[32];
 163 #ifdef HAVE_MULTIVOLUME
 164     char s2[32];
 165 #endif
 166     if (info->new_data)
 167     {
 168         fat_size(IF_MV2(0,) &info->size, &info->free);
 169 #ifdef HAVE_MULTIVOLUME
 170         if (fat_ismounted(1))
 171             fat_size(1, &info->size2, &info->free2);
 172         else
 173             info->size2 = 0;
 174 #endif
 175         info->new_data = false;
 176     }
 177     switch (selected_item)
 178     {
 179         case INFO_VERSION:
 180             snprintf(buffer, MAX_PATH, "%s: %s",
 181                      str(LANG_VERSION), appsversion);
 182             break;
 183 #if CONFIG_RTC
 184         case INFO_TIME:
 185             tm = get_time();
 186             snprintf(buffer, MAX_PATH, "%02d:%02d:%02d %s",
 187                 global_settings.timeformat == 0 ? tm->tm_hour : tm->tm_hour-12,
 188                 tm->tm_min,
 189                 tm->tm_sec,
 190                 global_settings.timeformat == 0 ? "" : tm->tm_hour>11 ? "P" : "A");
 191             break;
 192         case INFO_DATE:
 193             tm = get_time();
 194             snprintf(buffer, MAX_PATH, "%s %d %d",
 195                 str(LANG_MONTH_JANUARY + tm->tm_mon),
 196                 tm->tm_mday,
 197                 tm->tm_year+1900);
 198             break;
 199 #endif
 200         case INFO_BUFFER: /* buffer */
 201         {
 202             long buflen = ((audiobufend - audiobuf) * 2) / 2097;  /* avoid overflow */
 203             int integer = buflen / 1000;
 204             int decimal = buflen % 1000;
 205             snprintf(buffer, MAX_PATH, (char *)str(LANG_BUFFER_STAT),
 206                      integer, decimal);
 207         }
 208         break;
 209         case INFO_BATTERY: /* battery */
 210 #if CONFIG_CHARGING == CHARGING_SIMPLE
 211             if (charger_input_state == CHARGER)
 212                 snprintf(buffer, MAX_PATH, (char *)str(LANG_BATTERY_CHARGE));
 213             else
 214 #elif CONFIG_CHARGING >= CHARGING_MONITOR
 215             if (charge_state == CHARGING)
 216                 snprintf(buffer, MAX_PATH, (char *)str(LANG_BATTERY_CHARGE));
 217             else
 218 #if CONFIG_CHARGING == CHARGING_CONTROL
 219             if (charge_state == TOPOFF)
 220                 snprintf(buffer, MAX_PATH, (char *)str(LANG_BATTERY_TOPOFF_CHARGE));
 221             else
 222 #endif
 223             if (charge_state == TRICKLE)
 224                 snprintf(buffer, MAX_PATH, (char *)str(LANG_BATTERY_TRICKLE_CHARGE));
 225             else
 226 #endif
 227             if (battery_level() >= 0)
 228                 snprintf(buffer, MAX_PATH, (char *)str(LANG_BATTERY_TIME), battery_level(),
 229                          battery_time() / 60, battery_time() % 60);
 230             else
 231                 strcpy(buffer, "(n/a)");
 232             break;
 233         case INFO_DISK1: /* disk usage 1 */
 234 #ifdef HAVE_MULTIVOLUME
 235             output_dyn_value(s1, sizeof s1, info->free, kbyte_units, true);
 236             output_dyn_value(s2, sizeof s2, info->size, kbyte_units, true);
 237             snprintf(buffer, MAX_PATH, "%s %s/%s", str(LANG_DISK_NAME_INTERNAL),
 238                      s1, s2);
 239 #else
 240             output_dyn_value(s1, sizeof s1, info->free, kbyte_units, true);
 241             snprintf(buffer, MAX_PATH, SIZE_FMT, str(LANG_DISK_FREE_INFO), s1);
 242 #endif
 243             break;
 244         case INFO_DISK2: /* disk usage 2 */
 245 #ifdef HAVE_MULTIVOLUME
 246             if (info->size2)
 247             {
 248                 output_dyn_value(s1, sizeof s1, info->free2, kbyte_units, true);
 249                 output_dyn_value(s2, sizeof s2, info->size2, kbyte_units, true);
 250                 snprintf(buffer, MAX_PATH, "%s %s/%s", str(LANG_DISK_NAME_MMC),
 251                          s1, s2);
 252             }
 253             else
 254             {
 255                 snprintf(buffer, MAX_PATH, "%s %s", str(LANG_DISK_NAME_MMC),
 256                          str(LANG_NOT_PRESENT));
 257             }
 258 #else
 259             output_dyn_value(s1, sizeof s1, info->size, kbyte_units, true);
 260             snprintf(buffer, MAX_PATH, SIZE_FMT, str(LANG_DISK_SIZE_INFO), s1);
 261 #endif
 262             break;
 263     }
 264     return buffer;
 265 }
 266
 267 static int info_speak_item(int selected_item, void * data)
 268 {
 269     struct info_data *info = (struct info_data*)data;
 270     const unsigned char *kbyte_units[] = {
 271         ID2P(LANG_KILOBYTE),
 272         ID2P(LANG_MEGABYTE),
 273         ID2P(LANG_GIGABYTE)
 274     };
 275     switch (selected_item)
 276     {
 277         case INFO_VERSION: /* version */
 278             talk_id(LANG_VERSION, false);
 279             talk_spell(appsversion, true);
 280             break;
 281 #if CONFIG_RTC
 282         case INFO_TIME:
 283             talk_id(VOICE_CURRENT_TIME, false);
 284             talk_time(get_time(), true);
 285             break;
 286         case INFO_DATE:
 287             talk_date(get_time(), true);
 288             break;
 289 #endif
 290         case INFO_BUFFER: /* buffer */
 291         {
 292             talk_id(LANG_BUFFER_STAT, false);
 293             long buflen = ((audiobufend - audiobuf) * 2) / 2097;  /* avoid overflow */
 294             output_dyn_value(NULL, 0, buflen, kbyte_units, true);
 295             break;
 296         }
 297         case INFO_BATTERY: /* battery */
 298 #if CONFIG_CHARGING == CHARGING_SIMPLE
 299             if (charger_input_state == CHARGER)
 300                 talk_id(LANG_BATTERY_CHARGE, true);
 301             else
 302 #elif CONFIG_CHARGING >= CHARGING_MONITOR
 303             if (charge_state == CHARGING)
 304                 talk_id(LANG_BATTERY_CHARGE, true);
 305             else
 306 #if CONFIG_CHARGING == CHARGING_CONTROL
 307             if (charge_state == TOPOFF)
 308                 talk_id(LANG_BATTERY_TOPOFF_CHARGE, true);
 309             else
 310 #endif
 311             if (charge_state == TRICKLE)
 312                 talk_id(LANG_BATTERY_TRICKLE_CHARGE, true);
 313             else
 314 #endif
 315             if (battery_level() >= 0)
 316             {
 317                 talk_id(LANG_BATTERY_TIME, false);
 318                 talk_value(battery_level(), UNIT_PERCENT, true);
 319                 talk_value(battery_time() *60, UNIT_TIME, true);
 320             }
 321             else talk_id(VOICE_BLANK, false);
 322             break;
 323         case INFO_DISK1: /* disk 1 */
 324 #ifdef HAVE_MULTIVOLUME
 325             talk_id(LANG_DISK_NAME_INTERNAL, false);
 326             talk_id(LANG_DISK_FREE_INFO, true);
 327             output_dyn_value(NULL, 0, info->free, kbyte_units, true);
 328             talk_id(LANG_DISK_SIZE_INFO, true);
 329             output_dyn_value(NULL, 0, info->size, kbyte_units, true);
 330 #else
 331             talk_id(LANG_DISK_FREE_INFO, false);
 332             output_dyn_value(NULL, 0, info->free, kbyte_units, true);
 333 #endif
 334             break;
 335         case INFO_DISK2: /* disk 2 */
 336 #ifdef HAVE_MULTIVOLUME
 337             talk_id(LANG_DISK_NAME_MMC, false);
 338             if (info->size2)
 339             {
 340                 talk_id(LANG_DISK_FREE_INFO, true);
 341                 output_dyn_value(NULL, 0, info->free2, kbyte_units, true);
 342                 talk_id(LANG_DISK_SIZE_INFO, true);
 343                 output_dyn_value(NULL, 0, info->size2, kbyte_units, true);
 344             }
 345             else talk_id(LANG_NOT_PRESENT, true);
 346 #else
 347             talk_id(LANG_DISK_SIZE_INFO, false);
 348             output_dyn_value(NULL, 0, info->size, kbyte_units, true);
 349 #endif
 350             break;
 351     }
 352     return 0;
 353 }
 354
 355 static int info_action_callback(int action, struct gui_synclist *lists)
 356 {
 357     if (action == ACTION_STD_CANCEL)
 358         return action;
 359     if ((action == ACTION_STD_OK)
 360 #ifdef HAVE_MULTIVOLUME
 361         || action == SYS_HOTSWAP_INSERTED
 362         || action == SYS_HOTSWAP_EXTRACTED
 363 #endif
 364         )
 365     {
 366 #ifndef SIMULATOR
 367         struct info_data *info = (struct info_data *)lists->data;
 368         info->new_data = true;
 369         gui_syncsplash(0, ID2P(LANG_SCANNING_DISK));
 370         fat_recalc_free(IF_MV(0));
 371 #ifdef HAVE_MULTIVOLUME
 372         if (fat_ismounted(1))
 373             fat_recalc_free(1);
 374 #endif
 375
 376 #else
 377
 378         (void) lists;
 379 #endif
 380         return ACTION_REDRAW;
 381     }
 382     return action;
 383 }
 384 static bool show_info(void)
 385 {
 386     struct info_data data = {.new_data = true };
 387     struct simplelist_info info;
 388     simplelist_info_init(&info, str(LANG_ROCKBOX_INFO), INFO_COUNT, (void*)&data);
 389     info.hide_selection = !global_settings.talk_menu;
 390     info.get_name = info_getname;
 391     if(global_settings.talk_menu)
 392          info.get_talk = info_speak_item;
 393     info.action_callback = info_action_callback;
 394     return simplelist_show_list(&info);
 395 }
 396 MENUITEM_FUNCTION(show_info_item, 0, ID2P(LANG_ROCKBOX_INFO),
 397                    (menu_function)show_info, NULL, NULL, Icon_NOICON);
 398
 399
 400 /* sleep Menu */
 401 static void sleep_timer_formatter(char* buffer, size_t buffer_size, int value,
 402                                   const char* unit)
 403 {
 404     int minutes, hours;
 405
 406     (void) unit;
 407
 408     if (value) {
 409         hours = value / 60;
 410         minutes = value - (hours * 60);
 411         snprintf(buffer, buffer_size, "%d:%02d", hours, minutes);
 412    } else {
 413         snprintf(buffer, buffer_size, "%s", str(LANG_OFF));
 414     }
 415 }
 416
 417 static void sleep_timer_set(int minutes)
 418 {
 419     set_sleep_timer(minutes * 60);
 420 }
 421
 422 static int sleep_timer(void)
 423 {
 424     int minutes = (get_sleep_timer() + 59) / 60; /* round up */
 425     return (int)set_int(str(LANG_SLEEP_TIMER), "", UNIT_MIN, &minutes,
 426                    &sleep_timer_set, -5, 300, 0, sleep_timer_formatter);
 427 }
 428
 429 MENUITEM_FUNCTION(sleep_timer_call, 0, ID2P(LANG_SLEEP_TIMER), sleep_timer,
 430                     NULL, NULL, Icon_Menu_setting); /* make it look like a
 431                                                                 setting to the user */
 432 MENUITEM_FUNCTION(show_credits_item, 0, ID2P(LANG_VERSION),
 433                    (menu_function)show_credits, NULL, NULL, Icon_NOICON);
 434 MENUITEM_FUNCTION(show_runtime_item, 0, ID2P(LANG_RUNNING_TIME),
 435                    (menu_function)view_runtime, NULL, NULL, Icon_NOICON);
 436 MENUITEM_FUNCTION(debug_menu_item, 0, ID2P(LANG_DEBUG),
 437                    (menu_function)debug_menu, NULL, NULL, Icon_NOICON);
 438
 439 MAKE_MENU(info_menu, ID2P(LANG_SYSTEM), 0, Icon_Questionmark,
 440           &show_info_item, &show_credits_item, &show_runtime_item,
 441           &sleep_timer_call, &debug_menu_item);
 442 /*      INFO MENU                  */
 443 /***********************************/
 444
 445 /***********************************/
 446 /*    MAIN MENU                    */
 447
 448
 449 #ifdef HAVE_LCD_CHARCELLS
 450 int mainmenu_callback(int action,const struct menu_item_ex *this_item)
 451 {
 452     (void)this_item;
 453     switch (action)
 454     {
 455         case ACTION_ENTER_MENUITEM:
 456             status_set_param(true);
 457             break;
 458         case ACTION_EXIT_MENUITEM:
 459             status_set_param(false);
 460             break;
 461     }
 462     return action;
 463 }
 464 #else
 465 #define mainmenu_callback NULL
 466 #endif
 467 MAKE_MENU(main_menu_, ID2P(LANG_SETTINGS), mainmenu_callback,
 468         Icon_Submenu_Entered,
 469         &sound_settings,
 470         &settings_menu_item, &theme_menu,
 471 #ifdef HAVE_RECORDING
 472         &recording_settings,
 473 #endif
 474         &manage_settings,
 475         );
 476 /*    MAIN MENU                    */
 477 /***********************************/
 478