draw.c

   1 /*
   2  * draw.c -- drawing routines for XBoard
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
   9  *
  10  * The following terms apply to Digital Equipment Corporation's copyright
  11  * interest in XBoard:
  12  * ------------------------------------------------------------------------
  13  * All Rights Reserved
  14  *
  15  * Permission to use, copy, modify, and distribute this software and its
  16  * documentation for any purpose and without fee is hereby granted,
  17  * provided that the above copyright notice appear in all copies and that
  18  * both that copyright notice and this permission notice appear in
  19  * supporting documentation, and that the name of Digital not be
  20  * used in advertising or publicity pertaining to distribution of the
  21  * software without specific, written prior permission.
  22  *
  23  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  24  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  25  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  26  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  27  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  28  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  29  * SOFTWARE.
  30  * ------------------------------------------------------------------------
  31  *
  32  * The following terms apply to the enhanced version of XBoard
  33  * distributed by the Free Software Foundation:
  34  * ------------------------------------------------------------------------
  35  *
  36  * GNU XBoard is free software: you can redistribute it and/or modify
  37  * it under the terms of the GNU General Public License as published by
  38  * the Free Software Foundation, either version 3 of the License, or (at
  39  * your option) any later version.
  40  *
  41  * GNU XBoard is distributed in the hope that it will be useful, but
  42  * WITHOUT ANY WARRANTY; without even the implied warranty of
  43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  44  * General Public License for more details.
  45  *
  46  * You should have received a copy of the GNU General Public License
  47  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  48  *
  49  *------------------------------------------------------------------------
  50  ** See the file ChangeLog for a revision history.  */
  51
  52 #include "config.h"
  53
  54 #include <stdio.h>
  55 #include <math.h>
  56 #include <cairo/cairo.h>
  57 #include <cairo/cairo-xlib.h>
  58 #include <librsvg/rsvg.h>
  59 #include <librsvg/rsvg-cairo.h>
  60
  61 #if STDC_HEADERS
  62 # include <stdlib.h>
  63 # include <string.h>
  64 #else /* not STDC_HEADERS */
  65 extern char *getenv();
  66 # if HAVE_STRING_H
  67 #  include <string.h>
  68 # else /* not HAVE_STRING_H */
  69 #  include <strings.h>
  70 # endif /* not HAVE_STRING_H */
  71 #endif /* not STDC_HEADERS */
  72
  73 #if ENABLE_NLS
  74 #include <locale.h>
  75 #endif
  76
  77 #include "common.h"
  78
  79 #include "backend.h"
  80 #include "board.h"
  81 #include "menus.h"
  82 #include "dialogs.h"
  83 #include "evalgraph.h"
  84 #include "gettext.h"
  85 #include "draw.h"
  86
  87
  88 #ifdef __EMX__
  89 #ifndef HAVE_USLEEP
  90 #define HAVE_USLEEP
  91 #endif
  92 #define usleep(t)   _sleep2(((t)+500)/1000)
  93 #endif
  94
  95 #ifdef ENABLE_NLS
  96 # define  _(s) gettext (s)
  97 # define N_(s) gettext_noop (s)
  98 #else
  99 # define  _(s) (s)
 100 # define N_(s)  s
 101 #endif
 102
 103 #define SOLID 0
 104 #define OUTLINE 1
 105 Boolean cairoAnimate;
 106 Option *currBoard;
 107 cairo_surface_t *csBoardWindow;
 108 static cairo_surface_t *pngPieceImages[2][(int)BlackPawn+4];   // png 256 x 256 images
 109 static cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn];    // scaled pieces as used
 110 static cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
 111 static RsvgHandle *svgPieces[2][(int)BlackPawn+4]; // vector pieces in store
 112 static cairo_surface_t *pngBoardBitmap[2], *pngOriginalBoardBitmap[2];
 113 int useTexture, textureW[2], textureH[2];
 114
 115 #define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
 116 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
 117
 118 #define White(piece) ((int)(piece) < (int)BlackPawn)
 119
 120 char svgDir[MSG_SIZ] = SVGDIR;
 121
 122 char *crWhite = "#FFFFB0";
 123 char *crBlack = "#AD5D3D";
 124
 125 struct {
 126   int x1, x2, y1, y2;
 127 } gridSegments[BOARD_RANKS + BOARD_FILES + 2];
 128
 129 void
 130 SwitchWindow (int main)
 131 {
 132     currBoard = (main ? &mainOptions[W_BOARD] : &dualOptions[3]);
 133     csBoardWindow = DRAWABLE(currBoard);
 134 }
 135
 136 void
 137 SelectPieces(VariantClass v)
 138 {
 139     int i;
 140     for(i=0; i<2; i++) {
 141         int p;
 142         for(p=0; p<=(int)WhiteKing; p++)
 143            pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
 144         if(v == VariantShogi && BOARD_HEIGHT != 7) { // no exceptions in Tori Shogi
 145            pngPieceBitmaps[i][(int)WhiteCannon] = pngPieceBitmaps2[i][(int)WhiteTokin];
 146            pngPieceBitmaps[i][(int)WhiteNightrider] = pngPieceBitmaps2[i][(int)WhiteKing+2];
 147            pngPieceBitmaps[i][(int)WhiteGrasshopper] = pngPieceBitmaps2[i][(int)WhiteKing+3];
 148            pngPieceBitmaps[i][(int)WhiteSilver] = pngPieceBitmaps2[i][(int)WhiteKing+4];
 149            pngPieceBitmaps[i][(int)WhiteQueen] = pngPieceBitmaps2[i][(int)WhiteLance];
 150            pngPieceBitmaps[i][(int)WhiteFalcon] = pngPieceBitmaps2[i][(int)WhiteMonarch]; // for Sho Shogi
 151         }
 152 #ifdef GOTHIC
 153         if(v == VariantGothic) {
 154            pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteSilver];
 155         }
 156 #endif
 157         if(v == VariantSChess) {
 158            pngPieceBitmaps[i][(int)WhiteAngel]    = pngPieceBitmaps2[i][(int)WhiteFalcon];
 159            pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteAlfil];
 160         }
 161         if(v == VariantChuChess) {
 162            pngPieceBitmaps[i][(int)WhiteNightrider] = pngPieceBitmaps2[i][(int)WhiteLion];
 163         }
 164         if(v == VariantChu) {
 165            pngPieceBitmaps[i][(int)WhiteNightrider] = pngPieceBitmaps2[i][(int)WhiteKing+1];
 166            pngPieceBitmaps[i][(int)WhiteUnicorn] = pngPieceBitmaps2[i][(int)WhiteCat];
 167            pngPieceBitmaps[i][(int)WhiteSilver]  = pngPieceBitmaps2[i][(int)WhiteSword];
 168            pngPieceBitmaps[i][(int)WhiteFalcon]  = pngPieceBitmaps2[i][(int)WhiteDagger];
 169         }
 170     }
 171 }
 172
 173 #define BoardSize int
 174 void
 175 InitDrawingSizes (BoardSize boardSize, int flags)
 176 {   // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
 177     int boardWidth, boardHeight;
 178     static int oldWidth, oldHeight;
 179     static VariantClass oldVariant;
 180     static int oldTwoBoards = 0, oldNrOfFiles = 0;
 181
 182     if(!mainOptions[W_BOARD].handle) return;
 183
 184     if(boardSize == -2 && gameInfo.variant != oldVariant
 185                        && oldNrOfFiles && oldNrOfFiles != BOARD_WIDTH) { // called because variant switch changed board format
 186         squareSize = ((squareSize + lineGap) * oldNrOfFiles + 0.5*BOARD_WIDTH) / BOARD_WIDTH; // keep total width fixed
 187         if(appData.overrideLineGap < 0) lineGap = squareSize < 37 ? 1 : squareSize < 59 ? 2 : squareSize < 116 ? 3 : 4;
 188         squareSize -= lineGap;
 189         CreatePNGPieces();
 190         CreateGrid();
 191     }
 192     oldNrOfFiles = BOARD_WIDTH;
 193
 194     if(oldTwoBoards && !twoBoards) PopDown(DummyDlg);
 195     oldTwoBoards = twoBoards;
 196
 197     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
 198     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
 199     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 200
 201   if(boardWidth != oldWidth || boardHeight != oldHeight) { // do resizing stuff only if size actually changed
 202
 203     oldWidth = boardWidth; oldHeight = boardHeight;
 204     CreateGrid();
 205     CreateAnyPieces(0); // redo texture scaling
 206
 207     /*
 208      * Inhibit shell resizing.
 209      */
 210     ResizeBoardWindow(boardWidth, boardHeight, 0);
 211
 212     DelayedDrag();
 213   }
 214
 215     // [HGM] pieces: tailor piece bitmaps to needs of specific variant
 216     // (only for xpm)
 217
 218   if(gameInfo.variant != oldVariant) { // and only if variant changed
 219
 220     SelectPieces(gameInfo.variant);
 221
 222     oldVariant = gameInfo.variant;
 223   }
 224   CreateAnimVars();
 225 }
 226
 227 void
 228 ExposeRedraw (Option *graph, int x, int y, int w, int h)
 229 {   // copy a selected part of the buffer bitmap to the display
 230     cairo_t *cr = cairo_create((cairo_surface_t *) graph->textValue);
 231     cairo_set_source_surface(cr, (cairo_surface_t *) graph->choice, 0, 0);
 232     cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 233     cairo_rectangle(cr, x, y, w, h);
 234     cairo_fill(cr);
 235     cairo_destroy(cr);
 236 }
 237
 238 static void
 239 CreatePNGBoard (char *s, int kind)
 240 {
 241     float w, h;
 242     static float n[2] = { 1., 1. };
 243     if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
 244     if(strstr(s, ".png")) {
 245         cairo_surface_t *img = cairo_image_surface_create_from_png (s);
 246         if(img) {
 247             char c, *p = s, *q;
 248             int r, f;
 249             if(pngOriginalBoardBitmap[kind]) cairo_surface_destroy(pngOriginalBoardBitmap[kind]);
 250             if(n[kind] != 1.) cairo_surface_destroy(pngBoardBitmap[kind]);
 251             useTexture |= kind + 1; pngOriginalBoardBitmap[kind] = img;
 252             w = textureW[kind] = cairo_image_surface_get_width (img);
 253             h = textureH[kind] = cairo_image_surface_get_height (img);
 254             n[kind] = 1.;
 255             while((q = strchr(p+1, '-'))) p = q; // find last '-'
 256             if(strlen(p) < 11 && sscanf(p, "-%dx%d.pn%c", &f, &r, &c) == 3 && c == 'g') {
 257                 if(f == 0 || r == 0) f = BOARD_WIDTH, r = BOARD_HEIGHT; // 0x0 means 'fits any', so make it fit
 258                 textureW[kind] = (w*BOARD_WIDTH)/f; // sync cutting locations with square pattern
 259                 textureH[kind] = (h*BOARD_HEIGHT)/r;
 260                 n[kind] = r*squareSize/h; // scale to make it fit exactly vertically
 261             } else
 262             if((p = strstr(s, "xq")) && (p == s || p[-1] == '/')) { // assume full-board image for Xiangqi
 263                 while(0.8*squareSize*BOARD_WIDTH > n[kind]*w || 0.8*squareSize*BOARD_HEIGHT > n[kind]*h) n[kind]++;
 264             } else {
 265                 while(squareSize > n[kind]*w || squareSize > n[kind]*h) n[kind]++;
 266             }
 267             if(n[kind] == 1.) pngBoardBitmap[kind] = img; else {
 268                 // create scaled-up copy of the raw png image when it was too small
 269                 cairo_surface_t *cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, n[kind]*w, n[kind]*h);
 270                 cairo_t *cr = cairo_create(cs);
 271                 pngBoardBitmap[kind] = cs; textureW[kind] *= n[kind]; textureH[kind] *= n[kind];
 272 //              cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 273                 cairo_scale(cr, n[kind], n[kind]);
 274                 cairo_set_source_surface (cr, img, 0, 0);
 275                 cairo_paint (cr);
 276                 cairo_destroy (cr);
 277             }
 278         }
 279     }
 280 }
 281
 282 char *pngPieceNames[] = // must be in same order as internal piece encoding
 283 { "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner",
 284   "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "Lion",
 285   "GoldPawn", "HSword", "PromoHorse", "PromoDragon", "Leopard", "PromoSword", "Prince", "Phoenix", "Kylin", "PromoRook", "PromoHSword",
 286   "Dolphin", "Chancellor", "Unicorn", "Hawk", "Sword", "Princess", "HCrown", "Knight", "Elephant", "PromoBishop", "King",
 287   "Claw", "GoldKnight", "GoldLance", "GoldSilver", NULL
 288 };
 289
 290 char *backupPiece[] = { "King", "Queen", "Lion" }; // pieces that map on other when not kanji
 291
 292 RsvgHandle *
 293 LoadSVG (char *dir, int color, int piece, int retry)
 294 {
 295     char buf[MSG_SIZ];
 296   RsvgHandle *svg=svgPieces[color][piece];
 297   RsvgDimensionData svg_dimensions;
 298   GError *svgerror=NULL;
 299   cairo_surface_t *img;
 300   cairo_t *cr;
 301
 302     snprintf(buf, MSG_SIZ, "%s/%s%s.svg", dir, color ? "Black" : "White",
 303              retry ? backupPiece[piece - WhiteMonarch] : pngPieceNames[piece]);
 304
 305     if(svg || *dir && (svg = rsvg_handle_new_from_file(buf, &svgerror))) {
 306
 307       rsvg_handle_get_dimensions(svg, &svg_dimensions);
 308       img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, squareSize,  squareSize);
 309
 310       cr = cairo_create(img);
 311       cairo_scale(cr, squareSize/(double) svg_dimensions.width, squareSize/(double) svg_dimensions.height);
 312       rsvg_handle_render_cairo(svg, cr);
 313       if(cairo_surface_status(img) == CAIRO_STATUS_SUCCESS) {
 314         if(pngPieceImages[color][piece]) cairo_surface_destroy(pngPieceImages[color][piece]);
 315         pngPieceImages[color][piece] = img;
 316       }
 317       cairo_destroy(cr);
 318
 319       return svg;
 320     }
 321     if(!retry && piece >= WhiteMonarch && piece <= WhiteNothing) // pieces that are only different in kanji sets
 322         return LoadSVG(dir, color, piece, 1);
 323     if(svgerror)
 324         g_error_free(svgerror);
 325     return NULL;
 326 }
 327
 328 static void
 329 ScaleOnePiece (int color, int piece)
 330 {
 331   float w, h;
 332   char buf[MSG_SIZ];
 333   cairo_surface_t *img, *cs;
 334   cairo_t *cr;
 335
 336   g_type_init ();
 337
 338   svgPieces[color][piece] = LoadSVG("", color, piece, 0); // this fills pngPieceImages if we had cached svg with bitmap of wanted size
 339
 340   if(!pngPieceImages[color][piece]) { // we don't have cached bitmap (implying we did not have cached svg)
 341     if(*appData.pieceDirectory) { // user specified piece directory
 342       snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pieceDirectory, color ? "Black" : "White", pngPieceNames[piece]);
 343       img = cairo_image_surface_create_from_png (buf); // try if there are png pieces there
 344       if(cairo_surface_status(img) != CAIRO_STATUS_SUCCESS) { // there were not
 345         svgPieces[color][piece] = LoadSVG(appData.pieceDirectory, color, piece, 0); // so try if he has svg there
 346       } else pngPieceImages[color][piece] = img;
 347     }
 348   }
 349
 350   if(!pngPieceImages[color][piece]) { // we still did not manage to acquire a piece bitmap
 351     static int warned = 0;
 352     if(!(svgPieces[color][piece] = LoadSVG(svgDir, color, piece, 0)) && !warned) { // try to fall back on installed svg
 353       char *msg = _("No default pieces installed!\nSelect your own using '-pieceImageDirectory'.");
 354       printf("%s\n", msg); // give up
 355       DisplayError(msg, 0);
 356       warned = 1; // prevent error message being repeated for each piece type
 357     }
 358   }
 359
 360   img = pngPieceImages[color][piece];
 361
 362   // create new bitmap to hold scaled piece image (and remove any old)
 363   if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
 364   pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 365
 366   if(!img) return;
 367
 368   // scaled copying of the raw png image
 369   cr = cairo_create(cs);
 370   w = cairo_image_surface_get_width (img);
 371   h = cairo_image_surface_get_height (img);
 372   cairo_scale(cr, squareSize/w, squareSize/h);
 373   cairo_set_source_surface (cr, img, 0, 0);
 374   cairo_paint (cr);
 375   cairo_destroy (cr);
 376
 377   if(!appData.trueColors || !*appData.pieceDirectory) { // operate on bitmap to color it (king-size hack...)
 378     int stride = cairo_image_surface_get_stride(cs)/4;
 379     int *buf = (int *) cairo_image_surface_get_data(cs);
 380     int i, j, p;
 381     sscanf(color ? appData.blackPieceColor+1 : appData.whitePieceColor+1, "%x", &p); // replacement color
 382     cairo_surface_flush(cs);
 383     for(i=0; i<squareSize; i++) for(j=0; j<squareSize; j++) {
 384         int r, a;
 385         float f;
 386         unsigned int c = buf[i*stride + j];
 387         a = c >> 24; r = c >> 16 & 255;     // alpha and red, where red is the 'white' weight, since white is #FFFFCC in the source images
 388         f = (color ? a - r : r)/255.;       // fraction of black or white in the mix that has to be replaced
 389         buf[i*stride + j] = c & 0xFF000000; // alpha channel is kept at same opacity
 390         buf[i*stride + j] += ((int)(f*(p&0xFF0000)) & 0xFF0000) + ((int)(f*(p&0xFF00)) & 0xFF00) + (int)(f*(p&0xFF)); // add desired fraction of new color
 391         if(color) buf[i*stride + j] += r | r << 8 | r << 16; // details on black pieces get their weight added in pure white
 392         if(appData.monoMode) {
 393             if(a < 64) buf[i*stride + j] = 0; // if not opaque enough, totally transparent
 394             else if(2*r < a) buf[i*stride + j] = 0xFF000000; // if not light enough, totally black
 395             else buf[i*stride + j] = 0xFFFFFFFF; // otherwise white
 396         }
 397     }
 398     cairo_surface_mark_dirty(cs);
 399   }
 400 }
 401
 402 void
 403 CreatePNGPieces ()
 404 {
 405   int p;
 406
 407   for(p=0; pngPieceNames[p]; p++) {
 408     ScaleOnePiece(0, p);
 409     ScaleOnePiece(1, p);
 410   }
 411   SelectPieces(gameInfo.variant);
 412 }
 413
 414 void
 415 CreateAnyPieces (int p)
 416 {   // [HGM] taken out of main
 417     if(p) CreatePNGPieces();
 418     CreatePNGBoard(appData.liteBackTextureFile, 1);
 419     CreatePNGBoard(appData.darkBackTextureFile, 0);
 420 }
 421
 422 void
 423 InitDrawingParams (int reloadPieces)
 424 {
 425     int i, p;
 426     if(reloadPieces)
 427     for(i=0; i<2; i++) for(p=0; p<BlackPawn+4; p++) {
 428         if(pngPieceImages[i][p]) cairo_surface_destroy(pngPieceImages[i][p]);
 429         pngPieceImages[i][p] = NULL;
 430         if(svgPieces[i][p]) rsvg_handle_close(svgPieces[i][p], NULL);
 431         svgPieces[i][p] = NULL;
 432     }
 433     CreateAnyPieces(1);
 434 }
 435
 436 // [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
 437
 438 float
 439 Color (char *col, int n)
 440 {
 441   int c;
 442   sscanf(col, "#%x", &c);
 443   c = c >> 4*n & 255;
 444   return c/255.;
 445 }
 446
 447 void
 448 SetPen (cairo_t *cr, float w, char *col, int dash)
 449 {
 450   static const double dotted[] = {4.0, 4.0};
 451   static int len  = sizeof(dotted) / sizeof(dotted[0]);
 452   cairo_set_line_width (cr, w);
 453   cairo_set_source_rgba (cr, Color(col, 4), Color(col, 2), Color(col, 0), 1.0);
 454   if(dash) cairo_set_dash (cr, dotted, len, 0.0);
 455 }
 456
 457 void DrawSeekAxis( int x, int y, int xTo, int yTo )
 458 {
 459     cairo_t *cr;
 460
 461     /* get a cairo_t */
 462     cr = cairo_create (csBoardWindow);
 463
 464     cairo_move_to (cr, x, y);
 465     cairo_line_to(cr, xTo, yTo );
 466
 467     SetPen(cr, 2, "#000000", 0);
 468     cairo_stroke(cr);
 469
 470     /* free memory */
 471     cairo_destroy (cr);
 472     GraphExpose(currBoard, x-1, yTo-1, xTo-x+2, y-yTo+2);
 473 }
 474
 475 void DrawSeekBackground( int left, int top, int right, int bottom )
 476 {
 477     cairo_t *cr = cairo_create (csBoardWindow);
 478
 479     cairo_rectangle (cr, left, top, right-left, bottom-top);
 480
 481     cairo_set_source_rgba(cr, 0.8, 0.8, 0.4,1.0);
 482     cairo_fill(cr);
 483
 484     /* free memory */
 485     cairo_destroy (cr);
 486     GraphExpose(currBoard, left, top, right-left, bottom-top);
 487 }
 488
 489 void DrawSeekText(char *buf, int x, int y)
 490 {
 491     cairo_t *cr = cairo_create (csBoardWindow);
 492
 493     cairo_select_font_face (cr, "Sans",
 494                             CAIRO_FONT_SLANT_NORMAL,
 495                             CAIRO_FONT_WEIGHT_NORMAL);
 496
 497     cairo_set_font_size (cr, 12.0);
 498
 499     cairo_move_to (cr, x, y+4);
 500     cairo_set_source_rgba(cr, 0, 0, 0,1.0);
 501     cairo_show_text( cr, buf);
 502
 503     /* free memory */
 504     cairo_destroy (cr);
 505     GraphExpose(currBoard, x-5, y-10, 60, 15);
 506 }
 507
 508 void DrawSeekDot(int x, int y, int colorNr)
 509 {
 510     cairo_t *cr = cairo_create (csBoardWindow);
 511     int square = colorNr & 0x80;
 512     colorNr &= 0x7F;
 513
 514     if(square)
 515         cairo_rectangle (cr, x-squareSize/9, y-squareSize/9, 2*(squareSize/9), 2*(squareSize/9));
 516     else
 517         cairo_arc(cr, x, y, squareSize/9, 0.0, 2*M_PI);
 518
 519     SetPen(cr, 2, "#000000", 0);
 520     cairo_stroke_preserve(cr);
 521     switch (colorNr) {
 522       case 0: cairo_set_source_rgba(cr, 1.0, 0, 0,1.0); break;
 523       case 1: cairo_set_source_rgba (cr, 0.0, 0.7, 0.2, 1.0); break;
 524       default: cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 1.0); break;
 525     }
 526     cairo_fill(cr);
 527
 528     /* free memory */
 529     cairo_destroy (cr);
 530     GraphExpose(currBoard, x-squareSize/8, y-squareSize/8, 2*(squareSize/8), 2*(squareSize/8));
 531 }
 532
 533 void
 534 InitDrawingHandle (Option *opt)
 535 {
 536     csBoardWindow = DRAWABLE(opt);
 537 }
 538
 539 void
 540 CreateGrid ()
 541 {
 542     int i, j;
 543
 544     if (lineGap == 0) return;
 545
 546     /* [HR] Split this into 2 loops for non-square boards. */
 547
 548     for (i = 0; i < BOARD_HEIGHT + 1; i++) {
 549         gridSegments[i].x1 = 0;
 550         gridSegments[i].x2 =
 551           lineGap + BOARD_WIDTH * (squareSize + lineGap);
 552         gridSegments[i].y1 = gridSegments[i].y2
 553           = lineGap / 2 + (i * (squareSize + lineGap));
 554     }
 555
 556     for (j = 0; j < BOARD_WIDTH + 1; j++) {
 557         gridSegments[j + i].y1 = 0;
 558         gridSegments[j + i].y2 =
 559           lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 560         gridSegments[j + i].x1 = gridSegments[j + i].x2
 561           = lineGap / 2 + (j * (squareSize + lineGap));
 562     }
 563 }
 564
 565 void
 566 DrawGrid()
 567 {
 568   /* draws a grid starting around Nx, Ny squares starting at x,y */
 569   int i;
 570   float odd = (lineGap & 1)/2.;
 571   cairo_t *cr;
 572
 573   /* get a cairo_t */
 574   cr = cairo_create (csBoardWindow);
 575
 576   cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 577   SetPen(cr, lineGap, "#000000", 0);
 578
 579   /* lines in X */
 580   for (i = 0; i < BOARD_WIDTH + BOARD_HEIGHT + 2; i++)
 581     {
 582       int h = (gridSegments[i].y1 == gridSegments[i].y2); // horizontal
 583       cairo_move_to (cr, gridSegments[i].x1 + !h*odd, gridSegments[i].y1 + h*odd);
 584       cairo_line_to (cr, gridSegments[i].x2 + !h*odd, gridSegments[i].y2 + h*odd);
 585       cairo_stroke (cr);
 586     }
 587
 588   /* free memory */
 589   cairo_destroy (cr);
 590
 591   return;
 592 }
 593
 594 void
 595 DrawBorder (int x, int y, int type, int odd)
 596 {
 597     cairo_t *cr;
 598     char *col;
 599
 600     switch(type) {
 601         case 0: col = "#000000"; break;
 602         case 1: col = appData.highlightSquareColor; break;
 603         case 2: col = appData.premoveHighlightColor; break;
 604         default: col = "#808080"; break; // cannot happen
 605     }
 606     cr = cairo_create(csBoardWindow);
 607     cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 608     cairo_rectangle(cr, x+odd/2., y+odd/2., squareSize+lineGap, squareSize+lineGap);
 609     SetPen(cr, lineGap, col, 0);
 610     cairo_stroke(cr);
 611     cairo_destroy(cr);
 612     GraphExpose(currBoard, x - lineGap/2, y - lineGap/2, squareSize+2*lineGap+odd, squareSize+2*lineGap+odd);
 613 }
 614
 615 static int
 616 CutOutSquare (int x, int y, int *x0, int *y0, int  kind)
 617 {
 618     int W = BOARD_WIDTH, H = BOARD_HEIGHT;
 619     int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
 620     *x0 = 0; *y0 = 0;
 621     if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
 622     if(textureW[kind] < W*squareSize)
 623         *x0 = (textureW[kind] - squareSize) * nx/(W-1);
 624     else
 625         *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
 626     if(textureH[kind] < H*squareSize)
 627         *y0 = (textureH[kind] - squareSize) * ny/(H-1);
 628     else
 629         *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
 630     return 1;
 631 }
 632
 633 void
 634 DrawLogo (Option *opt, void *logo)
 635 {
 636     cairo_surface_t *img;
 637     cairo_t *cr;
 638     int w, h;
 639
 640     if(!logo || !opt) return;
 641     img = cairo_image_surface_create_from_png (logo);
 642     w = cairo_image_surface_get_width (img);
 643     h = cairo_image_surface_get_height (img);
 644     cr = cairo_create(DRAWABLE(opt));
 645 //    cairo_scale(cr, (float)appData.logoSize/w, appData.logoSize/(2.*h));
 646     cairo_scale(cr, (float)opt->max/w, (float)opt->value/h);
 647     cairo_set_source_surface (cr, img, 0, 0);
 648     cairo_paint (cr);
 649     cairo_destroy (cr);
 650     cairo_surface_destroy (img);
 651     GraphExpose(opt, 0, 0, appData.logoSize, appData.logoSize/2);
 652 }
 653
 654 static void
 655 BlankSquare (cairo_surface_t *dest, int x, int y, int color, ChessSquare piece, int fac)
 656 {   // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
 657     int x0, y0;
 658     cairo_t *cr;
 659
 660     cr = cairo_create (dest);
 661
 662     if ((useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
 663             cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
 664             cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 665             cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
 666             cairo_fill (cr);
 667             cairo_destroy (cr);
 668     } else { // evenly colored squares
 669         char *col = NULL;
 670         switch (color) {
 671           case 0: col = appData.darkSquareColor; break;
 672           case 1: col = appData.lightSquareColor; break;
 673           case 2: col = "#000000"; break;
 674           default: col = "#808080"; break; // cannot happen
 675         }
 676         SetPen(cr, 2.0, col, 0);
 677         cairo_rectangle (cr, fac*x, fac*y, squareSize, squareSize);
 678         cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 679         cairo_fill (cr);
 680         cairo_destroy (cr);
 681     }
 682 }
 683
 684 static void
 685 pngDrawPiece (cairo_surface_t *dest, ChessSquare piece, int square_color, int x, int y)
 686 {
 687     int kind;
 688     cairo_t *cr;
 689
 690     if ((int)piece < (int) BlackPawn) {
 691         kind = 0;
 692     } else {
 693         kind = 1;
 694         piece -= BlackPawn;
 695     }
 696     if(appData.upsideDown && flipView) kind = 1 - kind; // swap white and black pieces
 697     BlankSquare(dest, x, y, square_color, piece, 1); // erase previous contents with background
 698     cr = cairo_create (dest);
 699     cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
 700     cairo_paint(cr);
 701     cairo_destroy (cr);
 702 }
 703
 704 static char *markerColor[8] = { "#FFFF00", "#FF0000", "#00FF00", "#0000FF", "#00FFFF", "#FF00FF", "#FFFFFF", "#000000" };
 705
 706 void
 707 DoDrawDot (cairo_surface_t *cs, int marker, int x, int y, int r)
 708 {
 709         cairo_t *cr;
 710
 711         cr = cairo_create(cs);
 712         cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
 713         if(appData.monoMode) {
 714             SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
 715             cairo_stroke_preserve(cr);
 716             SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
 717         } else {
 718             SetPen(cr, 2, markerColor[marker-1], 0);
 719         }
 720         cairo_fill(cr);
 721
 722         cairo_destroy(cr);
 723 }
 724
 725 void
 726 DrawDot (int marker, int x, int y, int r)
 727 { // used for atomic captures; no need to draw on backup
 728   DoDrawDot(csBoardWindow, marker, x, y, r);
 729   GraphExpose(currBoard, x-r, y-r, 2*r, 2*r);
 730 }
 731
 732 static void
 733 DrawText (char *string, int x, int y, int align)
 734 {
 735         int xx = x, yy = y;
 736         cairo_text_extents_t te;
 737         cairo_t *cr;
 738
 739         cr = cairo_create (csBoardWindow);
 740         cairo_select_font_face (cr, "Sans",
 741                     CAIRO_FONT_SLANT_NORMAL,
 742                     CAIRO_FONT_WEIGHT_BOLD);
 743
 744         cairo_set_font_size (cr, align < 0 ? 2*squareSize/3 : squareSize/4);
 745         // calculate where it goes
 746         cairo_text_extents (cr, string, &te);
 747
 748         if (align == 1) {
 749             xx += squareSize - te.width - te.x_bearing - 1;
 750             yy += squareSize - te.height - te.y_bearing - 1;
 751         } else if (align == 2) {
 752             xx += te.x_bearing + 1, yy += -te.y_bearing + 1;
 753         } else if (align == 3) {
 754             xx += squareSize - te.width -te.x_bearing - 1;
 755             yy += -te.y_bearing + 3;
 756         } else if (align == 4) {
 757             xx += te.x_bearing + 1, yy += -te.y_bearing + 3;
 758         } else if (align < 0) {
 759             xx += squareSize/2 - te.width/2, yy += 9*squareSize/16 - te.y_bearing/2;
 760         }
 761
 762         cairo_move_to (cr, xx-1, yy);
 763         if(align == -2) cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); else
 764         if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 765         else          cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
 766         cairo_show_text (cr, string);
 767         cairo_destroy (cr);
 768 }
 769
 770 void
 771 InscribeKanji (ChessSquare piece, int x, int y)
 772 {
 773     char *p, *q, buf[10];
 774     int n;
 775     if(piece == EmptySquare) return;
 776     if(piece >= BlackPawn) piece = BLACK_TO_WHITE piece;
 777     p = appData.inscriptions;
 778     n = piece;
 779     while(piece > WhitePawn) {
 780       if(*p++ == NULLCHAR) {
 781         if(n != WhiteKing) return;
 782         p = q;
 783         break;
 784       }
 785       q = p - 1;
 786       while((*p & 0xC0) == 0x80) p++; // skip UTF-8 continuation bytes
 787       piece--;
 788     }
 789     strncpy(buf, p, 10);
 790     for(q=buf; (*++q & 0xC0) == 0x80;);
 791     *q = NULLCHAR;
 792     DrawText(buf, x, y, n > WhiteLion ? -2 : -1);
 793 }
 794
 795 void
 796 DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, char *tString, char *bString, int align)
 797 {   // basic front-end board-draw function: takes care of everything that can be in square:
 798     // piece, background, coordinate/count, marker dot
 799
 800     if (piece == EmptySquare) {
 801         BlankSquare(csBoardWindow, x, y, square_color, piece, 1);
 802     } else {
 803         pngDrawPiece(csBoardWindow, piece, square_color, x, y);
 804         if(appData.inscriptions[0]) InscribeKanji(piece, x, y);
 805     }
 806
 807     if(align) { // square carries inscription (coord or piece count)
 808         if(align > 1) DrawText(tString, x, y, align);       // top (rank or count)
 809         if(bString && *bString) DrawText(bString, x, y, 1); // bottom (always lower right file ID)
 810     }
 811
 812     if(marker) { // print fat marker dot, if requested
 813         DoDrawDot(csBoardWindow, marker, x + squareSize/4, y+squareSize/4, squareSize/2);
 814     }
 815 }
 816
 817 /****   Animation code by Hugh Fisher, DCS, ANU. ****/
 818
 819 /*      Masks for XPM pieces. Black and white pieces can have
 820         different shapes, but in the interest of retaining my
 821         sanity pieces must have the same outline on both light
 822         and dark squares, and all pieces must use the same
 823         background square colors/images.                */
 824
 825 static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
 826
 827 static void
 828 InitAnimState (AnimNr anr)
 829 {
 830     if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
 831     if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
 832     c_animBufs[anr+4] = csBoardWindow;
 833     c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 834     c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 835 }
 836
 837 void
 838 CreateAnimVars ()
 839 {
 840   InitAnimState(Game);
 841   InitAnimState(Player);
 842 }
 843
 844 static void
 845 CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
 846 {
 847   static cairo_t *pieceSource;
 848   pieceSource = cairo_create (dest);
 849   cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
 850   if(doubleClick) cairo_paint_with_alpha (pieceSource, 0.6);
 851   else cairo_paint(pieceSource);
 852   cairo_destroy (pieceSource);
 853 }
 854
 855 void
 856 InsertPiece (AnimNr anr, ChessSquare piece)
 857 {
 858     CairoOverlayPiece(piece, c_animBufs[anr]);
 859 }
 860
 861 void
 862 DrawBlank (AnimNr anr, int x, int y, int startColor)
 863 {
 864     BlankSquare(c_animBufs[anr+2], x, y, startColor, EmptySquare, 0);
 865 }
 866
 867 void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
 868                  int srcX, int srcY, int width, int height, int destX, int destY)
 869 {
 870         cairo_t *cr;
 871         c_animBufs[anr+4] = csBoardWindow;
 872         cr = cairo_create (c_animBufs[anr+destBuf]);
 873         cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
 874         cairo_rectangle (cr, destX, destY, width, height);
 875         cairo_fill (cr);
 876         cairo_destroy (cr);
 877         if(c_animBufs[anr+destBuf] == csBoardWindow) // suspect that GTK needs this!
 878             GraphExpose(currBoard, destX, destY, width, height);
 879 }
 880
 881 void
 882 SetDragPiece (AnimNr anr, ChessSquare piece)
 883 {
 884 }
 885
 886 /* [AS] Arrow highlighting support */
 887
 888 void
 889 DoDrawPolygon (cairo_surface_t *cs, Pnt arrow[], int nr)
 890 {
 891     cairo_t *cr;
 892     int i;
 893     cr = cairo_create (cs);
 894     cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
 895     for (i=0;i<nr;i++) {
 896         cairo_line_to(cr, arrow[i].x, arrow[i].y);
 897     }
 898     if(appData.monoMode) { // should we always outline arrow?
 899         cairo_line_to(cr, arrow[0].x, arrow[0].y);
 900         SetPen(cr, 2, "#000000", 0);
 901         cairo_stroke_preserve(cr);
 902     }
 903     SetPen(cr, 2, appData.highlightSquareColor, 0);
 904     cairo_fill(cr);
 905
 906     /* free memory */
 907     cairo_destroy (cr);
 908 }
 909
 910 void
 911 DrawPolygon (Pnt arrow[], int nr)
 912 {
 913     DoDrawPolygon(csBoardWindow, arrow, nr);
 914 //    if(!dual) DoDrawPolygon(csBoardBackup, arrow, nr);
 915 }
 916
 917 //-------------------- Eval Graph drawing routines (formerly in xevalgraph.h) --------------------
 918
 919 static void
 920 ChoosePen(cairo_t *cr, int i)
 921 {
 922   switch(i) {
 923     case PEN_BLACK:
 924       SetPen(cr, 1.0, "#000000", 0);
 925       break;
 926     case PEN_DOTTED:
 927       SetPen(cr, 1.0, "#A0A0A0", 1);
 928       break;
 929     case PEN_BLUEDOTTED:
 930       SetPen(cr, 1.0, "#0000FF", 1);
 931       break;
 932     case PEN_BOLDWHITE:
 933       SetPen(cr, 3.0, crWhite, 0);
 934       break;
 935     case PEN_BOLDBLACK:
 936       SetPen(cr, 3.0, crBlack, 0);
 937       break;
 938     case PEN_BACKGD:
 939       SetPen(cr, 3.0, "#E0E0F0", 0);
 940       break;
 941   }
 942 }
 943
 944 // [HGM] front-end, added as wrapper to avoid use of LineTo and MoveToEx in other routines (so they can be back-end)
 945 void
 946 DrawSegment (int x, int y, int *lastX, int *lastY, int penType)
 947 {
 948   static int curX, curY;
 949
 950   if(penType != PEN_NONE) {
 951     cairo_t *cr = cairo_create(DRAWABLE(disp));
 952     cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 953     cairo_move_to (cr, curX, curY);
 954     cairo_line_to (cr, x,y);
 955     ChoosePen(cr, penType);
 956     cairo_stroke (cr);
 957     cairo_destroy (cr);
 958   }
 959
 960   if(lastX != NULL) { *lastX = curX; *lastY = curY; }
 961   curX = x; curY = y;
 962 }
 963
 964 // front-end wrapper for drawing functions to do rectangles
 965 void
 966 DrawRectangle (int left, int top, int right, int bottom, int side, int style)
 967 {
 968   cairo_t *cr;
 969
 970   cr = cairo_create (DRAWABLE(disp));
 971   cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 972   cairo_rectangle (cr, left, top, right-left, bottom-top);
 973   switch(side)
 974     {
 975     case 0: ChoosePen(cr, PEN_BOLDWHITE); break;
 976     case 1: ChoosePen(cr, PEN_BOLDBLACK); break;
 977     case 2: ChoosePen(cr, PEN_BACKGD); break;
 978     }
 979   cairo_fill (cr);
 980
 981   if(style != FILLED)
 982     {
 983       cairo_rectangle (cr, left, top, right-left-1, bottom-top-1);
 984       ChoosePen(cr, PEN_BLACK);
 985       cairo_stroke (cr);
 986     }
 987
 988   cairo_destroy(cr);
 989 }
 990
 991 // front-end wrapper for putting text in graph
 992 void
 993 DrawEvalText (char *buf, int cbBuf, int y)
 994 {
 995     // the magic constants 8 and 5 should really be derived from the font size somehow
 996   cairo_text_extents_t extents;
 997   cairo_t *cr = cairo_create(DRAWABLE(disp));
 998
 999   /* GTK-TODO this has to go into the font-selection */
1000   cairo_select_font_face (cr, "Sans",
1001                           CAIRO_FONT_SLANT_NORMAL,
1002                           CAIRO_FONT_WEIGHT_NORMAL);
1003   cairo_set_font_size (cr, 12.0);
1004
1005
1006   cairo_text_extents (cr, buf, &extents);
1007
1008   cairo_move_to (cr, MarginX - 2 - 8*cbBuf, y+5);
1009   cairo_text_path (cr, buf);
1010   cairo_set_source_rgb (cr, 0.0, 0.0, 0);
1011   cairo_fill_preserve (cr);
1012   cairo_set_source_rgb (cr, 0, 1.0, 0);
1013   cairo_set_line_width (cr, 0.1);
1014   cairo_stroke (cr);
1015
1016   /* free memory */
1017   cairo_destroy (cr);
1018 }