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