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