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