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 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
  59 #if STDC_HEADERS
  60 # include <stdlib.h>
  61 # include <string.h>
  62 #else /* not STDC_HEADERS */
  63 extern char *getenv();
  64 # if HAVE_STRING_H
  65 #  include <string.h>
  66 # else /* not HAVE_STRING_H */
  67 #  include <strings.h>
  68 # endif /* not HAVE_STRING_H */
  69 #endif /* not STDC_HEADERS */
  70
  71 #if ENABLE_NLS
  72 #include <locale.h>
  73 #endif
  74
  75
  76 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
  77 #include "common.h"
  78
  79 #if HAVE_LIBXPM
  80 #include "pixmaps/pixmaps.h"
  81 #else
  82 #include "bitmaps/bitmaps.h"
  83 #endif
  84
  85 #include "frontend.h"
  86 #include "backend.h"
  87 #include "xboard.h"
  88 #include "xevalgraph.h"
  89 #include "board.h"
  90 #include "menus.h"
  91 #include "dialogs.h"
  92 #include "gettext.h"
  93 #include "draw.h"
  94
  95
  96 #ifdef __EMX__
  97 #ifndef HAVE_USLEEP
  98 #define HAVE_USLEEP
  99 #endif
 100 #define usleep(t)   _sleep2(((t)+500)/1000)
 101 #endif
 102
 103 #ifdef ENABLE_NLS
 104 # define  _(s) gettext (s)
 105 # define N_(s) gettext_noop (s)
 106 #else
 107 # define  _(s) (s)
 108 # define N_(s)  s
 109 #endif
 110
 111 #define SOLID 0
 112 #define OUTLINE 1
 113 Boolean cairoAnimate;
 114 static cairo_surface_t *csBoardWindow, *csBoardBackup, *csDualBoard;
 115 static cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn];    // scaled pieces as used
 116 static cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
 117 static cairo_surface_t *pngBoardBitmap[2];
 118 int useTexture, textureW[2], textureH[2];
 119
 120 #define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
 121 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
 122
 123 #define White(piece) ((int)(piece) < (int)BlackPawn)
 124
 125 struct {
 126   int x1, x2, y1, y2;
 127 } gridSegments[BOARD_RANKS + BOARD_FILES + 2];
 128
 129 void
 130 SwitchWindow ()
 131 {
 132     cairo_surface_t *cstmp = csBoardWindow;
 133     csBoardWindow = csDualBoard;
 134     if(!csDualBoard && cstmp) {
 135         int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
 136         int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 137         csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
 138     }
 139 }
 140
 141 void
 142 NewSurfaces ()
 143 {
 144     // delete surfaces after size becomes invalid, so they will be recreated
 145     if(csBoardWindow) cairo_surface_destroy(csBoardWindow);
 146     if(csBoardBackup) cairo_surface_destroy(csBoardBackup);
 147     if(csDualBoard) cairo_surface_destroy(csDualBoard);
 148     csBoardWindow = csBoardBackup = csDualBoard = NULL;
 149 }
 150
 151 #define BoardSize int
 152 void
 153 InitDrawingSizes (BoardSize boardSize, int flags)
 154 {   // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
 155     int boardWidth, boardHeight;
 156     int i;
 157     static Dimension oldWidth, oldHeight;
 158     static VariantClass oldVariant;
 159     static int oldMono = -1, oldTwoBoards = 0;
 160
 161     if(!formWidget) return;
 162
 163     if(oldTwoBoards && !twoBoards) PopDown(DummyDlg);
 164     oldTwoBoards = twoBoards;
 165
 166     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
 167     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
 168     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 169
 170   if(boardWidth != oldWidth || boardHeight != oldHeight) { // do resizing stuff only if size actually changed
 171
 172     oldWidth = boardWidth; oldHeight = boardHeight;
 173     CreateGrid();
 174     NewSurfaces();
 175
 176     /*
 177      * Inhibit shell resizing.
 178      */
 179     ResizeBoardWindow(boardWidth, boardHeight, !cairoAnimate);
 180
 181     DelayedDrag();
 182   }
 183
 184     // [HGM] pieces: tailor piece bitmaps to needs of specific variant
 185     // (only for xpm)
 186
 187   if(gameInfo.variant != oldVariant) { // and only if variant changed
 188
 189     for(i=0; i<2; i++) {
 190         int p;
 191         for(p=0; p<=(int)WhiteKing; p++)
 192            pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
 193         if(gameInfo.variant == VariantShogi) {
 194            pngPieceBitmaps[i][(int)WhiteCannon] = pngPieceBitmaps2[i][(int)WhiteKing+1];
 195            pngPieceBitmaps[i][(int)WhiteNightrider] = pngPieceBitmaps2[i][(int)WhiteKing+2];
 196            pngPieceBitmaps[i][(int)WhiteSilver] = pngPieceBitmaps2[i][(int)WhiteKing+3];
 197            pngPieceBitmaps[i][(int)WhiteGrasshopper] = pngPieceBitmaps2[i][(int)WhiteKing+4];
 198            pngPieceBitmaps[i][(int)WhiteQueen] = pngPieceBitmaps2[i][(int)WhiteLance];
 199         }
 200 #ifdef GOTHIC
 201         if(gameInfo.variant == VariantGothic) {
 202            pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteSilver];
 203         }
 204 #endif
 205         if(gameInfo.variant == VariantSChess) {
 206            pngPieceBitmaps[i][(int)WhiteAngel]    = pngPieceBitmaps2[i][(int)WhiteFalcon];
 207            pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteAlfil];
 208         }
 209     }
 210     oldMono = -10; // kludge to force recreation of animation masks
 211     oldVariant = gameInfo.variant;
 212   }
 213   CreateAnimVars();
 214   oldMono = appData.monoMode;
 215 }
 216
 217 static void
 218 CreatePNGBoard (char *s, int kind)
 219 {
 220     if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
 221     if(strstr(s, ".png")) {
 222         cairo_surface_t *img = cairo_image_surface_create_from_png (s);
 223         if(img) {
 224             useTexture |= kind + 1; pngBoardBitmap[kind] = img;
 225             textureW[kind] = cairo_image_surface_get_width (img);
 226             textureH[kind] = cairo_image_surface_get_height (img);
 227         }
 228     }
 229 }
 230
 231 char *pngPieceNames[] = // must be in same order as internal piece encoding
 232 { "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner",
 233   "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "King",
 234   "GoldKnight", "GoldLance", "GoldPawn", "GoldSilver", NULL
 235 };
 236
 237 static void
 238 ScaleOnePiece (char *name, int color, int piece)
 239 {
 240   int w, h;
 241   char buf[MSG_SIZ];
 242   cairo_surface_t *img, *cs;
 243   cairo_t *cr;
 244   static cairo_surface_t *pngPieceImages[2][(int)BlackPawn+4];   // png 256 x 256 images
 245
 246   if((img = pngPieceImages[color][piece]) == NULL) { // if PNG file for this piece was not yet read, read it now and store it
 247     snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pngDirectory, color ? "Black" : "White", pngPieceNames[piece]);
 248     pngPieceImages[color][piece] = img = cairo_image_surface_create_from_png (buf);
 249     w = cairo_image_surface_get_width (img);
 250     h = cairo_image_surface_get_height (img);
 251     if(w != 64 || h != 64) { printf("Bad png size %dx%d in %s\n", w, h, buf); exit(1); }
 252   }
 253   // create new bitmap to hold scaled piece image (and remove any old)
 254   if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
 255   pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 256   if(piece <= WhiteKing) pngPieceBitmaps[color][piece] = cs;
 257   // scaled copying of the raw png image
 258   cr = cairo_create(cs);
 259   cairo_scale(cr, squareSize/64., squareSize/64.);
 260   cairo_set_source_surface (cr, img, 0, 0);
 261   cairo_paint (cr);
 262   cairo_destroy (cr);
 263 }
 264
 265 void
 266 CreatePNGPieces ()
 267 {
 268   int p;
 269
 270   for(p=0; pngPieceNames[p]; p++) {
 271     ScaleOnePiece(pngPieceNames[p], 0, p);
 272     ScaleOnePiece(pngPieceNames[p], 1, p);
 273   }
 274 }
 275
 276 int
 277 CreateAnyPieces ()
 278 {   // [HGM] taken out of main
 279     if (appData.pngDirectory[0] != NULLCHAR) {
 280       CreatePNGPieces();
 281     }
 282     CreatePNGBoard(appData.liteBackTextureFile, 1);
 283     CreatePNGBoard(appData.darkBackTextureFile, 0);
 284     cairoAnimate = *appData.pngDirectory && useTexture == 3
 285         && strstr(appData.liteBackTextureFile, ".png") && strstr(appData.darkBackTextureFile, ".png");
 286     return cairoAnimate;
 287 }
 288
 289 void
 290 InitDrawingParams ()
 291 {
 292     MakeColors();
 293     CreateAnyPieces();
 294 }
 295
 296 // [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
 297
 298 float
 299 Color (char *col, int n)
 300 {
 301   int c;
 302   sscanf(col, "#%x", &c);
 303   c = c >> 4*n & 255;
 304   return c/255.;
 305 }
 306
 307 void
 308 SetPen (cairo_t *cr, float w, char *col, int dash)
 309 {
 310   static const double dotted[] = {4.0, 4.0};
 311   static int len  = sizeof(dotted) / sizeof(dotted[0]);
 312   cairo_set_line_width (cr, w);
 313   cairo_set_source_rgba (cr, Color(col, 4), Color(col, 2), Color(col, 0), 1.0);
 314   if(dash) cairo_set_dash (cr, dotted, len, 0.0);
 315 }
 316
 317 void DrawSeekAxis( int x, int y, int xTo, int yTo )
 318 {
 319     cairo_t *cr;
 320
 321     /* get a cairo_t */
 322     cr = cairo_create (csBoardWindow);
 323
 324     cairo_move_to (cr, x, y);
 325     cairo_line_to(cr, xTo, yTo );
 326
 327     SetPen(cr, 2, "#000000", 0);
 328     cairo_stroke(cr);
 329
 330     /* free memory */
 331     cairo_destroy (cr);
 332 }
 333
 334 void DrawSeekBackground( int left, int top, int right, int bottom )
 335 {
 336     cairo_t *cr = cairo_create (csBoardWindow);
 337
 338     cairo_rectangle (cr, left, top, right-left, bottom-top);
 339
 340     cairo_set_source_rgba(cr, 0.8, 0.8, 0.4,1.0);
 341     cairo_fill(cr);
 342
 343     /* free memory */
 344     cairo_destroy (cr);
 345 }
 346
 347 void DrawSeekText(char *buf, int x, int y)
 348 {
 349     cairo_t *cr = cairo_create (csBoardWindow);
 350
 351     cairo_select_font_face (cr, "Sans",
 352                             CAIRO_FONT_SLANT_NORMAL,
 353                             CAIRO_FONT_WEIGHT_NORMAL);
 354
 355     cairo_set_font_size (cr, 12.0);
 356
 357     cairo_move_to (cr, x, y+4);
 358     cairo_set_source_rgba(cr, 0, 0, 0,1.0);
 359     cairo_show_text( cr, buf);
 360
 361     /* free memory */
 362     cairo_destroy (cr);
 363 }
 364
 365 void DrawSeekDot(int x, int y, int colorNr)
 366 {
 367     cairo_t *cr = cairo_create (csBoardWindow);
 368     int square = colorNr & 0x80;
 369     colorNr &= 0x7F;
 370
 371     if(square)
 372         cairo_rectangle (cr, x-squareSize/9, y-squareSize/9, 2*(squareSize/9), 2*(squareSize/9));
 373     else
 374         cairo_arc(cr, x, y, squareSize/9, 0.0, 2*M_PI);
 375
 376     SetPen(cr, 2, "#000000", 0);
 377     cairo_stroke_preserve(cr);
 378     switch (colorNr) {
 379       case 0: cairo_set_source_rgba(cr, 1.0, 0, 0,1.0); break;
 380       case 1: cairo_set_source_rgba (cr, 0.0, 0.7, 0.2, 1.0); break;
 381       default: cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 1.0); break;
 382     }
 383     cairo_fill(cr);
 384
 385     /* free memory */
 386     cairo_destroy (cr);
 387 }
 388
 389 void
 390 DrawSeekOpen ()
 391 {
 392     int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
 393     int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 394     if(!csBoardWindow) {
 395         csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
 396         csBoardBackup = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, boardWidth, boardHeight);
 397     }
 398 }
 399
 400 void
 401 DrawSeekClose ()
 402 {
 403 }
 404
 405 void
 406 CreateGrid ()
 407 {
 408     int i, j;
 409
 410     if (lineGap == 0) return;
 411
 412     /* [HR] Split this into 2 loops for non-square boards. */
 413
 414     for (i = 0; i < BOARD_HEIGHT + 1; i++) {
 415         gridSegments[i].x1 = 0;
 416         gridSegments[i].x2 =
 417           lineGap + BOARD_WIDTH * (squareSize + lineGap);
 418         gridSegments[i].y1 = gridSegments[i].y2
 419           = lineGap / 2 + (i * (squareSize + lineGap));
 420     }
 421
 422     for (j = 0; j < BOARD_WIDTH + 1; j++) {
 423         gridSegments[j + i].y1 = 0;
 424         gridSegments[j + i].y2 =
 425           lineGap + BOARD_HEIGHT * (squareSize + lineGap);
 426         gridSegments[j + i].x1 = gridSegments[j + i].x2
 427           = lineGap / 2 + (j * (squareSize + lineGap));
 428     }
 429 }
 430
 431 void
 432 DoDrawGrid(cairo_surface_t *cs)
 433 {
 434   /* draws a grid starting around Nx, Ny squares starting at x,y */
 435   int i;
 436   cairo_t *cr;
 437
 438   DrawSeekOpen();
 439   /* get a cairo_t */
 440   cr = cairo_create (cs);
 441
 442   cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 443   SetPen(cr, lineGap, "#000000", 0);
 444
 445   /* lines in X */
 446   for (i = 0; i < BOARD_WIDTH + BOARD_HEIGHT + 2; i++)
 447     {
 448       cairo_move_to (cr, gridSegments[i].x1, gridSegments[i].y1);
 449       cairo_line_to (cr, gridSegments[i].x2, gridSegments[i].y2);
 450       cairo_stroke (cr);
 451     }
 452
 453   /* free memory */
 454   cairo_destroy (cr);
 455
 456   return;
 457 }
 458
 459 void
 460 DrawGrid()
 461 {
 462   DoDrawGrid(csBoardWindow);
 463   DoDrawGrid(csBoardBackup);
 464 }
 465
 466 void
 467 DoDrawBorder (cairo_surface_t *cs, int x, int y, int type)
 468 {
 469     cairo_t *cr;
 470     DrawSeekOpen();
 471     char *col;
 472
 473     switch(type) {
 474         case 0: col = "#000000"; break;
 475         case 1: col = appData.highlightSquareColor; break;
 476         case 2: col = appData.premoveHighlightColor; break;
 477     }
 478     cr = cairo_create(cs);
 479     cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
 480     cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
 481     SetPen(cr, lineGap, col, 0);
 482     cairo_stroke(cr);
 483 }
 484
 485 void
 486 DrawBorder (int x, int y, int type)
 487 {
 488   DoDrawBorder(csBoardWindow, x, y, type);
 489   DoDrawBorder(csBoardBackup, x, y, type);
 490 }
 491
 492 static int
 493 CutOutSquare (int x, int y, int *x0, int *y0, int  kind)
 494 {
 495     int W = BOARD_WIDTH, H = BOARD_HEIGHT;
 496     int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
 497     *x0 = 0; *y0 = 0;
 498     if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
 499     if(textureW[kind] < W*squareSize)
 500         *x0 = (textureW[kind] - squareSize) * nx/(W-1);
 501     else
 502         *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
 503     if(textureH[kind] < H*squareSize)
 504         *y0 = (textureH[kind] - squareSize) * ny/(H-1);
 505     else
 506         *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
 507     return 1;
 508 }
 509
 510 void
 511 DrawLogo (void *handle, void *logo)
 512 {
 513     cairo_surface_t *img, *cs;
 514     cairo_t *cr;
 515     int w, h;
 516
 517     if(!logo || !handle) return;
 518     cs = cairo_xlib_surface_create(xDisplay, XtWindow(handle), DefaultVisual(xDisplay, 0), appData.logoSize, appData.logoSize/2);
 519     img = cairo_image_surface_create_from_png (logo);
 520     w = cairo_image_surface_get_width (img);
 521     h = cairo_image_surface_get_height (img);
 522     cr = cairo_create(cs);
 523     cairo_scale(cr, (float)appData.logoSize/w, appData.logoSize/(2.*h));
 524     cairo_set_source_surface (cr, img, 0, 0);
 525     cairo_paint (cr);
 526     cairo_destroy (cr);
 527     cairo_surface_destroy (img);
 528     cairo_surface_destroy (cs);
 529 }
 530
 531 static void
 532 BlankSquare (cairo_surface_t *dest, int x, int y, int color, ChessSquare piece, int fac)
 533 {   // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
 534     int x0, y0;
 535     cairo_t *cr;
 536
 537     cr = cairo_create (dest);
 538
 539     if ((useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
 540             cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
 541             cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
 542             cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
 543             cairo_fill (cr);
 544             cairo_destroy (cr);
 545     } else { // evenly colored squares
 546         char *col;
 547         switch (color) {
 548           case 0: col = appData.darkSquareColor; break;
 549           case 1: col = appData.lightSquareColor; break;
 550           case 2: col = "#000000"; break;
 551         }
 552         SetPen(cr, 2.0, col, 0);
 553         cairo_rectangle (cr, x, y, squareSize, squareSize);
 554         cairo_fill (cr);
 555         cairo_destroy (cr);
 556     }
 557 }
 558
 559 static void
 560 pngDrawPiece (cairo_surface_t *dest, ChessSquare piece, int square_color, int x, int y)
 561 {
 562     int kind, p = piece;
 563     cairo_t *cr;
 564
 565     if ((int)piece < (int) BlackPawn) {
 566         kind = 0;
 567     } else {
 568         kind = 1;
 569         piece -= BlackPawn;
 570     }
 571     if(appData.upsideDown && flipView) { p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
 572     BlankSquare(dest, x, y, square_color, piece, 1); // erase previous contents with background
 573     cr = cairo_create (dest);
 574     cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
 575     cairo_paint(cr);
 576     cairo_destroy (cr);
 577 }
 578
 579 void
 580 DoDrawDot (cairo_surface_t *cs, int marker, int x, int y, int r)
 581 {
 582         cairo_t *cr;
 583
 584         cr = cairo_create(cs);
 585         cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
 586         if(appData.monoMode) {
 587             SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
 588             cairo_stroke_preserve(cr);
 589             SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
 590         } else {
 591             SetPen(cr, 2, marker == 2 ? "#FF0000" : "#FFFF00", 0);
 592         }
 593         cairo_fill(cr);
 594
 595         cairo_destroy(cr);
 596 }
 597
 598 void
 599 DrawDot (int marker, int x, int y, int r)
 600 { // used for atomic captures; no need to draw on backup
 601   DrawSeekOpen();
 602   DoDrawDot(csBoardWindow, marker, x, y, r);
 603 }
 604
 605 static void
 606 DoDrawOneSquare (cairo_surface_t *dest, int x, int y, ChessSquare piece, int square_color, int marker, char *string, int align)
 607 {   // basic front-end board-draw function: takes care of everything that can be in square:
 608     // piece, background, coordinate/count, marker dot
 609     int direction, font_ascent, font_descent;
 610     XCharStruct overall;
 611     cairo_t *cr;
 612
 613     if (piece == EmptySquare) {
 614         BlankSquare(dest, x, y, square_color, piece, 1);
 615     } else {
 616         pngDrawPiece(dest, piece, square_color, x, y);
 617     }
 618
 619     if(align) { // square carries inscription (coord or piece count)
 620         int xx = x, yy = y;
 621         // first calculate where it goes
 622         XTextExtents(countFontStruct, string, 1, &direction,
 623                          &font_ascent, &font_descent, &overall);
 624         if (align == 1) {
 625             xx += squareSize - overall.width - 2;
 626             yy += squareSize - font_descent - 1;
 627         } else if (align == 2) {
 628             xx += 2, yy += font_ascent + 1;
 629         } else if (align == 3) {
 630             xx += squareSize - overall.width - 2;
 631             yy += font_ascent + 1;
 632         } else if (align == 4) {
 633             xx += 2, yy += font_ascent + 1;
 634         }
 635         cr = cairo_create (dest);
 636         cairo_select_font_face (cr, "Sans",
 637                     CAIRO_FONT_SLANT_NORMAL,
 638                     CAIRO_FONT_WEIGHT_BOLD);
 639
 640         cairo_set_font_size (cr, squareSize/4);
 641
 642         cairo_move_to (cr, xx-1, yy);
 643         if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 644         else          cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
 645         cairo_show_text (cr, string);
 646         cairo_destroy (cr);
 647     }
 648
 649     if(marker) { // print fat marker dot, if requested
 650         DoDrawDot(dest, marker, x + squareSize/4, y+squareSize/4, squareSize/2);
 651     }
 652 }
 653
 654 void
 655 DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, char *string, int align)
 656 {
 657   DrawSeekOpen();
 658   DoDrawOneSquare (csBoardWindow, x, y, piece, square_color, marker, string, align);
 659   DoDrawOneSquare (csBoardBackup, x, y, piece, square_color, marker, string, align);
 660 }
 661
 662 /****   Animation code by Hugh Fisher, DCS, ANU. ****/
 663
 664 /*      Masks for XPM pieces. Black and white pieces can have
 665         different shapes, but in the interest of retaining my
 666         sanity pieces must have the same outline on both light
 667         and dark squares, and all pieces must use the same
 668         background square colors/images.                */
 669
 670 static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
 671
 672 static void
 673 InitAnimState (AnimNr anr)
 674 {
 675     DrawSeekOpen(); // set cs to board widget
 676     if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
 677     if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
 678     c_animBufs[anr+4] = csBoardWindow;
 679     c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 680     c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
 681 }
 682
 683 void
 684 CreateAnimVars ()
 685 {
 686   InitAnimState(Game);
 687   InitAnimState(Player);
 688 }
 689
 690 static void
 691 CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
 692 {
 693   static cairo_t *pieceSource;
 694   pieceSource = cairo_create (dest);
 695   cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
 696   if(doubleClick) cairo_paint_with_alpha (pieceSource, 0.6);
 697   else cairo_paint(pieceSource);
 698   cairo_destroy (pieceSource);
 699 }
 700
 701 void
 702 InsertPiece (AnimNr anr, ChessSquare piece)
 703 {
 704     CairoOverlayPiece(piece, c_animBufs[anr]);
 705 }
 706
 707 void
 708 DrawBlank (AnimNr anr, int x, int y, int startColor)
 709 {
 710     BlankSquare(c_animBufs[anr+2], x, y, startColor, EmptySquare, 0);
 711 }
 712
 713 void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
 714                  int srcX, int srcY, int width, int height, int destX, int destY)
 715 {
 716         cairo_t *cr;// = cairo_create (c_animBufs[anr+destBuf]);
 717         cr = cairo_create (c_animBufs[anr+destBuf]);
 718         if(c_animBufs[anr+srcBuf] == csBoardWindow)
 719         cairo_set_source_surface (cr, csBoardBackup, destX - srcX, destY - srcY);
 720         else
 721         cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
 722         cairo_rectangle (cr, destX, destY, width, height);
 723         cairo_fill (cr);
 724         cairo_destroy (cr);
 725         if(c_animBufs[anr+destBuf] == csBoardWindow) {
 726         cr = cairo_create (csBoardBackup); // also draw to backup
 727         cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
 728         cairo_rectangle (cr, destX, destY, width, height);
 729         cairo_fill (cr);
 730         cairo_destroy (cr);
 731         }
 732 }
 733
 734 void
 735 SetDragPiece (AnimNr anr, ChessSquare piece)
 736 {
 737 }
 738
 739 /* [AS] Arrow highlighting support */
 740
 741 void
 742 DoDrawPolygon (cairo_surface_t *cs, Pnt arrow[], int nr)
 743 {
 744     cairo_t *cr;
 745     int i;
 746     cr = cairo_create (cs);
 747     cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
 748     for (i=0;i<nr;i++) {
 749         cairo_line_to(cr, arrow[i].x, arrow[i].y);
 750     }
 751     if(appData.monoMode) { // should we always outline arrow?
 752         cairo_line_to(cr, arrow[0].x, arrow[0].y);
 753         SetPen(cr, 2, "#000000", 0);
 754         cairo_stroke_preserve(cr);
 755     }
 756     SetPen(cr, 2, appData.highlightSquareColor, 0);
 757     cairo_fill(cr);
 758
 759     /* free memory */
 760     cairo_destroy (cr);
 761 }
 762
 763 void
 764 DrawPolygon (Pnt arrow[], int nr)
 765 {
 766     DoDrawPolygon(csBoardWindow, arrow, nr);
 767     DoDrawPolygon(csBoardBackup, arrow, nr);
 768 }
 769
 770