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     textureW[kind] = 0; // prevents bitmap from being used if not succesfully loaded
 245     if(strstr(s, ".png")) {
 246         cairo_surface_t *img = cairo_image_surface_create_from_png (s);
 247         if(img) {
 248             char c, *p = s, *q;
 249             int r, f;
 250             if(pngOriginalBoardBitmap[kind]) cairo_surface_destroy(pngOriginalBoardBitmap[kind]);
 251             if(n[kind] != 1.) cairo_surface_destroy(pngBoardBitmap[kind]);
 252             useTexture |= kind + 1; pngOriginalBoardBitmap[kind] = img;
 253             w = textureW[kind] = cairo_image_surface_get_width (img);
 254             h = textureH[kind] = cairo_image_surface_get_height (img);
 255             n[kind] = 1.;
 256             while((q = strchr(p+1, '-'))) p = q; // find last '-'
 257             if(strlen(p) < 11 && sscanf(p, "-%dx%d.pn%c", &f, &r, &c) == 3 && c == 'g') {
 258                 if(f == 0 || r == 0) f = BOARD_WIDTH, r = BOARD_HEIGHT; // 0x0 means 'fits any', so make it fit
 259                 textureW[kind] = (w*BOARD_WIDTH)/f; // sync cutting locations with square pattern
 260                 textureH[kind] = (h*BOARD_HEIGHT)/r;
 261                 n[kind] = r*squareSize/h; // scale to make it fit exactly vertically
 262             } else
 263             if((p = strstr(s, "xq")) && (p == s || p[-1] == '/')) { // assume full-board image for Xiangqi
 264                 while(0.8*squareSize*BOARD_WIDTH > n[kind]*w || 0.8*squareSize*BOARD_HEIGHT > n[kind]*h) n[kind]++;
 265             } else {
 266                 while(squareSize > n[kind]*w || squareSize > n[kind]*h) n[kind]++;
 267             }
 268             if(n[kind] == 1.) pngBoardBitmap[kind] = img; else {
 269                 // create scaled-up copy of the raw png image when it was too small
 270                 cairo_surface_t *cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, n[kind]*w, n[kind]*h);
 271                 cairo_t *cr = cairo_create(cs);
 272                 pngBoardBitmap[kind] = cs; textureW[kind] *= n[kind]; textureH[kind] *= n[kind];
 273 //              cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 274                 cairo_scale(cr, n[kind], n[kind]);
 275                 cairo_set_source_surface (cr, img, 0, 0);
 276                 cairo_paint (cr);
 277                 cairo_destroy (cr);
 278             }
 279         }
 280     }
 281 }
 282
 283 char *pngPieceNames[] = // must be in same order as internal piece encoding
 284 { "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner",
 285   "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "Lion",
 286   "GoldPawn", "HSword", "PromoHorse", "PromoDragon", "Leopard", "PromoSword", "Prince", "Phoenix", "Kylin", "PromoRook", "PromoHSword",
 287   "Dolphin", "Chancellor", "Unicorn", "Hawk", "Sword", "Crown", "HCrown", "Knight", "Elephant", "PromoBishop", "King",
 288   "Claw", "GoldKnight", "GoldLance", "GoldSilver", NULL
 289 };
 290
 291 char *backupPiece[] = { "Princess", NULL, NULL, NULL, NULL, NULL, NULL,
 292                         NULL, NULL, NULL, NULL, NULL, NULL, "King", "Queen", "Lion" }; // pieces that map on other when not kanji
 293
 294 RsvgHandle *
 295 LoadSVG (char *dir, int color, int piece, int retry)
 296 {
 297     char buf[MSG_SIZ];
 298   RsvgHandle *svg=svgPieces[color][piece];
 299   RsvgDimensionData svg_dimensions;
 300   GError *svgerror=NULL;
 301   cairo_surface_t *img;
 302   cairo_t *cr;
 303   char *name = (retry ? backupPiece[piece - WhiteGrasshopper] : pngPieceNames[piece]);
 304
 305     if(!name) return NULL;
 306
 307     snprintf(buf, MSG_SIZ, "%s/%s%s.svg", dir, color ? "Black" : "White", name);
 308
 309     if(svg || *dir && (svg = rsvg_handle_new_from_file(buf, &svgerror))) {
 310
 311       rsvg_handle_get_dimensions(svg, &svg_dimensions);
 312       img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, squareSize,  squareSize);
 313
 314       cr = cairo_create(img);
 315       cairo_scale(cr, squareSize/(double) svg_dimensions.width, squareSize/(double) svg_dimensions.height);
 316       rsvg_handle_render_cairo(svg, cr);
 317       if(cairo_surface_status(img) == CAIRO_STATUS_SUCCESS) {
 318         if(pngPieceImages[color][piece]) cairo_surface_destroy(pngPieceImages[color][piece]);
 319         pngPieceImages[color][piece] = img;
 320       }
 321       cairo_destroy(cr);
 322
 323       return svg;
 324     }
 325     if(!retry && piece >= WhiteGrasshopper && piece <= WhiteNothing) // pieces that are only different in kanji sets
 326         return LoadSVG(dir, color, piece, 1);
 327     if(svgerror)
 328         g_error_free(svgerror);
 329     return NULL;
 330 }
 331
 332 static void
 333 ScaleOnePiece (int color, int piece)
 334 {
 335   float w, h;
 336   char buf[MSG_SIZ];
 337   cairo_surface_t *img, *cs;
 338   cairo_t *cr;
 339
 340   g_type_init ();
 341
 342   svgPieces[color][piece] = LoadSVG("", color, piece, 0); // this fills pngPieceImages if we had cached svg with bitmap of wanted size
 343
 344   if(!pngPieceImages[color][piece]) { // we don't have cached bitmap (implying we did not have cached svg)
 345     if(*appData.pieceDirectory) { // user specified piece directory
 346       snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pieceDirectory, color ? "Black" : "White", pngPieceNames[piece]);
 347       img = cairo_image_surface_create_from_png (buf); // try if there are png pieces there
 348       if(cairo_surface_status(img) != CAIRO_STATUS_SUCCESS) { // there were not
 349         svgPieces[color][piece] = LoadSVG(appData.pieceDirectory, color, piece, 0); // so try if he has svg there
 350       } else pngPieceImages[color][piece] = img;
 351     }
 352   }
 353
 354   if(!pngPieceImages[color][piece]) { // we still did not manage to acquire a piece bitmap
 355     static int warned = 0;
 356     if(!(svgPieces[color][piece] = LoadSVG(svgDir, color, piece, 0)) && !warned) { // try to fall back on installed svg
 357       char *msg = _("No default pieces installed!\nSelect your own using '-pieceImageDirectory'.");
 358       printf("%s\n", msg); // give up
 359       DisplayError(msg, 0);
 360       warned = 1; // prevent error message being repeated for each piece type
 361     }
 362   }
 363
 364   img = pngPieceImages[color][piece];
 365
 366   // create new bitmap to hold scaled piece image (and remove any old)
 367   if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
 368   pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 369
 370   if(!img) return;
 371
 372   // scaled copying of the raw png image
 373   cr = cairo_create(cs);
 374   w = cairo_image_surface_get_width (img);
 375   h = cairo_image_surface_get_height (img);
 376   cairo_scale(cr, squareSize/w, squareSize/h);
 377   cairo_set_source_surface (cr, img, 0, 0);
 378   cairo_paint (cr);
 379   cairo_destroy (cr);
 380
 381   if(!appData.trueColors || !*appData.pieceDirectory) { // operate on bitmap to color it (king-size hack...)
 382     int stride = cairo_image_surface_get_stride(cs)/4;
 383     int *buf = (int *) cairo_image_surface_get_data(cs);
 384     int i, j, p;
 385     sscanf(color ? appData.blackPieceColor+1 : appData.whitePieceColor+1, "%x", &p); // replacement color
 386     cairo_surface_flush(cs);
 387     for(i=0; i<squareSize; i++) for(j=0; j<squareSize; j++) {
 388         int r, a;
 389         float f;
 390         unsigned int c = buf[i*stride + j];
 391         a = c >> 24; r = c >> 16 & 255;     // alpha and red, where red is the 'white' weight, since white is #FFFFCC in the source images
 392         f = (color ? a - r : r)/255.;       // fraction of black or white in the mix that has to be replaced
 393         buf[i*stride + j] = c & 0xFF000000; // alpha channel is kept at same opacity
 394         buf[i*stride + j] += ((int)(f*(p&0xFF0000)) & 0xFF0000) + ((int)(f*(p&0xFF00)) & 0xFF00) + (int)(f*(p&0xFF)); // add desired fraction of new color
 395         if(color) buf[i*stride + j] += r | r << 8 | r << 16; // details on black pieces get their weight added in pure white
 396         if(appData.monoMode) {
 397             if(a < 64) buf[i*stride + j] = 0; // if not opaque enough, totally transparent
 398             else if(2*r < a) buf[i*stride + j] = 0xFF000000; // if not light enough, totally black
 399             else buf[i*stride + j] = 0xFFFFFFFF; // otherwise white
 400         }
 401     }
 402     cairo_surface_mark_dirty(cs);
 403   }
 404 }
 405
 406 void
 407 CreatePNGPieces ()
 408 {
 409   int p;
 410
 411   for(p=0; pngPieceNames[p]; p++) {
 412     ScaleOnePiece(0, p);
 413     ScaleOnePiece(1, p);
 414   }
 415   SelectPieces(gameInfo.variant);
 416 }
 417
 418 void
 419 CreateAnyPieces (int p)
 420 {   // [HGM] taken out of main
 421     if(p) CreatePNGPieces();
 422     CreatePNGBoard(appData.liteBackTextureFile, 1);
 423     CreatePNGBoard(appData.darkBackTextureFile, 0);
 424 }
 425
 426 void
 427 InitDrawingParams (int reloadPieces)
 428 {
 429     int i, p;
 430     if(reloadPieces)
 431     for(i=0; i<2; i++) for(p=0; p<BlackPawn+4; p++) {
 432         if(pngPieceImages[i][p]) cairo_surface_destroy(pngPieceImages[i][p]);
 433         pngPieceImages[i][p] = NULL;
 434         if(svgPieces[i][p]) rsvg_handle_close(svgPieces[i][p], NULL);
 435         svgPieces[i][p] = NULL;
 436     }
 437     CreateAnyPieces(1);
 438 }
 439
 440 // [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
 441
 442 float
 443 Color (char *col, int n)
 444 {
 445   int c;
 446   sscanf(col, "#%x", &c);
 447   c = c >> 4*n & 255;
 448   return c/255.;
 449 }
 450
 451 void
 452 SetPen (cairo_t *cr, float w, char *col, int dash)
 453 {
 454   static const double dotted[] = {4.0, 4.0};
 455   static int len  = sizeof(dotted) / sizeof(dotted[0]);
 456   cairo_set_line_width (cr, w);
 457   cairo_set_source_rgba (cr, Color(col, 4), Color(col, 2), Color(col, 0), 1.0);
 458   if(dash) cairo_set_dash (cr, dotted, len, 0.0);
 459 }
 460
 461 void DrawSeekAxis( int x, int y, int xTo, int yTo )
 462 {
 463     cairo_t *cr;
 464
 465     /* get a cairo_t */
 466     cr = cairo_create (csBoardWindow);
 467
 468     cairo_move_to (cr, x, y);
 469     cairo_line_to(cr, xTo, yTo );
 470
 471     SetPen(cr, 2, "#000000", 0);
 472     cairo_stroke(cr);
 473
 474     /* free memory */
 475     cairo_destroy (cr);
 476     GraphExpose(currBoard, x-1, yTo-1, xTo-x+2, y-yTo+2);
 477 }
 478
 479 void DrawSeekBackground( int left, int top, int right, int bottom )
 480 {
 481     cairo_t *cr = cairo_create (csBoardWindow);
 482
 483     cairo_rectangle (cr, left, top, right-left, bottom-top);
 484
 485     cairo_set_source_rgba(cr, 0.8, 0.8, 0.4,1.0);
 486     cairo_fill(cr);
 487
 488     /* free memory */
 489     cairo_destroy (cr);
 490     GraphExpose(currBoard, left, top, right-left, bottom-top);
 491 }
 492
 493 void DrawSeekText(char *buf, int x, int y)
 494 {
 495     cairo_t *cr = cairo_create (csBoardWindow);
 496
 497     cairo_select_font_face (cr, "Sans",
 498                             CAIRO_FONT_SLANT_NORMAL,
 499                             CAIRO_FONT_WEIGHT_NORMAL);
 500
 501     cairo_set_font_size (cr, 12.0);
 502
 503     cairo_move_to (cr, x, y+4);
 504     cairo_set_source_rgba(cr, 0, 0, 0,1.0);
 505     cairo_show_text( cr, buf);
 506
 507     /* free memory */
 508     cairo_destroy (cr);
 509     GraphExpose(currBoard, x-5, y-10, 60, 15);
 510 }
 511
 512 void DrawSeekDot(int x, int y, int colorNr)
 513 {
 514     cairo_t *cr = cairo_create (csBoardWindow);
 515     int square = colorNr & 0x80;
 516     colorNr &= 0x7F;
 517
 518     if(square)
 519         cairo_rectangle (cr, x-squareSize/9, y-squareSize/9, 2*(squareSize/9), 2*(squareSize/9));
 520     else
 521         cairo_arc(cr, x, y, squareSize/9, 0.0, 2*M_PI);
 522
 523     SetPen(cr, 2, "#000000", 0);
 524     cairo_stroke_preserve(cr);
 525     switch (colorNr) {
 526       case 0: cairo_set_source_rgba(cr, 1.0, 0, 0,1.0); break;
 527       case 1: cairo_set_source_rgba (cr, 0.0, 0.7, 0.2, 1.0); break;
 528       default: cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 1.0); break;
 529     }
 530     cairo_fill(cr);
 531
 532     /* free memory */
 533     cairo_destroy (cr);
 534     GraphExpose(currBoard, x-squareSize/8, y-squareSize/8, 2*(squareSize/8), 2*(squareSize/8));
 535 }
 536
 537 void
 538 InitDrawingHandle (Option *opt)
 539 {
 540     csBoardWindow = DRAWABLE(opt);
 541 }
 542
 543 void
 544 CreateGrid ()
 545 {
 546     int i, j;
 547
 548     if (lineGap == 0) return;
 549
 550     /* [HR] Split this into 2 loops for non-square boards. */
 551
 552     for (i = 0; i < BOARD_HEIGHT + 1; i++) {
 553         gridSegments[i].x1 = 0;
 554         gridSegments[i].x2 =
 555           lineGap + BOARD_WIDTH * (squareSize + lineGap);
 556         gridSegments[i].y1 = gridSegments[i].y2
 557           = lineGap / 2 + (i * (squareSize + lineGap));
 558     }
 559
 560     for (j = 0; j < BOARD_WIDTH + 1; j++) {
 561         gridSegments[j + i].y1 = 0;
 562         gridSegments[j + i].y2 =
 563           lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 564         gridSegments[j + i].x1 = gridSegments[j + i].x2
 565           = lineGap / 2 + (j * (squareSize + lineGap));
 566     }
 567 }
 568
 569 void
 570 DrawGrid()
 571 {
 572   /* draws a grid starting around Nx, Ny squares starting at x,y */
 573   int i;
 574   float odd = (lineGap & 1)/2.;
 575   cairo_t *cr;
 576
 577   /* get a cairo_t */
 578   cr = cairo_create (csBoardWindow);
 579
 580   cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 581   SetPen(cr, lineGap, "#000000", 0);
 582
 583   /* lines in X */
 584   for (i = 0; i < BOARD_WIDTH + BOARD_HEIGHT + 2; i++)
 585     {
 586       int h = (gridSegments[i].y1 == gridSegments[i].y2); // horizontal
 587       cairo_move_to (cr, gridSegments[i].x1 + !h*odd, gridSegments[i].y1 + h*odd);
 588       cairo_line_to (cr, gridSegments[i].x2 + !h*odd, gridSegments[i].y2 + h*odd);
 589       cairo_stroke (cr);
 590     }
 591
 592   /* free memory */
 593   cairo_destroy (cr);
 594
 595   return;
 596 }
 597
 598 void
 599 DrawBorder (int x, int y, int type, int odd)
 600 {
 601     cairo_t *cr;
 602     char *col;
 603
 604     switch(type) {
 605         case 0: col = "#000000"; break;
 606         case 1: col = appData.highlightSquareColor; break;
 607         case 2: col = appData.premoveHighlightColor; break;
 608         default: col = "#808080"; break; // cannot happen
 609     }
 610     cr = cairo_create(csBoardWindow);
 611     cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 612     cairo_rectangle(cr, x+odd/2., y+odd/2., squareSize+lineGap, squareSize+lineGap);
 613     SetPen(cr, lineGap, col, 0);
 614     cairo_stroke(cr);
 615     cairo_destroy(cr);
 616     GraphExpose(currBoard, x - lineGap/2, y - lineGap/2, squareSize+2*lineGap+odd, squareSize+2*lineGap+odd);
 617 }
 618
 619 static int
 620 CutOutSquare (int x, int y, int *x0, int *y0, int  kind)
 621 {
 622     int W = BOARD_WIDTH, H = BOARD_HEIGHT;
 623     int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
 624     *x0 = 0; *y0 = 0;
 625     if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
 626     if(textureW[kind] < W*squareSize)
 627         *x0 = (textureW[kind] - squareSize) * nx/(W-1);
 628     else
 629         *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
 630     if(textureH[kind] < H*squareSize)
 631         *y0 = (textureH[kind] - squareSize) * ny/(H-1);
 632     else
 633         *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
 634     return 1;
 635 }
 636
 637 void
 638 DrawLogo (Option *opt, void *logo)
 639 {
 640     cairo_surface_t *img;
 641     cairo_t *cr;
 642     int w, h;
 643
 644     if(!logo || !opt) return;
 645     img = cairo_image_surface_create_from_png (logo);
 646     w = cairo_image_surface_get_width (img);
 647     h = cairo_image_surface_get_height (img);
 648     cr = cairo_create(DRAWABLE(opt));
 649 //    cairo_scale(cr, (float)appData.logoSize/w, appData.logoSize/(2.*h));
 650     cairo_scale(cr, (float)opt->max/w, (float)opt->value/h);
 651     cairo_set_source_surface (cr, img, 0, 0);
 652     cairo_paint (cr);
 653     cairo_destroy (cr);
 654     cairo_surface_destroy (img);
 655     GraphExpose(opt, 0, 0, appData.logoSize, appData.logoSize/2);
 656 }
 657
 658 static void
 659 BlankSquare (cairo_surface_t *dest, int x, int y, int color, ChessSquare piece, int fac)
 660 {   // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
 661     int x0, y0;
 662     cairo_t *cr;
 663
 664     cr = cairo_create (dest);
 665
 666     if ((useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
 667             cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
 668             cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 669             cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
 670             cairo_fill (cr);
 671             cairo_destroy (cr);
 672     } else { // evenly colored squares
 673         char *col = NULL;
 674         switch (color) {
 675           case 0: col = appData.darkSquareColor; break;
 676           case 1: col = appData.lightSquareColor; break;
 677           case 2: col = "#000000"; break;
 678           default: col = "#808080"; break; // cannot happen
 679         }
 680         SetPen(cr, 2.0, col, 0);
 681         cairo_rectangle (cr, fac*x, fac*y, squareSize, squareSize);
 682         cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 683         cairo_fill (cr);
 684         cairo_destroy (cr);
 685     }
 686 }
 687
 688 static void
 689 pngDrawPiece (cairo_surface_t *dest, ChessSquare piece, int square_color, int x, int y)
 690 {
 691     int kind;
 692     cairo_t *cr;
 693
 694     if ((int)piece < (int) BlackPawn) {
 695         kind = 0;
 696     } else {
 697         kind = 1;
 698         piece -= BlackPawn;
 699     }
 700     if(appData.upsideDown && flipView) kind = 1 - kind; // swap white and black pieces
 701     BlankSquare(dest, x, y, square_color, piece, 1); // erase previous contents with background
 702     cr = cairo_create (dest);
 703     cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
 704     cairo_paint(cr);
 705     cairo_destroy (cr);
 706 }
 707
 708 static char *markerColor[8] = { "#FFFF00", "#FF0000", "#00FF00", "#0000FF", "#00FFFF", "#FF00FF", "#FFFFFF", "#000000" };
 709
 710 void
 711 DoDrawDot (cairo_surface_t *cs, int marker, int x, int y, int r)
 712 {
 713         cairo_t *cr;
 714
 715         cr = cairo_create(cs);
 716         cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
 717         if(appData.monoMode) {
 718             SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
 719             cairo_stroke_preserve(cr);
 720             SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
 721         } else {
 722             SetPen(cr, 2, markerColor[marker-1], 0);
 723         }
 724         cairo_fill(cr);
 725
 726         cairo_destroy(cr);
 727 }
 728
 729 void
 730 DrawDot (int marker, int x, int y, int r)
 731 { // used for atomic captures; no need to draw on backup
 732   DoDrawDot(csBoardWindow, marker, x, y, r);
 733   GraphExpose(currBoard, x-r, y-r, 2*r, 2*r);
 734 }
 735
 736 static void
 737 DrawText (char *string, int x, int y, int align)
 738 {
 739         int xx = x, yy = y;
 740         cairo_text_extents_t te;
 741         cairo_t *cr;
 742
 743         cr = cairo_create (csBoardWindow);
 744         cairo_select_font_face (cr, "Sans",
 745                     CAIRO_FONT_SLANT_NORMAL,
 746                     CAIRO_FONT_WEIGHT_BOLD);
 747
 748         cairo_set_font_size (cr, align < 0 ? 2*squareSize/3 : squareSize/4);
 749         // calculate where it goes
 750         cairo_text_extents (cr, string, &te);
 751
 752         if (align == 1) {
 753             xx += squareSize - te.width - te.x_bearing - 1;
 754             yy += squareSize - te.height - te.y_bearing - 1;
 755         } else if (align == 2) {
 756             xx += te.x_bearing + 1, yy += -te.y_bearing + 1;
 757         } else if (align == 3) {
 758             xx += squareSize - te.width -te.x_bearing - 1;
 759             yy += -te.y_bearing + 3;
 760         } else if (align == 4) {
 761             xx += te.x_bearing + 1, yy += -te.y_bearing + 3;
 762         } else if (align < 0) {
 763             xx += squareSize/2 - te.width/2, yy += 9*squareSize/16 - te.y_bearing/2;
 764         }
 765
 766         cairo_move_to (cr, xx-1, yy);
 767         if(align == -2) cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); else
 768         if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 769         else          cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
 770         cairo_show_text (cr, string);
 771         cairo_destroy (cr);
 772 }
 773
 774 void
 775 InscribeKanji (ChessSquare piece, int x, int y)
 776 {
 777     char *p, *q, buf[10];
 778     int n;
 779     if(piece == EmptySquare) return;
 780     if(piece >= BlackPawn) piece = BLACK_TO_WHITE piece;
 781     p = appData.inscriptions;
 782     n = piece;
 783     while(piece > WhitePawn) {
 784       if(*p++ == NULLCHAR) {
 785         if(n != WhiteKing) return;
 786         p = q;
 787         break;
 788       }
 789       q = p - 1;
 790       while((*p & 0xC0) == 0x80) p++; // skip UTF-8 continuation bytes
 791       piece--;
 792     }
 793     strncpy(buf, p, 10);
 794     for(q=buf; (*++q & 0xC0) == 0x80;);
 795     *q = NULLCHAR;
 796     DrawText(buf, x, y, n > WhiteLion ? -2 : -1);
 797 }
 798
 799 void
 800 DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, char *tString, char *bString, int align)
 801 {   // basic front-end board-draw function: takes care of everything that can be in square:
 802     // piece, background, coordinate/count, marker dot
 803
 804     if (piece == EmptySquare) {
 805         BlankSquare(csBoardWindow, x, y, square_color, piece, 1);
 806     } else {
 807         pngDrawPiece(csBoardWindow, piece, square_color, x, y);
 808         if(appData.inscriptions[0]) InscribeKanji(piece, x, y);
 809     }
 810
 811     if(align) { // square carries inscription (coord or piece count)
 812         if(align > 1) DrawText(tString, x, y, align);       // top (rank or count)
 813         if(bString && *bString) DrawText(bString, x, y, 1); // bottom (always lower right file ID)
 814     }
 815
 816     if(marker) { // print fat marker dot, if requested
 817         DoDrawDot(csBoardWindow, marker, x + squareSize/4, y+squareSize/4, squareSize/2);
 818     }
 819 }
 820
 821 /****   Animation code by Hugh Fisher, DCS, ANU. ****/
 822
 823 /*      Masks for XPM pieces. Black and white pieces can have
 824         different shapes, but in the interest of retaining my
 825         sanity pieces must have the same outline on both light
 826         and dark squares, and all pieces must use the same
 827         background square colors/images.                */
 828
 829 static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
 830
 831 static void
 832 InitAnimState (AnimNr anr)
 833 {
 834     if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
 835     if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
 836     c_animBufs[anr+4] = csBoardWindow;
 837     c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 838     c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 839 }
 840
 841 void
 842 CreateAnimVars ()
 843 {
 844   InitAnimState(Game);
 845   InitAnimState(Player);
 846 }
 847
 848 static void
 849 CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
 850 {
 851   static cairo_t *pieceSource;
 852   pieceSource = cairo_create (dest);
 853   cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
 854   if(doubleClick) cairo_paint_with_alpha (pieceSource, 0.6);
 855   else cairo_paint(pieceSource);
 856   cairo_destroy (pieceSource);
 857 }
 858
 859 void
 860 InsertPiece (AnimNr anr, ChessSquare piece)
 861 {
 862     CairoOverlayPiece(piece, c_animBufs[anr]);
 863 }
 864
 865 void
 866 DrawBlank (AnimNr anr, int x, int y, int startColor)
 867 {
 868     BlankSquare(c_animBufs[anr+2], x, y, startColor, EmptySquare, 0);
 869 }
 870
 871 void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
 872                  int srcX, int srcY, int width, int height, int destX, int destY)
 873 {
 874         cairo_t *cr;
 875         c_animBufs[anr+4] = csBoardWindow;
 876         cr = cairo_create (c_animBufs[anr+destBuf]);
 877         cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
 878         cairo_rectangle (cr, destX, destY, width, height);
 879         cairo_fill (cr);
 880         cairo_destroy (cr);
 881         if(c_animBufs[anr+destBuf] == csBoardWindow) // suspect that GTK needs this!
 882             GraphExpose(currBoard, destX, destY, width, height);
 883 }
 884
 885 void
 886 SetDragPiece (AnimNr anr, ChessSquare piece)
 887 {
 888 }
 889
 890 /* [AS] Arrow highlighting support */
 891
 892 void
 893 DoDrawPolygon (cairo_surface_t *cs, Pnt arrow[], int nr)
 894 {
 895     cairo_t *cr;
 896     int i;
 897     cr = cairo_create (cs);
 898     cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
 899     for (i=0;i<nr;i++) {
 900         cairo_line_to(cr, arrow[i].x, arrow[i].y);
 901     }
 902     if(appData.monoMode) { // should we always outline arrow?
 903         cairo_line_to(cr, arrow[0].x, arrow[0].y);
 904         SetPen(cr, 2, "#000000", 0);
 905         cairo_stroke_preserve(cr);
 906     }
 907     SetPen(cr, 2, appData.highlightSquareColor, 0);
 908     cairo_fill(cr);
 909
 910     /* free memory */
 911     cairo_destroy (cr);
 912 }
 913
 914 void
 915 DrawPolygon (Pnt arrow[], int nr)
 916 {
 917     DoDrawPolygon(csBoardWindow, arrow, nr);
 918 //    if(!dual) DoDrawPolygon(csBoardBackup, arrow, nr);
 919 }
 920
 921 //-------------------- Eval Graph drawing routines (formerly in xevalgraph.h) --------------------
 922
 923 static void
 924 ChoosePen(cairo_t *cr, int i)
 925 {
 926   switch(i) {
 927     case PEN_BLACK:
 928       SetPen(cr, 1.0, "#000000", 0);
 929       break;
 930     case PEN_DOTTED:
 931       SetPen(cr, 1.0, "#A0A0A0", 1);
 932       break;
 933     case PEN_BLUEDOTTED:
 934       SetPen(cr, 1.0, "#0000FF", 1);
 935       break;
 936     case PEN_BOLDWHITE:
 937       SetPen(cr, 3.0, crWhite, 0);
 938       break;
 939     case PEN_BOLDBLACK:
 940       SetPen(cr, 3.0, crBlack, 0);
 941       break;
 942     case PEN_BACKGD:
 943       SetPen(cr, 3.0, "#E0E0F0", 0);
 944       break;
 945   }
 946 }
 947
 948 // [HGM] front-end, added as wrapper to avoid use of LineTo and MoveToEx in other routines (so they can be back-end)
 949 void
 950 DrawSegment (int x, int y, int *lastX, int *lastY, int penType)
 951 {
 952   static int curX, curY;
 953
 954   if(penType != PEN_NONE) {
 955     cairo_t *cr = cairo_create(DRAWABLE(disp));
 956     cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 957     cairo_move_to (cr, curX, curY);
 958     cairo_line_to (cr, x,y);
 959     ChoosePen(cr, penType);
 960     cairo_stroke (cr);
 961     cairo_destroy (cr);
 962   }
 963
 964   if(lastX != NULL) { *lastX = curX; *lastY = curY; }
 965   curX = x; curY = y;
 966 }
 967
 968 // front-end wrapper for drawing functions to do rectangles
 969 void
 970 DrawRectangle (int left, int top, int right, int bottom, int side, int style)
 971 {
 972   cairo_t *cr;
 973
 974   cr = cairo_create (DRAWABLE(disp));
 975   cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 976   cairo_rectangle (cr, left, top, right-left, bottom-top);
 977   switch(side)
 978     {
 979     case 0: ChoosePen(cr, PEN_BOLDWHITE); break;
 980     case 1: ChoosePen(cr, PEN_BOLDBLACK); break;
 981     case 2: ChoosePen(cr, PEN_BACKGD); break;
 982     }
 983   cairo_fill (cr);
 984
 985   if(style != FILLED)
 986     {
 987       cairo_rectangle (cr, left, top, right-left-1, bottom-top-1);
 988       ChoosePen(cr, PEN_BLACK);
 989       cairo_stroke (cr);
 990     }
 991
 992   cairo_destroy(cr);
 993 }
 994
 995 // front-end wrapper for putting text in graph
 996 void
 997 DrawEvalText (char *buf, int cbBuf, int y)
 998 {
 999     // the magic constants 8 and 5 should really be derived from the font size somehow
1000   cairo_text_extents_t extents;
1001   cairo_t *cr = cairo_create(DRAWABLE(disp));
1002
1003   /* GTK-TODO this has to go into the font-selection */
1004   cairo_select_font_face (cr, "Sans",
1005                           CAIRO_FONT_SLANT_NORMAL,
1006                           CAIRO_FONT_WEIGHT_NORMAL);
1007   cairo_set_font_size (cr, 12.0);
1008
1009
1010   cairo_text_extents (cr, buf, &extents);
1011
1012   cairo_move_to (cr, MarginX - 2 - 8*cbBuf, y+5);
1013   cairo_text_path (cr, buf);
1014   cairo_set_source_rgb (cr, 0.0, 0.0, 0);
1015   cairo_fill_preserve (cr);
1016   cairo_set_source_rgb (cr, 0, 1.0, 0);
1017   cairo_set_line_width (cr, 0.1);
1018   cairo_stroke (cr);
1019
1020   /* free memory */
1021   cairo_destroy (cr);
1022 }