apps/plugins/goban/goban.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007-2009 Joshua Simmons <mud at majidejima dot com>
  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 #include "plugin.h"
  23 #include "lib/playback_control.h"
  24 #include "lib/configfile.h"
  25
  26
  27
  28 #include "goban.h"
  29 #include "game.h"
  30 #include "board.h"
  31 #include "display.h"
  32 #include "sgf.h"
  33 #include "sgf_storage.h"
  34 #include "types.h"
  35 #include "util.h"
  36
  37 enum play_mode_t play_mode = MODE_PLAY;
  38
  39 #if defined(GBN_BUTTON_NAV_MODE)
  40
  41 #define NAV_MODE_BOARD 0
  42 #define NAV_MODE_TREE 1
  43
  44 int nav_mode = NAV_MODE_BOARD;
  45
  46 #endif
  47
  48 /* the stack that uses this buffer is used for both storing intersections
  49  * in board algorithms (could store one short for each board location), and
  50  * for parsing (could store an indefinite number of ints, related to how
  51  * many levels deep branches go (in other words, how many branches off of
  52  * branches there are).  50 should take care of any reasonable file.
  53  */
  54 #define PARSE_STACK_BUFFER_SIZE (max(MAX_BOARD_SIZE * MAX_BOARD_SIZE * sizeof(unsigned short), 50 * sizeof(int)))
  55
  56 /* used in SGF file parsing and outputting as well as in liberty counting
  57    and capturing/uncapturing */
  58 struct stack_t parse_stack;
  59 char parse_stack_buffer[PARSE_STACK_BUFFER_SIZE];
  60
  61 static void global_setup (void);
  62 static void global_cleanup (void);
  63
  64 static bool do_main_menu (void);
  65 static void do_gameinfo_menu (void);
  66 static enum prop_type_t menu_selection_to_prop (int selection);
  67 static void do_context_menu (void);
  68 static void do_options_menu (void);
  69
  70 static bool do_comment_edit (void);
  71 static bool do_zoom (void);
  72 static void set_defaults (void);
  73
  74 bool auto_show_comments = true;
  75 bool disable_shutdown = false;
  76 unsigned int autosave_time = 0;
  77 unsigned int autosave_counter = 0;
  78
  79 #define SETTINGS_VERSION 2
  80 #define SETTINGS_MIN_VERSION 1
  81 #define SETTINGS_FILENAME "goban.cfg"
  82
  83 static struct configdata config[] =
  84 {            /* INT in MAX_INT_SIZE is intersection, not integer */
  85     {TYPE_INT, 0, MAX_INT_SIZE,
  86         { .int_p = &saved_circle_size },
  87         "stone size", NULL},
  88     {TYPE_BOOL, 0, 1,
  89         { .bool_p = &draw_variations },
  90         "draw variations",
  91         NULL},
  92     {TYPE_BOOL, 0, 1,
  93         { .bool_p = &auto_show_comments },
  94         "auto show comments",
  95         NULL},
  96     {TYPE_BOOL, 0, 1,
  97         { .bool_p = &disable_shutdown },
  98         "disable shutdown",
  99         NULL},
 100     {TYPE_INT, 0, MAX_AUTOSAVE,
 101         { .int_p = &autosave_time },
 102         "autosave time",
 103         NULL}
 104 };
 105
 106 static void
 107 set_defaults (void)
 108 {
 109     saved_circle_size = 0;
 110     draw_variations = true;
 111     auto_show_comments = true;
 112
 113     disable_shutdown = false;
 114     autosave_time = 7;
 115 }
 116
 117 static const char*
 118 komi_formatter (char *dest, size_t size, int menu_item, const char *unknown)
 119 {
 120     (void) unknown;
 121     snprint_fixed (dest, size, menu_item);
 122     return dest;
 123 }
 124
 125 static const char*
 126 ruleset_formatter (char *dest, size_t size, int menu_item, const char *unknown)
 127 {
 128     (void)dest, (void)size, (void)unknown;
 129     return ruleset_names[menu_item];
 130 }
 131
 132 static const char*
 133 autosave_formatter (char *dest, size_t size, int menu_item, const char *
 134 unknown)
 135 {
 136     (void) unknown;
 137     if (menu_item == 0)
 138     {
 139         return "Off";
 140     }
 141     else
 142     {
 143         rb->snprintf (dest, size, "%d minute%s", menu_item,
 144                       menu_item == 1 ? "" : "s");
 145         return dest;
 146     }
 147 }
 148
 149 static const char*
 150 time_formatter (char *dest, size_t size, int menu_item, const char *unknown)
 151 {
 152     int time_values[4];         /* days hours minutes seconds */
 153     int min_set, max_set;
 154     int temp;
 155
 156     (void) unknown;
 157
 158     time_values[0] = menu_item / (24 * 60 * 60);
 159     menu_item %= (24 * 60 * 60);
 160     time_values[1] = menu_item / (60 * 60);
 161     menu_item %= (60 * 60);
 162     time_values[2] = menu_item / 60;
 163     time_values[3] = menu_item % 60;
 164
 165     min_set = 500;
 166     max_set = -1;
 167     int i;
 168     for (i = 0;
 169          (unsigned int) i < (sizeof (time_values) / sizeof (time_values[0]));
 170          ++i)
 171     {
 172         if (time_values[i])
 173         {
 174             if (i < min_set)
 175             {
 176                 min_set = i;
 177             }
 178
 179             if (i > max_set)
 180             {
 181                 max_set = i;
 182             }
 183         }
 184     }
 185
 186     if (max_set == -1)
 187     {
 188         return "0";
 189     }
 190
 191     for (i = min_set; i <= 3; ++i)
 192     {
 193         if (i <= max_set)
 194         {
 195             if (i == 0 || i == 1 || i == min_set)
 196             {
 197                 rb->snprintf (dest, size, "%d", time_values[i]);
 198             }
 199             else
 200             {
 201                 rb->snprintf (dest, size, "%02d", time_values[i]);
 202             }
 203             temp = rb->strlen (dest);
 204             dest += temp;
 205             size -= temp;
 206         }
 207         else if (i != 3)
 208         {
 209             continue;
 210         }
 211
 212         if (i == 0)             /* days */
 213         {
 214             rb->snprintf (dest, size, " d ");
 215         }
 216         else if (i == 3)        /* seconds, print the final units */
 217         {
 218             if (min_set == 0 || min_set == 1)
 219             {
 220                 rb->snprintf (dest, size, " h");
 221             }
 222             else if (min_set == 2)
 223             {
 224                 rb->snprintf (dest, size, " m");
 225             }
 226             else
 227             {
 228                 rb->snprintf (dest, size, " s");
 229             }
 230         }
 231         else if (i != max_set)
 232         {
 233             rb->snprintf (dest, size, ":");
 234         }
 235
 236         temp = rb->strlen (dest);
 237         dest += temp;
 238         size -= temp;
 239     }
 240     return dest;
 241 }
 242
 243 enum plugin_status
 244 plugin_start (const void *parameter)
 245 {
 246     int btn;
 247
 248     rb->mkdir (DEFAULT_SAVE_DIR);
 249
 250     global_setup ();
 251
 252 #ifdef GBN_TEST
 253     run_tests ();
 254     return PLUGIN_OK;
 255 #endif
 256
 257     if (!(parameter && load_game (parameter)))
 258     {
 259         if (parameter)
 260         {
 261             rb->splashf (2 * HZ, "Loading %s failed.", (char *) parameter);
 262         }
 263
 264         if (!load_game (DEFAULT_SAVE))
 265         {
 266             rb->strcpy (save_file, DEFAULT_SAVE);
 267
 268             if (!setup_game (MAX_BOARD_SIZE, MAX_BOARD_SIZE, 0, 0))
 269             {
 270                 return PLUGIN_ERROR;
 271             }
 272         }
 273     }
 274     else
 275     {
 276         /* game loaded */
 277         if (rb->strcmp (save_file, DEFAULT_SAVE))
 278         {
 279             /* delete the scratch file if we loaded a game and it wasn't
 280              * from the scratch file
 281              */
 282             rb->remove (DEFAULT_SAVE);
 283         }
 284     }
 285
 286     draw_screen_display ();
 287
 288     autosave_counter = 0;
 289     for (;;)
 290     {
 291         btn = rb->button_get_w_tmo (HZ * 30);
 292
 293         if (disable_shutdown)
 294         {
 295             /* tell rockbox we're not idle */
 296             rb->reset_poweroff_timer ();
 297         }
 298
 299         bool is_idle = false;
 300
 301         switch (btn)
 302         {
 303
 304 #if defined(GBN_BUTTON_NAV_MODE)
 305         case GBN_BUTTON_NAV_MODE:
 306         case GBN_BUTTON_NAV_MODE | BUTTON_REPEAT:
 307             if (nav_mode == NAV_MODE_TREE)
 308             {
 309                 nav_mode = NAV_MODE_BOARD;
 310                 rb->splash (2 * HZ / 3, "board navigation mode");
 311                 draw_screen_display ();
 312             }
 313             else
 314             {
 315                 nav_mode = NAV_MODE_TREE;
 316                 rb->splash (2 * HZ / 3, "tree navigation mode");
 317                 draw_screen_display ();
 318             }
 319             break;
 320 #endif
 321
 322 #if defined(GBN_BUTTON_ADVANCE)
 323         case GBN_BUTTON_ADVANCE:
 324         case GBN_BUTTON_ADVANCE | BUTTON_REPEAT:
 325             if (has_more_nodes_sgf ())
 326             {
 327                 if (!redo_node_sgf ())
 328                 {
 329                     rb->splash (2 * HZ, "redo failed");
 330                 }
 331                 draw_screen_display ();
 332             }
 333             break;
 334 #endif
 335
 336 #if defined(GBN_BUTTON_RETREAT)
 337         case GBN_BUTTON_RETREAT:
 338         case GBN_BUTTON_RETREAT | BUTTON_REPEAT:
 339             if (has_prev_nodes_sgf ())
 340             {
 341                 if (!undo_node_sgf ())
 342                 {
 343                     rb->splash (3 * HZ / 2, "Undo Failed");
 344                 }
 345                 draw_screen_display ();
 346             }
 347             break;
 348 #endif
 349
 350         case GBN_BUTTON_PLAY:
 351             if (play_mode == MODE_PLAY || play_mode == MODE_FORCE_PLAY)
 352             {
 353                 if (!play_move_sgf (cursor_pos, current_player))
 354                 {
 355                     rb->splash (HZ / 3, "Illegal Move");
 356                 }
 357             }
 358             else if (play_mode == MODE_ADD_BLACK)
 359             {
 360                 if (!add_stone_sgf (cursor_pos, BLACK))
 361                 {
 362                     rb->splash (HZ / 3, "Illegal");
 363                 }
 364             }
 365             else if (play_mode == MODE_ADD_WHITE)
 366             {
 367                 if (!add_stone_sgf (cursor_pos, WHITE))
 368                 {
 369                     rb->splash (HZ / 3, "Illegal");
 370                 }
 371             }
 372             else if (play_mode == MODE_REMOVE)
 373             {
 374                 if (!add_stone_sgf (cursor_pos, EMPTY))
 375                 {
 376                     rb->splash (HZ / 3, "Illegal");
 377                 }
 378             }
 379             else if (play_mode == MODE_MARK)
 380             {
 381                 if (!add_mark_sgf (cursor_pos, PROP_MARK))
 382                 {
 383                     rb->splash (HZ / 3, "Couldn't Mark");
 384                 }
 385             }
 386             else if (play_mode == MODE_CIRCLE)
 387             {
 388                 if (!add_mark_sgf (cursor_pos, PROP_CIRCLE))
 389                 {
 390                     rb->splash (HZ / 3, "Couldn't Mark");
 391                 }
 392             }
 393             else if (play_mode == MODE_SQUARE)
 394             {
 395                 if (!add_mark_sgf (cursor_pos, PROP_SQUARE))
 396                 {
 397                     rb->splash (HZ / 3, "Couldn't Mark");
 398                 }
 399             }
 400             else if (play_mode == MODE_TRIANGLE)
 401             {
 402                 if (!add_mark_sgf (cursor_pos, PROP_TRIANGLE))
 403                 {
 404                     rb->splash (HZ / 3, "Couldn't Mark");
 405                 }
 406             }
 407             else if (play_mode == MODE_LABEL)
 408             {
 409                 if (!add_mark_sgf (cursor_pos, PROP_LABEL))
 410                 {
 411                     rb->splash (HZ / 3, "Couldn't Label");
 412                 }
 413             }
 414             else
 415             {
 416                 rb->splash (HZ, "mode not implemented");
 417             }
 418
 419             draw_screen_display ();
 420             break;
 421
 422         case GBN_BUTTON_RIGHT:
 423         case GBN_BUTTON_RIGHT | BUTTON_REPEAT:
 424 #if defined(GBN_BUTTON_NAV_MODE)
 425             if (nav_mode == NAV_MODE_TREE)
 426             {
 427                 if (has_more_nodes_sgf ())
 428                 {
 429                     if (!redo_node_sgf ())
 430                     {
 431                         rb->splash (2 * HZ, "Redo Failed");
 432                     }
 433                     draw_screen_display ();
 434                 }
 435             }
 436             else
 437             {
 438 #endif
 439                 cursor_pos = WRAP (EAST (cursor_pos));
 440                 draw_screen_display ();
 441 #if defined(GBN_BUTTON_NAV_MODE)
 442             }
 443 #endif
 444             break;
 445
 446         case GBN_BUTTON_LEFT:
 447         case GBN_BUTTON_LEFT | BUTTON_REPEAT:
 448 #if defined(GBN_BUTTON_NAV_MODE)
 449             if (nav_mode == NAV_MODE_TREE)
 450             {
 451                 if (has_prev_nodes_sgf ())
 452                 {
 453                     if (!undo_node_sgf ())
 454                     {
 455                         rb->splash (2 * HZ, "Undo Failed");
 456                     }
 457                     draw_screen_display ();
 458                 }
 459             }
 460             else
 461             {
 462 #endif
 463                 cursor_pos = WRAP (WEST (cursor_pos));
 464                 draw_screen_display ();
 465 #if defined(GBN_BUTTON_NAV_MODE)
 466             }
 467 #endif
 468             break;
 469
 470         case GBN_BUTTON_DOWN:
 471         case GBN_BUTTON_DOWN | BUTTON_REPEAT:
 472             cursor_pos = WRAP (SOUTH (cursor_pos));
 473             draw_screen_display ();
 474             break;
 475
 476         case GBN_BUTTON_UP:
 477         case GBN_BUTTON_UP | BUTTON_REPEAT:
 478             cursor_pos = WRAP (NORTH (cursor_pos));
 479             draw_screen_display ();
 480             break;
 481
 482         case GBN_BUTTON_MENU:
 483             if (do_main_menu ())
 484             {
 485                 save_game (DEFAULT_SAVE);
 486
 487                 global_cleanup ();
 488                 return PLUGIN_OK;
 489             }
 490
 491             draw_screen_display ();
 492             break;
 493
 494 #if defined(GBN_BUTTON_CONTEXT)
 495         case GBN_BUTTON_CONTEXT:
 496             do_context_menu ();
 497             draw_screen_display ();
 498             break;
 499 #endif
 500
 501 #if defined(GBN_BUTTON_NEXT_VAR)
 502         case GBN_BUTTON_NEXT_VAR:
 503         case GBN_BUTTON_NEXT_VAR | BUTTON_REPEAT:
 504         {
 505             int temp;
 506             if ((temp = next_variation_sgf ()) >= 0)
 507             {
 508                 draw_screen_display ();
 509                 rb->splashf (2 * HZ / 3, "%d of %d", temp,
 510                              num_variations_sgf ());
 511                 draw_screen_display ();
 512             }
 513             else
 514             {
 515                 if (num_variations_sgf () > 1)
 516                 {
 517                     rb->splashf (HZ, "Error %d in next_variation_sgf", temp);
 518                 }
 519                 draw_screen_display ();
 520             }
 521             break;
 522         }
 523 #endif
 524
 525         case BUTTON_NONE:
 526             is_idle = true;
 527         default:
 528             if (rb->default_event_handler (btn) == SYS_USB_CONNECTED)
 529             {
 530                 return PLUGIN_USB_CONNECTED;
 531             }
 532             break;
 533         };
 534
 535         if (is_idle && autosave_dirty)
 536         {
 537             ++autosave_counter;
 538
 539             if (autosave_time != 0 &&
 540                 autosave_counter / 2 >= autosave_time)
 541                 /* counter is in 30 second increments, autosave_time is in
 542                  * minutes
 543                  */
 544             {
 545                 DEBUGF("autosaving\n");
 546                 rb->splash(HZ / 4, "Autosaving...");
 547                 save_game(DEFAULT_SAVE);
 548                 draw_screen_display();
 549                 autosave_counter = 0;
 550             }
 551         }
 552         else
 553         {
 554             autosave_counter = 0;
 555         }
 556     }
 557
 558     return PLUGIN_OK;
 559 }
 560
 561 static void
 562 global_cleanup (void)
 563 {
 564     cleanup_sgf ();
 565     configfile_save(SETTINGS_FILENAME, config,
 566                     sizeof(config)/sizeof(*config),
 567                     SETTINGS_VERSION);
 568 }
 569
 570 static void
 571 global_setup (void)
 572 {
 573     setup_stack (&parse_stack, parse_stack_buffer,
 574                  sizeof (parse_stack_buffer));
 575     setup_display ();
 576     setup_sgf ();
 577
 578     set_defaults();
 579     if (configfile_load(SETTINGS_FILENAME, config,
 580                         sizeof(config)/sizeof(*config),
 581                         SETTINGS_MIN_VERSION ) < 0)
 582     {
 583         /* If the loading failed, save a new config file (as the disk is
 584            already spinning) */
 585
 586         /* set defaults again just in case (don't know if they can ever
 587          * be messed up by configfile_load, and it's basically free anyway)
 588          */
 589         set_defaults();
 590
 591         configfile_save(SETTINGS_FILENAME, config,
 592                         sizeof(config)/sizeof(*config),
 593                         SETTINGS_VERSION);
 594     }
 595 }
 596
 597 enum main_menu_selections
 598 {
 599     MAIN_NEW = 0,
 600     MAIN_SAVE,
 601     MAIN_SAVE_AS,
 602     MAIN_GAME_INFO,
 603     MAIN_PLAYBACK,
 604     MAIN_ZOOM,
 605     MAIN_OPTIONS,
 606     MAIN_CONTEXT,
 607     MAIN_QUIT
 608 };
 609
 610 static bool
 611 do_main_menu (void)
 612 {
 613     int selection = 0;
 614     MENUITEM_STRINGLIST (menu, "Rockbox Goban", NULL,
 615                          "New",
 616                          "Save",
 617                          "Save As",
 618                          "Game Info",
 619                          "Playback Control",
 620                          "Zoom Level",
 621                          "Options",
 622                          "Context Menu",
 623                          "Quit");
 624
 625     /* for "New" in menu */
 626     int new_handi = 0, new_bs = MAX_BOARD_SIZE, new_komi = 15;
 627
 628     char new_save_file[SAVE_FILE_LENGTH];
 629
 630
 631     bool done = false;
 632
 633     while (!done)
 634     {
 635         selection = rb->do_menu (&menu, &selection, NULL, false);
 636
 637         switch (selection)
 638         {
 639         case MAIN_NEW:
 640             rb->set_int ("board size", "lines", UNIT_INT,
 641                          &new_bs, NULL, 1, MIN_BOARD_SIZE, MAX_BOARD_SIZE,
 642                          NULL);
 643
 644             rb->set_int ("handicap", "stones", UNIT_INT,
 645                          &new_handi, NULL, 1, 0, 9, NULL);
 646
 647             if (new_handi > 0)
 648             {
 649                 new_komi = 1;
 650             }
 651             else
 652             {
 653                 new_komi = 13;
 654             }
 655
 656             rb->set_int ("komi", "moku", UNIT_INT, &new_komi, NULL,
 657                          1, -300, 300, &komi_formatter);
 658
 659             setup_game (new_bs, new_bs, new_handi, new_komi);
 660             draw_screen_display ();
 661             done = true;
 662             break;
 663
 664         case MAIN_SAVE:
 665             if (!save_game (save_file))
 666             {
 667                 rb->splash (2 * HZ, "Save Failed!");
 668             }
 669             else
 670             {
 671                 rb->splash (2 * HZ / 3, "Saved");
 672             }
 673             done = true;
 674             draw_screen_display ();
 675             break;
 676
 677         case MAIN_SAVE_AS:
 678             rb->strcpy (new_save_file, save_file);
 679
 680             if (!rb->kbd_input (new_save_file, SAVE_FILE_LENGTH))
 681             {
 682                 break;
 683             }
 684
 685             if (!save_game (new_save_file))
 686             {
 687                 rb->splash (2 * HZ, "Save Failed!");
 688             }
 689             else
 690             {
 691                 rb->strcpy (save_file, new_save_file);
 692                 rb->splash (2 * HZ / 3, "Saved");
 693             }
 694
 695             done = true;
 696             draw_screen_display ();
 697             break;
 698
 699         case MAIN_GAME_INFO:
 700             do_gameinfo_menu ();
 701             break;
 702
 703         case MAIN_PLAYBACK:
 704             if (!audio_stolen_sgf ())
 705             {
 706                 playback_control (NULL);
 707             }
 708             else
 709             {
 710                 rb->splash (1 * HZ, "Audio has been disabled!");
 711             }
 712             break;
 713
 714         case MAIN_ZOOM:
 715             if (do_zoom ())
 716             {
 717                 return true;
 718             }
 719             done = true;
 720             draw_screen_display ();
 721             break;
 722
 723         case MAIN_OPTIONS:
 724             do_options_menu();
 725             break;
 726
 727         case MAIN_CONTEXT:
 728             do_context_menu ();
 729             done = true;
 730             break;
 731
 732         case MAIN_QUIT:
 733         case MENU_ATTACHED_USB:
 734             return true;
 735
 736         case GO_TO_ROOT:
 737         case GO_TO_PREVIOUS:
 738         default:
 739
 740             done = true;
 741             break;
 742         };
 743     }
 744
 745     return false;
 746 }
 747
 748 static void
 749 zoom_preview (int current)
 750 {
 751     set_zoom_display (current);
 752     draw_screen_display ();
 753     rb->splash (0, "Preview");
 754 }
 755
 756 static bool
 757 do_zoom (void)
 758 {
 759     unsigned int zoom_level;
 760     unsigned int old_val;
 761     bool done = false;
 762
 763     unsigned int min_val = min_zoom_display ();
 764     unsigned int max_val = max_zoom_display ();
 765
 766     zoom_level = old_val = current_zoom_display ();
 767
 768     int action;
 769
 770     zoom_preview (zoom_level);
 771     while (!done)
 772     {
 773         switch (action = rb->get_action (CONTEXT_LIST, TIMEOUT_BLOCK))
 774         {
 775         case ACTION_STD_OK:
 776             set_zoom_display (zoom_level);
 777             done = true;
 778             rb->splash (HZ / 2, "Zoom Set");
 779             saved_circle_size = intersection_size;
 780             break;
 781
 782         case ACTION_STD_CANCEL:
 783             set_zoom_display (old_val);
 784             done = true;
 785             rb->splash (HZ / 2, "Cancelled");
 786             break;
 787
 788         case ACTION_STD_CONTEXT:
 789             zoom_level = old_val;
 790             zoom_preview (zoom_level);
 791             break;
 792
 793         case ACTION_STD_NEXT:
 794         case ACTION_STD_NEXTREPEAT:
 795             zoom_level = zoom_level * 3 / 2;
 796
 797             /* 1 * 3 / 2 is 1 again... */
 798             if (zoom_level == 1)
 799             {
 800                 ++zoom_level;
 801             }
 802
 803             if (zoom_level > max_val)
 804             {
 805                 zoom_level = min_val;
 806             }
 807
 808             zoom_preview (zoom_level);
 809             break;
 810
 811         case ACTION_STD_PREV:
 812         case ACTION_STD_PREVREPEAT:
 813             zoom_level = zoom_level * 2 / 3;
 814
 815             if (zoom_level < min_val)
 816             {
 817                 zoom_level = max_val;
 818             }
 819             zoom_preview (zoom_level);
 820             break;
 821
 822         case ACTION_NONE:
 823             break;
 824
 825         default:
 826             if (rb->default_event_handler (action) == SYS_USB_CONNECTED)
 827             {
 828                 return true;
 829             }
 830             break;
 831         }
 832     }
 833
 834     return false;
 835 }
 836
 837 enum gameinfo_menu_selections
 838 {
 839     GINFO_BASIC_INFO = 0,
 840     GINFO_TIME_LIMIT,
 841     GINFO_OVERTIME,
 842     GINFO_RESULT,
 843     GINFO_HANDICAP,
 844     GINFO_KOMI,
 845     GINFO_RULESET,
 846     GINFO_BLACK_PLAYER,
 847     GINFO_BLACK_RANK,
 848     GINFO_BLACK_TEAM,
 849     GINFO_WHITE_PLAYER,
 850     GINFO_WHITE_RANK,
 851     GINFO_WHITE_TEAM,
 852     GINFO_DATE,
 853     GINFO_EVENT,
 854     GINFO_PLACE,
 855     GINFO_ROUND,
 856     GINFO_DONE
 857 };
 858
 859
 860 static void
 861 do_gameinfo_menu (void)
 862 {
 863     MENUITEM_STRINGLIST (gameinfo_menu, "Game Info", NULL,
 864                          "Basic Info",
 865                          "Time Limit",
 866                          "Overtime",
 867                          "Result",
 868                          "Handicap",
 869                          "Komi",
 870                          "Ruleset",
 871                          "Black Player",
 872                          "Black Rank",
 873                          "Black Team",
 874                          "White Player",
 875                          "White Rank",
 876                          "White Team",
 877                          "Date",
 878                          "Event",
 879                          "Place",
 880                          "Round",
 881                          "Done");
 882     /* IMPORTANT:
 883      *
 884      * if you edit this string list, make sure you keep
 885      * menu_selection_to_prop function in line with it!! (see the bottom
 886      * of this file).
 887      */
 888
 889     int new_ruleset = 0;
 890
 891     char *gameinfo_string;
 892     int gameinfo_string_size;
 893
 894     bool done = false;
 895     int selection = 0;
 896
 897     while (!done)
 898     {
 899         selection = rb->do_menu (&gameinfo_menu, &selection, NULL, false);
 900
 901         switch (selection)
 902         {
 903         case GINFO_OVERTIME:
 904         case GINFO_RESULT:
 905         case GINFO_BLACK_PLAYER:
 906         case GINFO_BLACK_RANK:
 907         case GINFO_BLACK_TEAM:
 908         case GINFO_WHITE_PLAYER:
 909         case GINFO_WHITE_RANK:
 910         case GINFO_WHITE_TEAM:
 911         case GINFO_DATE:
 912         case GINFO_EVENT:
 913         case GINFO_PLACE:
 914         case GINFO_ROUND:
 915             if (!get_header_string_and_size (&header,
 916                                              menu_selection_to_prop
 917                                              (selection), &gameinfo_string,
 918                                              &gameinfo_string_size))
 919             {
 920                 rb->splash (3 * HZ, "Couldn't get header string");
 921                 break;
 922             }
 923
 924             rb->kbd_input (gameinfo_string, gameinfo_string_size);
 925             sanitize_string (gameinfo_string);
 926             set_game_modified();
 927             break;
 928
 929             /* these need special handling in some way, so they are
 930                separate */
 931
 932         case GINFO_BASIC_INFO:
 933             metadata_summary();
 934             break;
 935
 936         case GINFO_TIME_LIMIT:
 937             rb->set_int ("Time Limit", "", UNIT_INT, &header.time_limit,
 938                          NULL, 60, 0, 24 * 60 * 60, &time_formatter);
 939             set_game_modified();
 940             break;
 941
 942         case GINFO_HANDICAP:
 943             rb->splashf (0, "%d stones.  Start a new game to set handicap",
 944                          header.handicap);
 945             rb->action_userabort(TIMEOUT_BLOCK);
 946             break;
 947
 948         case GINFO_KOMI:
 949             rb->set_int ("Komi", "moku", UNIT_INT, &header.komi, NULL,
 950                          1, -300, 300, &komi_formatter);
 951             set_game_modified();
 952             break;
 953
 954         case GINFO_RULESET:
 955             new_ruleset = 0;
 956             rb->set_int ("Ruleset", "", UNIT_INT, &new_ruleset, NULL,
 957                          1, 0, NUM_RULESETS - 1, &ruleset_formatter);
 958
 959             rb->strcpy (header.ruleset, ruleset_names[new_ruleset]);
 960             set_game_modified();
 961             break;
 962
 963         case GINFO_DONE:
 964         case GO_TO_ROOT:
 965         case GO_TO_PREVIOUS:
 966         case MENU_ATTACHED_USB:
 967         default:
 968             done = true;
 969             break;
 970         };
 971     }
 972 }
 973
 974 enum context_menu_selections
 975 {
 976     CTX_PLAY = 0,
 977     CTX_ADD_BLACK,
 978     CTX_ADD_WHITE,
 979     CTX_ERASE,
 980     CTX_PASS,
 981     CTX_NEXT_VAR,
 982     CTX_FORCE,
 983     CTX_MARK,
 984     CTX_CIRCLE,
 985     CTX_SQUARE,
 986     CTX_TRIANGLE,
 987     CTX_LABEL,
 988     CTX_COMMENT,
 989     CTX_DONE
 990 };
 991
 992 static void
 993 do_context_menu (void)
 994 {
 995     int selection;
 996     bool done = false;
 997     int temp;
 998
 999     MENUITEM_STRINGLIST (context_menu, "Context Menu", NULL,
1000                          "Play Mode (default)",
1001                          "Add Black Mode",
1002                          "Add White Mode",
1003                          "Erase Stone Mode",
1004                          "Pass",
1005                          "Next Variation",
1006                          "Force Play Mode",
1007                          "Mark Mode",
1008                          "Circle Mode",
1009                          "Square Mode",
1010                          "Triangle Mode",
1011                          "Label Mode",
1012                          "Add/Edit Comment",
1013                          "Done");
1014
1015     while (!done)
1016     {
1017         selection = rb->do_menu (&context_menu, &selection, NULL, false);
1018
1019         switch (selection)
1020         {
1021         case CTX_PLAY:
1022             play_mode = MODE_PLAY;
1023             done = true;
1024             break;
1025
1026         case CTX_ADD_BLACK:
1027             play_mode = MODE_ADD_BLACK;
1028             done = true;
1029             break;
1030
1031         case CTX_ADD_WHITE:
1032             play_mode = MODE_ADD_WHITE;
1033             done = true;
1034             break;
1035
1036         case CTX_ERASE:
1037             play_mode = MODE_REMOVE;
1038             done = true;
1039             break;
1040
1041         case CTX_PASS:
1042             if (!play_move_sgf (PASS_POS, current_player))
1043             {
1044                 rb->splash (HZ, "Error while passing!");
1045             }
1046             done = true;
1047             break;
1048
1049         case CTX_NEXT_VAR:
1050             if ((temp = next_variation_sgf ()) >= 0)
1051             {
1052                 draw_screen_display ();
1053                 rb->splashf (2 * HZ / 3, "%d of %d", temp,
1054                              num_variations_sgf ());
1055                 draw_screen_display ();
1056             }
1057             else
1058             {
1059                 if (num_variations_sgf () > 1)
1060                 {
1061                     rb->splashf (HZ, "Error %d in next_variation_sgf", temp);
1062                 }
1063                 else
1064                 {
1065                     rb->splash (HZ, "No next variation");
1066                 }
1067             }
1068             break;
1069
1070         case CTX_FORCE:
1071             play_mode = MODE_FORCE_PLAY;
1072             done = true;
1073             break;
1074
1075         case CTX_MARK:
1076             play_mode = MODE_MARK;
1077             done = true;
1078             break;
1079
1080         case CTX_CIRCLE:
1081             play_mode = MODE_CIRCLE;
1082             done = true;
1083             break;
1084
1085         case CTX_SQUARE:
1086             play_mode = MODE_SQUARE;
1087             done = true;
1088             break;
1089
1090         case CTX_TRIANGLE:
1091             play_mode = MODE_TRIANGLE;
1092             done = true;
1093             break;
1094
1095         case CTX_LABEL:
1096             play_mode = MODE_LABEL;
1097             done = true;
1098             break;
1099
1100         case CTX_COMMENT:
1101             if (!do_comment_edit ())
1102             {
1103                 DEBUGF ("Editing comment failed\n");
1104                 rb->splash (HZ, "Read or write failed!\n");
1105             }
1106             done = true;
1107             break;
1108
1109         case CTX_DONE:
1110         case GO_TO_ROOT:
1111         case GO_TO_PREVIOUS:
1112         case MENU_ATTACHED_USB:
1113         default:
1114             done = true;
1115             break;
1116         };
1117     }
1118 }
1119
1120 enum options_menu_selections
1121 {
1122     OMENU_SHOW_VARIATIONS = 0,
1123     OMENU_DISABLE_POWEROFF,
1124     OMENU_AUTOSAVE_TIME,
1125     OMENU_AUTO_COMMENT
1126 };
1127
1128 static void
1129 do_options_menu (void)
1130 {
1131     int selection;
1132     bool done = false;
1133
1134     MENUITEM_STRINGLIST (options_menu, "Options Menu", NULL,
1135                          "Show Child Variations?",
1136                          "Disable Idle Poweroff?",
1137                          "Idle Autosave Time",
1138                          "Automatically Show Comments?");
1139
1140     while (!done)
1141     {
1142         selection = rb->do_menu (&options_menu, &selection, NULL, false);
1143
1144         switch (selection)
1145         {
1146         case OMENU_SHOW_VARIATIONS:
1147             rb->set_bool("Draw Variations?", &draw_variations);
1148             clear_marks_display ();
1149             set_all_marks_sgf ();
1150             if (draw_variations)
1151             {
1152                 mark_child_variations_sgf ();
1153             }
1154             break;
1155
1156         case OMENU_DISABLE_POWEROFF:
1157             rb->set_bool("Disable Idle Poweroff?", &disable_shutdown);
1158             break;
1159
1160         case OMENU_AUTOSAVE_TIME:
1161             rb->set_int("Idle Autosave Time", "minutes", UNIT_INT,
1162                         &autosave_time, NULL, 1, 0, MAX_AUTOSAVE,
1163                         &autosave_formatter);
1164             autosave_counter = 0;
1165             break;
1166
1167         case OMENU_AUTO_COMMENT:
1168             rb->set_bool("Auto Show Comments?", &auto_show_comments);
1169             break;
1170
1171         case GO_TO_ROOT:
1172         case GO_TO_PREVIOUS:
1173         case MENU_ATTACHED_USB:
1174         default:
1175             done = true;
1176             break;
1177         };
1178     }
1179
1180 }
1181
1182 static bool
1183 do_comment_edit (void)
1184 {
1185     char cbuffer[512];
1186
1187     rb->memset (cbuffer, 0, sizeof (cbuffer));
1188
1189     if (read_comment_sgf (cbuffer, sizeof (cbuffer)) < 0)
1190     {
1191         return false;
1192     }
1193
1194     if (!rb->kbd_input (cbuffer, sizeof (cbuffer)))
1195     {
1196         /* user didn't edit, no reason to write it back */
1197         return true;
1198     }
1199
1200     if (write_comment_sgf (cbuffer) < 0)
1201     {
1202         return false;
1203     }
1204
1205     return true;
1206 }
1207
1208 static enum prop_type_t
1209 menu_selection_to_prop (int selection)
1210 {
1211     switch (selection)
1212     {
1213     case GINFO_OVERTIME:
1214         return PROP_OVERTIME;
1215     case GINFO_RESULT:
1216         return PROP_RESULT;
1217     case GINFO_BLACK_PLAYER:
1218         return PROP_BLACK_NAME;
1219     case GINFO_BLACK_RANK:
1220         return PROP_BLACK_RANK;
1221     case GINFO_BLACK_TEAM:
1222         return PROP_BLACK_TEAM;
1223     case GINFO_WHITE_PLAYER:
1224         return PROP_WHITE_NAME;
1225     case GINFO_WHITE_RANK:
1226         return PROP_WHITE_RANK;
1227     case GINFO_WHITE_TEAM:
1228         return PROP_WHITE_TEAM;
1229     case GINFO_DATE:
1230         return PROP_DATE;
1231     case GINFO_EVENT:
1232         return PROP_EVENT;
1233     case GINFO_PLACE:
1234         return PROP_PLACE;
1235     case GINFO_ROUND:
1236         return PROP_ROUND;
1237     default:
1238         DEBUGF ("Tried to get prop from invalid menu selection!!!\n");
1239         return PROP_PLACE;      /* just pick one, there's a major bug if
1240                                    we got here */
1241     };
1242 }