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