apps/plugins/goban/display.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 "board.h"
  23 #include "goban.h"
  24 #include "display.h"
  25 #include "game.h"
  26 #include "sgf.h"
  27
  28 /* for xlcd_filltriangle */
  29 #include "lib/xlcd.h"
  30
  31 unsigned int intersection_size = 0;
  32
  33 #define LINE_OFFSET (intersection_size / 2)
  34
  35 /* pixel offsets for the board on the LCD */
  36 int board_x = 0;
  37 int board_y = 0;
  38 int board_pixel_width = 0;
  39 int board_pixel_height = 0;
  40
  41 /* current cursor position in board coordinates (intersections, not
  42    pixels) */
  43 unsigned short cursor_pos = POS (0, 0);
  44
  45 /* we way need to "move" our notion of which intersections to draw when
  46    the cursor moves, since we can be zoomed in (and often will be) this is
  47    used to signal when we need to do that */
  48 unsigned short last_cursor_pos = INVALID_POS;
  49 unsigned int last_int_size = MAX_INT_SIZE + 1;
  50
  51 unsigned int min_x_int = 0;
  52 unsigned int min_y_int = 0;
  53 unsigned int num_x_ints = 0;
  54 unsigned int num_y_ints = 0;
  55
  56 int extend_t = 0, extend_b = 0, extend_l = 0, extend_r = 0;
  57
  58 bool draw_variations = true;
  59 unsigned int saved_circle_size = 0;
  60 bool has_comment = false;
  61
  62 unsigned char display_marks[MAX_BOARD_SIZE * MAX_BOARD_SIZE];
  63
  64
  65 /* function prototypes */
  66
  67 static int pixel_x (unsigned short pos);
  68 static int pixel_y (unsigned short pos);
  69
  70 static void draw_circle (int c_x, int c_y, int r, bool filled);
  71
  72 static void draw_cursor (unsigned short pos);
  73 static void draw_stone_raw (int pixel_x, int pixel_y, bool black);
  74 static void draw_stone (unsigned short pos, bool black);
  75 static void draw_all_stones (void);
  76
  77 static void draw_hoshi (unsigned short pos);
  78 static void draw_footer (void);
  79 static void draw_all_marks (void);
  80 static void draw_all_hoshi (void);
  81
  82 static unsigned int unzoomed_int_size (void);
  83 static void cursor_updated (void);
  84
  85 void
  86 clear_marks_display (void)
  87 {
  88     rb->memset (display_marks, ' ', sizeof (display_marks));
  89     has_comment = false;
  90 }
  91
  92 void
  93 set_mark_display (unsigned short pos, unsigned char mark_char)
  94 {
  95     if (!on_board (pos))
  96     {
  97         return;
  98     }
  99
 100     if ((mark_char == 'b' || mark_char == 'w') &&
 101         display_marks[I (pos) + J (pos) * board_width] != ' ')
 102     {
 103         /* don't overwrite real board marks with last-move or variation
 104            marks */
 105         return;
 106     }
 107
 108     display_marks[I (pos) + J (pos) * board_width] = mark_char;
 109 }
 110
 111
 112 void
 113 set_comment_display (bool new_val)
 114 {
 115     has_comment = new_val;
 116 }
 117
 118
 119 static void
 120 draw_all_marks (void)
 121 {
 122     unsigned int x, y;
 123     for (x = MIN_X; x < MAX_X; ++x)
 124     {
 125         for (y = MIN_Y; y < MAX_Y; ++y)
 126         {
 127             if (display_marks[x + y * board_width] != ' ')
 128             {
 129 #if LCD_DEPTH > 1
 130                 if (display_marks[x + y * board_width] != 'b' &&
 131                     display_marks[x + y * board_width] != 'w')
 132                 {
 133                     rb->lcd_set_foreground (MARK_COLOR);
 134                 }
 135                 else
 136                 {
 137                     rb->lcd_set_foreground (CURSOR_COLOR);
 138                 }
 139                 rb->lcd_set_drawmode (DRMODE_FG);
 140 #else
 141                 rb->lcd_set_drawmode (DRMODE_FG + DRMODE_COMPLEMENT);
 142 #endif
 143
 144                 if (display_marks[x + y * board_width] & (1 << 7))
 145                 {
 146                     char to_display[2];
 147                     int width, height;
 148
 149                     to_display[0] =
 150                         display_marks[x + y * board_width] & (~(1 << 7));
 151                     to_display[1] = '\0';
 152
 153                     rb->lcd_getstringsize (to_display, &width, &height);
 154
 155                     int display_x =
 156                         pixel_x (POS (x, y)) + LINE_OFFSET - (width / 2);
 157                     int display_y =
 158                         pixel_y (POS (x, y)) + LINE_OFFSET - (height / 2);
 159
 160                     if (display_x < 0)
 161                     {
 162                         display_x = 0;
 163                     }
 164
 165                     if (display_y < 0)
 166                     {
 167                         display_y = 0;
 168                     }
 169
 170                     if (display_x + width >= LCD_WIDTH)
 171                     {
 172                         display_x = LCD_WIDTH - 1 - width;
 173                     }
 174
 175                     if (display_y + height >= LCD_HEIGHT)
 176                     {
 177                         display_y = LCD_HEIGHT - 1 - height;
 178                     }
 179
 180                     rb->lcd_putsxy (display_x, display_y, to_display);
 181                     continue;
 182                 }
 183
 184                 switch (display_marks[x + y * board_width])
 185                 {
 186                     /* moves, 'mark', 'square' */
 187                 case 'b':
 188                 case 'w':
 189                     if (intersection_size <= 5)
 190                     {
 191                         DEBUGF ("screen is too small to mark current move\n");
 192                         break;
 193                     }
 194                 case 'm':
 195                     if (intersection_size <= 5)
 196                     {
 197                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET +
 198                                            1,
 199                                            pixel_y (POS (x, y)) + LINE_OFFSET +
 200                                            1);
 201                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET -
 202                                            1,
 203                                            pixel_y (POS (x, y)) + LINE_OFFSET -
 204                                            1);
 205                     }
 206                     else
 207                     {
 208                         rb->lcd_drawrect (pixel_x (POS (x, y)) + LINE_OFFSET -
 209                                           intersection_size / 6,
 210                                           pixel_y (POS (x, y)) + LINE_OFFSET -
 211                                           intersection_size / 6,
 212                                           (intersection_size / 6) * 2 + 1,
 213                                           (intersection_size / 6) * 2 + 1);
 214                     }
 215                     break;
 216                 case 's':
 217                     if (intersection_size <= 5)
 218                     {
 219                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET +
 220                                            1,
 221                                            pixel_y (POS (x, y)) + LINE_OFFSET +
 222                                            1);
 223                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET -
 224                                            1,
 225                                            pixel_y (POS (x, y)) + LINE_OFFSET -
 226                                            1);
 227                     }
 228                     else
 229                     {
 230                         rb->lcd_fillrect (pixel_x (POS (x, y)) + LINE_OFFSET -
 231                                           intersection_size / 6,
 232                                           pixel_y (POS (x, y)) + LINE_OFFSET -
 233                                           intersection_size / 6,
 234                                           (intersection_size / 6) * 2 + 1,
 235                                           (intersection_size / 6) * 2 + 1);
 236                     }
 237                     break;
 238
 239                 case 'c':
 240                     if (intersection_size > 7)
 241                     {
 242                         draw_circle (pixel_x (POS (x, y)) + LINE_OFFSET,
 243                                      pixel_y (POS (x, y)) + LINE_OFFSET,
 244                                      (intersection_size - 1) / 4, true);
 245                         break;
 246                     }
 247
 248                     /* purposely don't break here, draw small the same as
 249                        a triangle */
 250
 251                 case 't':
 252                     if (intersection_size <= 7)
 253                     {
 254                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET -
 255                                            1,
 256                                            pixel_y (POS (x, y)) + LINE_OFFSET +
 257                                            1);
 258                         rb->lcd_drawpixel (pixel_x (POS (x, y)) + LINE_OFFSET +
 259                                            1,
 260                                            pixel_y (POS (x, y)) + LINE_OFFSET -
 261                                            1);
 262                     }
 263                     else
 264                     {
 265                         xlcd_filltriangle (pixel_x (POS (x, y)) + LINE_OFFSET,
 266                                            pixel_y (POS (x, y)) + LINE_OFFSET -
 267                                            intersection_size / 4,
 268                                            pixel_x (POS (x, y)) + LINE_OFFSET +
 269                                            intersection_size / 4,
 270                                            pixel_y (POS (x, y)) + LINE_OFFSET +
 271                                            intersection_size / 4,
 272                                            pixel_x (POS (x, y)) + LINE_OFFSET -
 273                                            intersection_size / 4,
 274                                            pixel_y (POS (x, y)) + LINE_OFFSET +
 275                                            intersection_size / 4);
 276                     }
 277                     break;
 278                 default:
 279                     DEBUGF ("tried to display unknown mark '%c' %d\n",
 280                             display_marks[x + y * board_width],
 281                             display_marks[x + y * board_width]);
 282                     break;
 283                 };
 284
 285                 rb->lcd_set_drawmode (DRMODE_SOLID);
 286                 /* don't have to undo the colors for LCD_DEPTH > 1, most
 287                    functions assume bg and fg get clobbered */
 288             }
 289         }
 290     }
 291 }
 292
 293
 294 static void
 295 draw_circle (int c_x, int c_y, int r, bool filled)
 296 {
 297     int f = 1 - r;
 298     int x = 0;
 299     int y = r;
 300
 301     /* draw the points on the axes to make the loop easier */
 302     rb->lcd_drawpixel (c_x, c_y + r);
 303     rb->lcd_drawpixel (c_x, c_y - r);
 304
 305     if (filled)
 306     {
 307         rb->lcd_hline (c_x - r, c_x + r, c_y);
 308     }
 309     else
 310     {
 311         rb->lcd_drawpixel (c_x + r, c_y);
 312         rb->lcd_drawpixel (c_x - r, c_y);
 313     }
 314
 315     /* Now walk from the very top of the circle to 1/8th of the way around
 316        to the right.  For each point, draw the 8 symmetrical points. */
 317     while (x < y)
 318     {
 319         /* walk one pixel to the right */
 320         ++x;
 321
 322         /* And then adjust our discriminant, and adjust y if we've
 323            ventured outside of the circle. This boils down to walking a
 324            tightrope between being inside and outside the circle.  The
 325            updating functions are taken from expanding the discriminant
 326            function f(x, y) = x^2 + y^2 - r^2 after substituting in x + 1
 327            and y - 1 and then subtracting out f(x, y) */
 328         if (f <= 0)
 329         {
 330             f += 2 * x + 1;
 331         }
 332         else
 333         {
 334             --y;
 335             f += (x - y) * 2 + 1;
 336         }
 337
 338         if (filled)
 339         {
 340             /* each line takes care of 2 points on the circle so we only
 341                need 4 */
 342             rb->lcd_hline (c_x - y, c_x + y, c_y + x);
 343             rb->lcd_hline (c_x - y, c_x + y, c_y - x);
 344             rb->lcd_hline (c_x - x, c_x + x, c_y + y);
 345             rb->lcd_hline (c_x - x, c_x + x, c_y - y);
 346         }
 347         else
 348         {
 349             /* Draw all 8 symmetrical points */
 350             rb->lcd_drawpixel (c_x + x, c_y + y);
 351             rb->lcd_drawpixel (c_x + y, c_y + x);
 352             rb->lcd_drawpixel (c_x + y, c_y - x);
 353             rb->lcd_drawpixel (c_x + x, c_y - y);
 354             rb->lcd_drawpixel (c_x - x, c_y + y);
 355             rb->lcd_drawpixel (c_x - y, c_y + x);
 356             rb->lcd_drawpixel (c_x - y, c_y - x);
 357             rb->lcd_drawpixel (c_x - x, c_y - y);
 358         }
 359     }
 360 }
 361
 362
 363 void
 364 draw_screen_display (void)
 365 {
 366 #if LCD_DEPTH > 1
 367     int saved_fg = rb->lcd_get_foreground ();
 368     int saved_bg = rb->lcd_get_background ();
 369 #endif
 370     int saved_drmode = rb->lcd_get_drawmode ();
 371
 372     if (cursor_pos != last_cursor_pos || intersection_size != last_int_size)
 373     {
 374         cursor_updated ();
 375     }
 376
 377 #if LCD_DEPTH > 1
 378     rb->lcd_set_backdrop (NULL);
 379
 380     rb->lcd_set_foreground (BOARD_COLOR);
 381     rb->lcd_set_background (BACKGROUND_COLOR);
 382     rb->lcd_set_drawmode (DRMODE_SOLID);
 383
 384 #else
 385     rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 386 #endif
 387
 388     rb->lcd_clear_display ();
 389
 390     rb->lcd_fillrect (pixel_x (POS (MIN_X, MIN_Y)),
 391                       pixel_y (POS (MIN_X, MIN_Y)),
 392                       (MAX_X - MIN_X) * intersection_size,
 393                       (MAX_Y - MIN_Y) * intersection_size);
 394
 395 #if LCD_DEPTH > 1
 396     rb->lcd_set_foreground (LINE_COLOR);
 397 #else
 398     rb->lcd_set_drawmode (DRMODE_SOLID);
 399 #endif
 400
 401     unsigned int i;
 402     for (i = MIN_Y; i < MAX_Y; ++i)
 403     {
 404         rb->lcd_hline (pixel_x (POS (MIN_X, i)) + LINE_OFFSET + extend_l,
 405                        pixel_x (POS (MAX_X - 1, i)) + LINE_OFFSET + extend_r,
 406                        pixel_y (POS (MIN_X, i)) + LINE_OFFSET);
 407     }
 408
 409     for (i = MIN_X; i < MAX_X; ++i)
 410     {
 411         rb->lcd_vline (pixel_x (POS (i, MIN_Y)) + LINE_OFFSET,
 412                        pixel_y (POS (i, MIN_Y)) + LINE_OFFSET + extend_t,
 413                        pixel_y (POS (i, MAX_Y - 1)) + LINE_OFFSET + extend_b);
 414     }
 415
 416     draw_all_hoshi ();
 417     draw_all_stones ();
 418     draw_cursor (cursor_pos);
 419
 420     if (draw_variations)
 421     {
 422         mark_child_variations_sgf ();
 423     }
 424
 425     draw_all_marks ();
 426
 427     draw_footer ();
 428     rb->lcd_update ();
 429
 430 #if LCD_DEPTH > 1
 431     rb->lcd_set_foreground (saved_fg);
 432     rb->lcd_set_background (saved_bg);
 433 #endif
 434     rb->lcd_set_drawmode (saved_drmode);
 435 }
 436
 437
 438
 439 #if defined(GBN_WIDE_SCREEN)
 440
 441 /* the size of the string, in pixels, when drawn vertically */
 442 static void
 443 vert_string_size (char *string, int *width, int *height)
 444 {
 445     int temp_width = 0;
 446     int temp_height = 0;
 447
 448     int ret_width = 0;
 449     int ret_height = 0;
 450
 451     char temp_buffer[2];
 452
 453     temp_buffer[0] = temp_buffer[1] = 0;
 454
 455     if (!string)
 456     {
 457         return;
 458     }
 459
 460     while (*string)
 461     {
 462         temp_buffer[0] = *string;
 463         rb->lcd_getstringsize (temp_buffer, &temp_width, &temp_height);
 464
 465         ret_height += temp_height;
 466
 467         if (ret_width < temp_width)
 468         {
 469             ret_width = temp_width;
 470         }
 471
 472         ++string;
 473     }
 474
 475     if (width)
 476     {
 477         *width = ret_width;
 478     }
 479
 480     if (height)
 481     {
 482         *height = ret_height;
 483     }
 484 }
 485
 486 static void
 487 putsxy_vertical (int x, int y, int width, char *str)
 488 {
 489     int temp_width = 0;
 490     int temp_height = 0;
 491     char temp_buffer[2];
 492
 493     temp_buffer[0] = temp_buffer[1] = 0;
 494
 495     if (!str)
 496     {
 497         return;
 498     }
 499
 500     while (*str)
 501     {
 502         temp_buffer[0] = *str;
 503         rb->lcd_getstringsize (temp_buffer, &temp_width, &temp_height);
 504         DEBUGF ("putting %s at %d %d\n", temp_buffer,
 505                 x + (width - temp_width) / 2, y);
 506         rb->lcd_putsxy (x + (width - temp_width) / 2, y, temp_buffer);
 507         y += temp_height;
 508         ++str;
 509     }
 510 }
 511
 512 #endif /* GBN_WIDE_SCREEN */
 513
 514
 515 static void
 516 draw_footer (void)
 517 {
 518     char captures_buffer[16];
 519     char display_flags[16] = "";
 520     int size_x, size_y;
 521     int vert_x, vert_y;
 522
 523     (void) vert_x;
 524     (void) vert_y;
 525
 526 #if LCD_DEPTH > 1
 527     rb->lcd_set_background (BACKGROUND_COLOR);
 528     rb->lcd_set_foreground (BLACK_COLOR);
 529 #else
 530     rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 531 #endif
 532
 533     rb->snprintf (captures_buffer, sizeof (captures_buffer),
 534                   "%d", white_captures);
 535
 536
 537     rb->lcd_getstringsize (captures_buffer, &size_x, &size_y);
 538 #if defined(GBN_TALL_SCREEN)
 539     rb->lcd_putsxy (size_y + 2, LCD_HEIGHT - size_y, captures_buffer);
 540 #else
 541     vert_string_size (captures_buffer, &vert_x, &vert_y);
 542     if (board_pixel_width + size_x <= LCD_WIDTH)
 543     {
 544         rb->lcd_putsxy (LCD_WIDTH - size_x - 1, vert_x + 2, captures_buffer);
 545     }
 546     else
 547     {
 548         putsxy_vertical (LCD_WIDTH - vert_x - 1, vert_x + 2, vert_x,
 549                          captures_buffer);
 550     }
 551 #endif
 552
 553 #if LCD_DEPTH == 1
 554     rb->lcd_set_drawmode (DRMODE_SOLID);
 555 #endif
 556
 557 #if defined(GBN_TALL_SCREEN)
 558     draw_circle (size_y / 2,
 559                  LCD_HEIGHT - (size_y / 2), (size_y - 1) / 2, true);
 560
 561 #if LCD_DEPTH == 1
 562     rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 563     draw_circle (size_y / 2,
 564                  LCD_HEIGHT - (size_y / 2), (size_y - 1) / 2, false);
 565 #endif /* LCD_DEPTH */
 566
 567 #else /* !GBN_TALL_SCREEN */
 568     draw_circle (LCD_WIDTH - 1 - vert_x / 2,
 569                  (vert_x / 2), (vert_x - 1) / 2, true);
 570
 571 #if LCD_DEPTH == 1
 572     rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 573     draw_circle (LCD_WIDTH - 1 - vert_x / 2,
 574                  (vert_x / 2), (vert_x - 1) / 2, false);
 575 #endif /* LCD_DEPTH */
 576
 577 #endif /* GBN_TALL_SCREEN */
 578
 579
 580 #if LCD_DEPTH > 1
 581     rb->lcd_set_foreground (WHITE_COLOR);
 582 #endif
 583     rb->snprintf (captures_buffer, sizeof (captures_buffer),
 584                   "%d", black_captures);
 585
 586     rb->lcd_getstringsize (captures_buffer, &size_x, &size_y);
 587 #if defined(GBN_TALL_SCREEN)
 588     rb->lcd_putsxy (LCD_WIDTH - (size_y + 1) - size_x,
 589                     LCD_HEIGHT - size_y, captures_buffer);
 590
 591     draw_circle (LCD_WIDTH - (size_y / 2),
 592                  LCD_HEIGHT - (size_y / 2), (size_y - 1) / 2, true);
 593 #else
 594     vert_string_size (captures_buffer, &vert_x, &vert_y);
 595     if (board_pixel_width + size_x <= LCD_WIDTH)
 596     {
 597         rb->lcd_putsxy (LCD_WIDTH - size_x - 1,
 598                         LCD_HEIGHT - vert_x - size_y - 3, captures_buffer);
 599     }
 600     else
 601     {
 602         putsxy_vertical (LCD_WIDTH - vert_x - 1,
 603                          LCD_HEIGHT - vert_x - 3 - vert_y,
 604                          vert_x, captures_buffer);
 605     }
 606
 607     draw_circle (LCD_WIDTH - 1 - vert_x / 2,
 608                  LCD_HEIGHT - 1 - vert_x / 2, (vert_x - 1) / 2, true);
 609 #endif
 610
 611
 612 #if LCD_DEPTH > 1
 613     rb->lcd_set_foreground (BLACK_COLOR);
 614 #endif
 615
 616     if (has_comment)
 617     {
 618         rb->strcat (display_flags, "C");
 619     }
 620
 621     if (has_more_nodes_sgf ())
 622     {
 623         rb->strcat (display_flags, "+");
 624     }
 625
 626     if (num_variations_sgf () > 1)
 627     {
 628         rb->strcat (display_flags, "*");
 629     }
 630
 631
 632
 633     rb->snprintf (captures_buffer, sizeof (captures_buffer),
 634                   "%d%s", move_num, display_flags);
 635
 636     rb->lcd_getstringsize (captures_buffer, &size_x, &size_y);
 637 #if defined(GBN_TALL_SCREEN)
 638     rb->lcd_putsxy ((LCD_WIDTH - size_x) / 2,
 639                     LCD_HEIGHT - size_y, captures_buffer);
 640 #else
 641     if (board_pixel_width + size_x <= LCD_WIDTH)
 642     {
 643         rb->lcd_putsxy (LCD_WIDTH - size_x - 1,
 644                         (LCD_HEIGHT - size_y) / 2, captures_buffer);
 645     }
 646     else
 647     {
 648         vert_string_size (captures_buffer, &vert_x, &vert_y);
 649         putsxy_vertical (LCD_WIDTH - vert_x - 1,
 650                          (LCD_HEIGHT - vert_y) / 2, vert_x, captures_buffer);
 651     }
 652 #endif
 653
 654
 655     rb->lcd_set_drawmode (DRMODE_SOLID);
 656 }
 657
 658
 659
 660
 661
 662
 663
 664 static int
 665 pixel_x (unsigned short pos)
 666 {
 667     return board_x + (I (pos) - min_x_int) * intersection_size;
 668 }
 669
 670 static int
 671 pixel_y (unsigned short pos)
 672 {
 673     return board_y + (J (pos) - min_y_int) * intersection_size;
 674 }
 675
 676
 677
 678 void
 679 move_display (unsigned short pos)
 680 {
 681     if (!on_board (pos))
 682     {
 683         return;
 684     }
 685
 686     while ((unsigned) I (pos) >= REAL_MAX_X)
 687     {
 688         cursor_pos = EAST (cursor_pos);
 689         cursor_updated ();
 690     }
 691     while ((unsigned) I (pos) < REAL_MIN_X)
 692     {
 693         cursor_pos = WEST (cursor_pos);
 694         cursor_updated ();
 695     }
 696
 697     while ((unsigned) J (pos) >= REAL_MAX_Y)
 698     {
 699         cursor_pos = SOUTH (cursor_pos);
 700         cursor_updated ();
 701     }
 702     while ((unsigned) J (pos) < REAL_MIN_Y)
 703     {
 704         cursor_pos = NORTH (cursor_pos);
 705         cursor_updated ();
 706     }
 707 }
 708
 709
 710 static void
 711 cursor_updated (void)
 712 {
 713     if (!on_board(cursor_pos))
 714     {
 715         cursor_pos = WRAP (cursor_pos);
 716     }
 717
 718     if (intersection_size != last_int_size ||
 719         ((unsigned) I (cursor_pos)) < REAL_MIN_X + 1 ||
 720         ((unsigned) I (cursor_pos)) > REAL_MAX_X - 2 ||
 721         ((unsigned) J (cursor_pos)) < REAL_MIN_Y + 1 ||
 722         ((unsigned) J (cursor_pos)) > REAL_MAX_Y - 2)
 723     {
 724         if ((unsigned) I (cursor_pos) < (num_x_ints / 2))
 725         {
 726             min_x_int = 0;
 727         }
 728         else
 729         {
 730             min_x_int = min (I (cursor_pos) - (num_x_ints / 2),
 731                              board_width - num_x_ints);
 732         }
 733
 734         if ((unsigned) J (cursor_pos) < (num_y_ints / 2))
 735         {
 736             min_y_int = 0;
 737         }
 738         else
 739         {
 740
 741             min_y_int = min (J (cursor_pos) - (num_y_ints / 2),
 742                              board_height - num_y_ints);
 743         }
 744     }
 745
 746     /* these are used in line drawing to extend the lines if there is more
 747        board in that direction */
 748     if (MIN_X)
 749     {
 750         extend_l = -1 * LINE_OFFSET;
 751     }
 752     else
 753     {
 754         extend_l = 0;
 755     }
 756
 757     if (MIN_Y)
 758     {
 759         extend_t = -1 * LINE_OFFSET;
 760     }
 761     else
 762     {
 763         extend_t = 0;
 764     }
 765
 766     if (MAX_X != board_width)
 767     {
 768         extend_r = LINE_OFFSET;
 769     }
 770     else
 771     {
 772         extend_r = 0;
 773     }
 774
 775     if (MAX_Y != board_height)
 776     {
 777         extend_b = LINE_OFFSET;
 778     }
 779     else
 780     {
 781         extend_b = 0;
 782     }
 783
 784     last_cursor_pos = cursor_pos;
 785     last_int_size = intersection_size;
 786 }
 787
 788 static unsigned int
 789 unzoomed_int_size (void)
 790 {
 791     int int_size = min ((LCD_BOARD_WIDTH / board_width),
 792                         (LCD_BOARD_HEIGHT / board_height));
 793
 794     if (!(int_size & 1))
 795     {
 796         --int_size;
 797     }
 798
 799     if (int_size < 0)
 800     {
 801         int_size = 1;
 802     }
 803
 804     return max(int_size, MIN_INT_SIZE);
 805 }
 806
 807 unsigned int
 808 current_zoom_display (void)
 809 {
 810     return (intersection_size - unzoomed_int_size ()) / 2 + 1;
 811 }
 812
 813 unsigned int
 814 max_zoom_display (void)
 815 {
 816     return (MAX_INT_SIZE - unzoomed_int_size ()) / 2 + 1;
 817 }
 818
 819 unsigned int
 820 min_zoom_display (void)
 821 {
 822     if (MIN_INT_SIZE >= unzoomed_int_size())
 823     {
 824         return (MIN_INT_SIZE - unzoomed_int_size ()) / 2 + 1;
 825     }
 826     else
 827     {
 828         return 1;
 829     }
 830 }
 831
 832 void
 833 set_zoom_display (unsigned int zoom_level)
 834 {
 835     unsigned int unzoomed = unzoomed_int_size ();
 836
 837     if (saved_circle_size < MIN_INT_SIZE ||
 838         saved_circle_size > MAX_INT_SIZE)
 839     {
 840         saved_circle_size = MIN_DEFAULT_INT_SIZE;
 841     }
 842
 843     if (zoom_level == 0)
 844     {
 845         /* default zoom, we get to set it however we want */
 846         intersection_size = max (unzoomed, saved_circle_size);
 847     }
 848     else
 849     {
 850         intersection_size = unzoomed + 2 * (zoom_level - 1);
 851     }
 852
 853     if (intersection_size > MAX_INT_SIZE)
 854     {
 855         intersection_size = MAX_INT_SIZE;
 856     }
 857
 858     /* now intersection_size has been set appropriately, so set up all of
 859        the derived values used for display */
 860
 861     num_x_ints = min (LCD_BOARD_WIDTH / intersection_size, board_width);
 862     num_y_ints = min (LCD_BOARD_HEIGHT / intersection_size, board_height);
 863
 864     board_pixel_width = num_x_ints * intersection_size;
 865     board_pixel_height = num_y_ints * intersection_size;
 866
 867 #if defined(GBN_TALL_SCREEN)
 868     board_x = (LCD_WIDTH - board_pixel_width) / 2;
 869     board_y = 0;
 870 #elif defined(GBN_WIDE_SCREEN)
 871     board_x = 0;
 872     board_y = (LCD_HEIGHT - board_pixel_height) / 2;
 873 #else
 874 #error screen dimensions have not been evaluated properly
 875 #endif
 876 }
 877
 878
 879 /* Call every time the board size might have changed! */
 880 void
 881 setup_display (void)
 882 {
 883     set_zoom_display (0);       /* 0 means set to default */
 884
 885     /* The cursor starts out in the top right of the board
 886      * (on the hoshi point for most board sizes), unless the board
 887      * is really small in which case the cursor starts at the center
 888      * of the board.
 889      */
 890     int start_x, start_y;
 891     if (board_width >= 7)
 892     {
 893         start_x = board_width - 4;
 894     }
 895     else
 896     {
 897         start_x = board_width / 2;
 898     }
 899
 900     if (board_height >= 7)
 901     {
 902         start_y = 3;
 903     }
 904     else
 905     {
 906         start_y = board_height / 2;
 907     }
 908     cursor_pos = POS (start_x, start_y);
 909     last_cursor_pos = INVALID_POS;
 910     last_int_size = -1;
 911
 912     clear_marks_display ();
 913 }
 914
 915 static void
 916 draw_cursor (unsigned short pos)
 917 {
 918     if (!on_board (pos))
 919     {
 920         return;
 921     }
 922
 923 #if LCD_DEPTH > 1
 924     rb->lcd_set_foreground (CURSOR_COLOR);
 925 #else
 926     rb->lcd_set_drawmode (DRMODE_COMPLEMENT);
 927 #endif
 928
 929     rb->lcd_drawrect (pixel_x (pos),
 930                       pixel_y (pos), intersection_size, intersection_size);
 931
 932     rb->lcd_set_drawmode (DRMODE_SOLID);
 933 }
 934
 935 static void
 936 draw_stone_raw (int pixel_x, int pixel_y, bool black)
 937 {
 938 #if LCD_DEPTH > 1
 939     rb->lcd_set_foreground (black ? BLACK_COLOR : WHITE_COLOR);
 940 #else
 941     if (black)
 942     {
 943         rb->lcd_set_drawmode (DRMODE_SOLID);
 944     }
 945     else
 946     {
 947         rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 948     }
 949 #endif
 950
 951     draw_circle (pixel_x + LINE_OFFSET,
 952                  pixel_y + LINE_OFFSET, LINE_OFFSET, true);
 953
 954 #if defined(OUTLINE_STONES)
 955 #if LCD_DEPTH > 1
 956     rb->lcd_set_foreground (black ? WHITE_COLOR : BLACK_COLOR);
 957 #else
 958     if (black)
 959     {
 960         rb->lcd_set_drawmode (DRMODE_SOLID + DRMODE_INVERSEVID);
 961     }
 962     else
 963     {
 964         rb->lcd_set_drawmode (DRMODE_SOLID);
 965     }
 966 #endif /* LCD_DEPTH > 1 */
 967
 968     if (!black)
 969     {
 970         draw_circle (pixel_x + LINE_OFFSET,
 971                      pixel_y + LINE_OFFSET, LINE_OFFSET, false);
 972     }
 973
 974 #endif /* OUTLINE_STONES */
 975
 976     rb->lcd_set_drawmode (DRMODE_SOLID);
 977 }
 978
 979
 980 static void
 981 draw_stone (unsigned short pos, bool black)
 982 {
 983     if (!on_board (pos))
 984     {
 985         return;
 986     }
 987
 988     draw_stone_raw (pixel_x (pos), pixel_y (pos), black);
 989 }
 990
 991
 992 static void
 993 draw_all_stones (void)
 994 {
 995     unsigned int x, y;
 996     unsigned short temp_pos;
 997
 998     for (x = MIN_X; x < MAX_X; ++x)
 999     {
1000         for (y = MIN_Y; y < MAX_Y; ++y)
1001         {
1002             temp_pos = POS (x, y);
1003             if (get_point_board (temp_pos) == EMPTY)
1004             {
1005                 continue;
1006             }
1007
1008             draw_stone (temp_pos, get_point_board (temp_pos) == BLACK);
1009         }
1010     }
1011 }
1012
1013 static void
1014 draw_hoshi (unsigned short pos)
1015 {
1016     /* color and drawmode are already set before this function (all lines
1017        and hoshi and stuff are drawn together) */
1018
1019     if (!on_board(pos))
1020     {
1021         return;
1022     }
1023
1024     if ((unsigned) I (pos) < MIN_X ||
1025         (unsigned) I (pos) >= MAX_X ||
1026         (unsigned) J (pos) < MIN_Y ||
1027         (unsigned) J (pos) >= MAX_Y)
1028     {
1029         return;
1030     }
1031     if (intersection_size > 8)
1032     {
1033         rb->lcd_fillrect (pixel_x (pos) + LINE_OFFSET - 1,
1034                           pixel_y (pos) + LINE_OFFSET - 1, 3, 3);
1035     }
1036     else
1037     {
1038         rb->lcd_drawpixel (pixel_x (pos) + LINE_OFFSET - 1,
1039                            pixel_y (pos) + LINE_OFFSET - 1);
1040         rb->lcd_drawpixel (pixel_x (pos) + LINE_OFFSET + 1,
1041                            pixel_y (pos) + LINE_OFFSET + 1);
1042     }
1043 }
1044
1045
1046 static void
1047 draw_all_hoshi (void)
1048 {
1049     if (board_width != board_height)
1050     {
1051         return;
1052     }
1053
1054     if (board_width == 19)
1055     {
1056         draw_hoshi (POS (3, 3));
1057         draw_hoshi (POS (3, 9));
1058         draw_hoshi (POS (3, 15));
1059
1060         draw_hoshi (POS (9, 3));
1061         draw_hoshi (POS (9, 9));
1062         draw_hoshi (POS (9, 15));
1063
1064         draw_hoshi (POS (15, 3));
1065         draw_hoshi (POS (15, 9));
1066         draw_hoshi (POS (15, 15));
1067     }
1068     else if (board_width == 9)
1069     {
1070         draw_hoshi (POS (2, 2));
1071         draw_hoshi (POS (2, 6));
1072
1073         draw_hoshi (POS (4, 4));
1074
1075         draw_hoshi (POS (6, 2));
1076         draw_hoshi (POS (6, 6));
1077     }
1078     else if (board_width == 13)
1079     {
1080         draw_hoshi (POS (3, 3));
1081         draw_hoshi (POS (3, 9));
1082
1083         draw_hoshi (POS (6, 6));
1084
1085         draw_hoshi (POS (9, 3));
1086         draw_hoshi (POS (9, 9));
1087
1088     }
1089 }