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