X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=xboard.c;h=c5c849bd91b9200ad39b6bddc4caf4bb88ad3f0b;hb=08aa97a16435e4569975d203c7e1f3050b207d8a;hp=e3afe5df8842b24e4d07cde9070d67bdc290f301;hpb=c3dccf9e44678d2c0330f28dccdb7ec8fca9e593;p=xboard.git

diff --git a/xboard.c b/xboard.c
index e3afe5d..c5c849b 100644
--- a/xboard.c
+++ b/xboard.c
@@ -204,6 +204,7 @@ extern char *getenv();
 #include "childio.h"
 #include "xgamelist.h"
 #include "xhistory.h"
+#include "xevalgraph.h"
 #include "xedittags.h"
 #include "menus.h"
 #include "board.h"
@@ -236,6 +237,7 @@ static void CreateGCs P((int redo));
 static void CreateAnyPieces P((void));
 void CreateXIMPieces P((void));
 void CreateXPMPieces P((void));
+void CreatePNGPieces P((void));
 void CreateXPMBoard P((char *s, int n));
 void CreatePieces P((void));
 Widget CreateMenuBar P((Menu *mb, int boardWidth));
@@ -338,6 +340,11 @@ WindowPlacement wpTags;
 
 #define SOLID 0
 #define OUTLINE 1
+Boolean cairoAnimate;
+static cairo_surface_t *csBoardWindow, *csBoardBackup, *csDualBoard;
+static cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn];    // scaled pieces as used
+static cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
+static cairo_surface_t *pngBoardBitmap[2];
 Pixmap pieceBitmap[2][(int)BlackPawn];
 Pixmap pieceBitmap2[2][(int)BlackPawn+4];       /* [HGM] pieces */
 Pixmap xpmPieceBitmap[4][(int)BlackPawn];	/* LL, LD, DL, DD actually used*/
@@ -887,9 +894,16 @@ SwitchWindow ()
     extern Option dualOptions[];
     static Window dual;
     Window tmp = xBoardWindow;
+    cairo_surface_t *cstmp = csBoardWindow;
     if(!dual) dual = XtWindow(dualOptions[3].handle); // must be first call
     xBoardWindow = dual; // swap them
     dual = tmp;
+    csBoardWindow = csDualBoard;
+    if(!csDualBoard && cstmp) {
+	int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+	int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+	csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+    }
 }
 
 void
@@ -920,6 +934,16 @@ ConvertToLine (int argc, char **argv)
 
 //--------------------------------------------------------------------------------------------
 
+void
+NewSurfaces ()
+{
+    // delete surfaces after size becomes invalid, so they will be recreated
+    if(csBoardWindow) cairo_surface_destroy(csBoardWindow);
+    if(csBoardBackup) cairo_surface_destroy(csBoardBackup);
+    if(csDualBoard) cairo_surface_destroy(csDualBoard);
+    csBoardWindow = csBoardBackup = csDualBoard = NULL;
+}
+
 #define BoardSize int
 void
 InitDrawingSizes (BoardSize boardSize, int flags)
@@ -943,15 +967,16 @@ InitDrawingSizes (BoardSize boardSize, int flags)
 
     oldWidth = boardWidth; oldHeight = boardHeight;
     CreateGrid();
+    NewSurfaces();
 
     /*
      * Inhibit shell resizing.
      */
-    shellArgs[0].value = w = (XtArgVal) boardWidth + marginW ;
+    shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + 1; // [HGM] not sure why the +1 is (sometimes) needed...
     shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
     shellArgs[4].value = shellArgs[2].value = w;
     shellArgs[5].value = shellArgs[3].value = h;
-    XtSetValues(shellWidget, &shellArgs[0], 6);
+    XtSetValues(shellWidget, &shellArgs[0], cairoAnimate ? 2 : 6);
 
     XSync(xDisplay, False);
     DelayedDrag();
@@ -1028,11 +1053,17 @@ InitDrawingSizes (BoardSize boardSize, int flags)
 	}
       }
     }
+    for(i=0; i<2; i++) {
+	int p;
+printf("Copy pieces\n");
+	for(p=0; p<=(int)WhiteKing; p++)
+	   pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
+    }
     oldMono = -10; // kludge to force recreation of animation masks
     oldVariant = gameInfo.variant;
   }
 #if HAVE_LIBXPM
-  if(appData.monoMode != oldMono)
+  if(appData.monoMode != oldMono || cairoAnimate)
     CreateAnimVars();
 #endif
   oldMono = appData.monoMode;
@@ -1090,6 +1121,9 @@ CreateAnyPieces ()
       CreateXPMBoard(appData.liteBackTextureFile, 1);
       CreateXPMBoard(appData.darkBackTextureFile, 0);
     }
+    if (appData.pngDirectory[0] != NULLCHAR) { // for now do in parallel
+      CreatePNGPieces();
+    }
 #else
     CreateXIMPieces();
     /* Create regular pieces */
@@ -1507,12 +1541,17 @@ XBoard square size (hint): %d\n\
     /*
      * Inhibit shell resizing.
      */
+
+    CreateAnyPieces();
+    cairoAnimate = *appData.pngDirectory && useTexture == 3
+	&& strstr(appData.liteBackTextureFile, ".png") && strstr(appData.darkBackTextureFile, ".png");
+
     shellArgs[0].value = (XtArgVal) &w;
     shellArgs[1].value = (XtArgVal) &h;
     XtGetValues(shellWidget, shellArgs, 2);
     shellArgs[4].value = shellArgs[2].value = w;
     shellArgs[5].value = shellArgs[3].value = h;
-    XtSetValues(shellWidget, &shellArgs[2], 4);
+    if(!cairoAnimate) XtSetValues(shellWidget, &shellArgs[2], 4);
     marginW =  w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
     marginH =  h - boardHeight;
 
@@ -1520,7 +1559,6 @@ XBoard square size (hint): %d\n\
 
     CreateGCs(False);
     CreateGrid();
-    CreateAnyPieces();
 
     if(appData.logoSize)
     {   // locate and read user logo
@@ -2045,6 +2083,14 @@ CreateXPMBoard (char *s, int kind)
     XpmAttributes attr;
     attr.valuemask = 0;
     if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
+    if(strstr(s, ".png")) {
+	cairo_surface_t *img = cairo_image_surface_create_from_png (s);
+	if(img) {
+	    useTexture |= kind + 1; pngBoardBitmap[kind] = img;
+	    textureW[kind] = cairo_image_surface_get_width (img);
+	    textureH[kind] = cairo_image_surface_get_height (img);
+	}
+    } else
     if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
 	useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
     }
@@ -2205,6 +2251,51 @@ CreateXPMPieces ()
 }
 #endif /* HAVE_LIBXPM */
 
+char *pngPieceNames[] = // must be in same order as internal piece encoding
+{ "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner", 
+  "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "King", 
+  "GoldKnight", "GoldLance", "GoldPawn", "GoldSilver", NULL
+};
+
+void
+ScaleOnePiece (char *name, int color, int piece)
+{
+  int w, h;
+  char buf[MSG_SIZ];
+  cairo_surface_t *img, *cs;
+  cairo_t *cr;
+  static cairo_surface_t *pngPieceImages[2][(int)BlackPawn+4];   // png 256 x 256 images
+
+  if((img = pngPieceImages[color][piece]) == NULL) { // if PNG file for this piece was not yet read, read it now and store it
+    snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pngDirectory, color ? "Black" : "White", pngPieceNames[piece]);
+    pngPieceImages[color][piece] = img = cairo_image_surface_create_from_png (buf);
+    w = cairo_image_surface_get_width (img);
+    h = cairo_image_surface_get_height (img);
+    if(w != 64 || h != 64) { printf("Bad png size %dx%d in %s\n", w, h, buf); exit(1); }
+  }
+  // create new bitmap to hold scaled piece image (and remove any old)
+  if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
+  pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+  if(piece <= WhiteKing) pngPieceBitmaps[color][piece] = cs;
+  // scaled copying of the raw png image
+  cr = cairo_create(cs);
+  cairo_scale(cr, squareSize/64., squareSize/64.);
+  cairo_set_source_surface (cr, img, 0, 0);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+}
+
+void
+CreatePNGPieces ()
+{
+  int p;
+
+  for(p=0; pngPieceNames[p]; p++) {
+    ScaleOnePiece(pngPieceNames[p], 0, p);
+    ScaleOnePiece(pngPieceNames[p], 1, p);
+  }
+}
+
 #if HAVE_LIBXPM
 /* No built-in bitmaps */
 void CreatePieces()
@@ -2426,14 +2517,23 @@ do_flash_delay (unsigned long msec)
 }
 
 void
-DrawBorder (int x, int y, int type)
+DoDrawBorder (cairo_surface_t *cs, int x, int y, int type)
 {
-    GC gc = lineGC;
+    cairo_t *cr;
+    DrawSeekOpen();
 
-    if(type == 1) gc = highlineGC; else if(type == 2) gc = prelineGC;
+    cr = cairo_create(cs);
+    cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+    cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
+    SetPen(cr, lineGap, type == 1 ? appData.highlightSquareColor : appData.premoveHighlightColor, 0);
+    cairo_stroke(cr);
+}
 
-    XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
-		   squareSize+lineGap, squareSize+lineGap);
+void
+DrawBorder (int x, int y, int type)
+{
+  DoDrawBorder(csBoardWindow, x, y, type);
+  DoDrawBorder(csBoardBackup, x, y, type);
 }
 
 static int
@@ -2480,6 +2580,25 @@ BlankSquare (int x, int y, int color, ChessSquare piece, Drawable dest, int fac)
 {   // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
     int x0, y0;
     if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
+	if(pngBoardBitmap[color]) {
+	    cairo_t *cr;
+	    if(!fac && !cairoAnimate) return;
+	    DrawSeekOpen();
+	    cr = cairo_create (fac ? csBoardWindow : (cairo_surface_t *) dest);
+	    cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+	    cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+	    cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+	    cairo_fill (cr);
+	    cairo_destroy (cr);
+	   if(fac) {
+	    cr = cairo_create (csBoardBackup);
+	    cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+	    cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+	    cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+	    cairo_fill (cr);
+	    cairo_destroy (cr);
+	   }
+	} else
 	XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
 		  squareSize, squareSize, x*fac, y*fac);
     } else
@@ -2630,6 +2749,31 @@ colorDrawPieceImage (ChessSquare piece, int square_color, int x, int y, Drawable
 	      squareSize, squareSize, x, y);
 }
 
+static void
+pngDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+    int kind, p = piece;
+    cairo_t *cr;
+
+    if ((int)piece < (int) BlackPawn) {
+	kind = 0;
+    } else {
+	kind = 1;
+	piece -= BlackPawn;
+    }
+    if(appData.upsideDown && flipView) { p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
+    BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+    DrawSeekOpen();
+    cr = cairo_create (csBoardWindow);
+    cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+    cairo_paint(cr);
+    cairo_destroy (cr);
+    cr = cairo_create (csBoardBackup);
+    cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+    cairo_paint(cr);
+    cairo_destroy (cr);
+}
+
 typedef void (*DrawFunc)();
 
 DrawFunc
@@ -2641,6 +2785,8 @@ ChooseDrawFunc ()
 	} else {
 	    return monoDrawPiece;
 	}
+    } else if(appData.pngDirectory[0]) {
+	return pngDrawPiece;
     } else {
 	if (useImages)
 	  return colorDrawPieceImage;
@@ -2650,16 +2796,30 @@ ChooseDrawFunc ()
 }
 
 void
-DrawDot (int marker, int x, int y, int r)
+DoDrawDot (int marker, int x, int y, int r, cairo_surface_t *cs)
 {
+	cairo_t *cr;
+	DrawSeekOpen();
+	cr = cairo_create(cs);
+	cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
 	if(appData.monoMode) {
-	    XFillArc(xDisplay, xBoardWindow, marker == 2 ? darkSquareGC : lightSquareGC,
-		    x, y, r, r, 0, 64*360);
-	    XDrawArc(xDisplay, xBoardWindow, marker == 2 ? lightSquareGC : darkSquareGC,
-		    x, y, r, r, 0, 64*360);
-	} else
-	XFillArc(xDisplay, xBoardWindow, marker == 2 ? prelineGC : highlineGC,
-		    x, y, r, r, 0, 64*360);
+	    SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
+	    cairo_stroke_preserve(cr);
+	    SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
+	} else {
+	    SetPen(cr, 2, marker == 2 ? "#FF0000" : "#FFFF00", 0);
+	}
+	cairo_fill(cr);
+	cairo_stroke(cr);
+
+	cairo_destroy(cr);
+}
+
+void
+DrawDot (int marker, int x, int y, int r)
+{
+  DoDrawDot(marker, x, y, r, csBoardWindow);
+  DoDrawDot(marker, x, y, r, csBoardBackup);
 }
 
 void
@@ -2698,6 +2858,22 @@ DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, ch
 	if (appData.monoMode) {
 	    XDrawImageString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
 	} else {
+	    if(*appData.pngDirectory) {
+		cairo_t *cr = cairo_create (csBoardWindow);
+		cairo_select_font_face (cr, "Sans",
+			    CAIRO_FONT_SLANT_NORMAL,
+			    CAIRO_FONT_WEIGHT_BOLD);
+
+		cairo_set_font_size (cr, squareSize/4);
+
+		cairo_move_to (cr, xx-1, yy);
+		if(align < 3) cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+		else          cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+		cairo_show_text (cr, string);
+
+		/* free memory */
+		cairo_destroy (cr);
+	    } else
 	    XDrawString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
 	}
     }
@@ -2759,15 +2935,37 @@ CoDrag (Widget sh, WindowPlacement *wp)
     XtSetValues(sh, args, j);
 }
 
+void
+ReSize (WindowPlacement *wp)
+{
+	int sqx, sqy;
+	if(wp->width == wpMain.width && wp->height == wpMain.height) return; // not sized
+	sqx = (wp->width  - lineGap - marginW) / BOARD_WIDTH - lineGap;
+	sqy = (wp->height - lineGap - marginH) / BOARD_HEIGHT - lineGap;
+	if(sqy < sqx) sqx = sqy;
+	if(sqx != squareSize) {
+	    squareSize = sqx; // adopt new square size
+	    NewSurfaces();
+	    CreatePNGPieces(); // make newly scaled pieces
+	    InitDrawingSizes(0, 0); // creates grid etc.
+	}
+}
+
 static XtIntervalId delayedDragID = 0;
 
 void
 DragProc ()
 {
+	static int busy;
+	if(busy) return;
+
+	busy = 1;
 	GetActualPlacement(shellWidget, &wpNew);
 	if(wpNew.x == wpMain.x && wpNew.y == wpMain.y && // not moved
-	   wpNew.width == wpMain.width && wpNew.height == wpMain.height) // not sized
-	    return; // false alarm
+	   wpNew.width == wpMain.width && wpNew.height == wpMain.height) { // not sized
+	    busy = 0; return; // false alarm
+	}
+	ReSize(&wpNew);
 	if(shellUp[EngOutDlg]) CoDrag(shells[EngOutDlg], &wpEngineOutput);
 	if(shellUp[HistoryDlg]) CoDrag(shells[HistoryDlg], &wpMoveHistory);
 	if(shellUp[EvalGraphDlg]) CoDrag(shells[EvalGraphDlg], &wpEvalGraph);
@@ -2775,6 +2973,7 @@ DragProc ()
 	wpMain = wpNew;
 	DrawPosition(True, NULL);
 	delayedDragID = 0; // now drag executed, make sure next DelayedDrag will not cancel timer event (which could now be used by other)
+	busy = 0;
 }
 
 
@@ -2783,7 +2982,7 @@ DelayedDrag ()
 {
     if(delayedDragID) XtRemoveTimeOut(delayedDragID); // cancel pending
     delayedDragID =
-      XtAppAddTimeOut(appContext, 50, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
+      XtAppAddTimeOut(appContext, 100, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
 }
 
 void
@@ -2795,8 +2994,6 @@ EventProc (Widget widget, caddr_t unused, XEvent *event)
 
 // [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
 
-static cairo_surface_t *cs; // to keep out of back-end :-(
-
 float
 Color (char *col, int n)
 {
@@ -2821,7 +3018,7 @@ void DrawSeekAxis( int x, int y, int xTo, int yTo )
     cairo_t *cr;
 
     /* get a cairo_t */
-    cr = cairo_create (cs);
+    cr = cairo_create (csBoardWindow);
 
     cairo_move_to (cr, x, y);
     cairo_line_to(cr, xTo, yTo );
@@ -2835,7 +3032,7 @@ void DrawSeekAxis( int x, int y, int xTo, int yTo )
 
 void DrawSeekBackground( int left, int top, int right, int bottom )
 {
-    cairo_t *cr = cairo_create (cs);
+    cairo_t *cr = cairo_create (csBoardWindow);
 
     cairo_rectangle (cr, left, top, right-left, bottom-top);
 
@@ -2848,7 +3045,7 @@ void DrawSeekBackground( int left, int top, int right, int bottom )
 
 void DrawSeekText(char *buf, int x, int y)
 {
-    cairo_t *cr = cairo_create (cs);
+    cairo_t *cr = cairo_create (csBoardWindow);
 
     cairo_select_font_face (cr, "Sans",
 			    CAIRO_FONT_SLANT_NORMAL,
@@ -2868,7 +3065,7 @@ void DrawSeekText(char *buf, int x, int y)
 
 void DrawSeekDot(int x, int y, int colorNr)
 {
-    cairo_t *cr = cairo_create (cs);
+    cairo_t *cr = cairo_create (csBoardWindow);
     int square = colorNr & 0x80;
     colorNr &= 0x7F;
 
@@ -2895,17 +3092,19 @@ DrawSeekOpen ()
 {
     int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
     int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
-    cs = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+    if(!csBoardWindow) {
+	csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+	csBoardBackup = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, boardWidth, boardHeight);
+    }
 }
 
 void
 DrawSeekClose ()
 {
-    cairo_surface_destroy(cs);
 }
 
 void
-DrawGrid()
+DoDrawGrid(cairo_surface_t *cs)
 {
   /* draws a grid starting around Nx, Ny squares starting at x,y */
   int i;
@@ -2928,11 +3127,17 @@ DrawGrid()
 
   /* free memory */
   cairo_destroy (cr);
-  DrawSeekClose();
 
   return;
 }
 
+void
+DrawGrid()
+{
+  DoDrawGrid(csBoardWindow);
+  DoDrawGrid(csBoardBackup);
+}
+
 /*
  * event handler for redrawing the board
  */
@@ -3644,6 +3849,7 @@ RemoveInputSource (InputSourceRef isr)
 static int xpmDone = 0;
 static Pixmap animBufs[3*NrOfAnims]; // newBuf, saveBuf
 static GC animGCs[3*NrOfAnims]; // blitGC, pieceGC, outlineGC;
+static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
 
 static void
 CreateAnimMasks (int pieceDepth)
@@ -3729,6 +3935,15 @@ InitAnimState (AnimNr anr, XWindowAttributes *info)
   XtGCMask  mask;
   XGCValues values;
 
+  if(cairoAnimate) {
+    DrawSeekOpen(); // set cs to board widget
+    if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
+    if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
+    c_animBufs[anr+4] = csBoardWindow;
+    c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+    c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+  }
+
   /* Each buffer is square size, same depth as window */
   animBufs[anr+4] = xBoardWindow;
   animBufs[anr+2] = XCreatePixmap(xDisplay, xBoardWindow,
@@ -3759,7 +3974,7 @@ CreateAnimVars ()
 {
   XWindowAttributes info;
 
-  if (xpmDone && gameInfo.variant == oldVariant) return;
+  if (!cairoAnimate && xpmDone && gameInfo.variant == oldVariant) return;
   if(xpmDone) oldVariant = gameInfo.variant; // first time pieces might not be created yet
   XGetWindowAttributes(xDisplay, xBoardWindow, &info);
 
@@ -3767,7 +3982,7 @@ CreateAnimVars ()
   InitAnimState(Player, &info);
 
   /* For XPM pieces, we need bitmaps to use as masks. */
-  if (useImages)
+  if (useImages & !xpmDone)
     CreateAnimMasks(info.depth), xpmDone = 1;
 }
 
@@ -3885,21 +4100,60 @@ OverlayPiece (ChessSquare piece, GC clip, GC outline,  Drawable dest)
   }
 }
 
+static void
+CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
+{
+  static ChessSquare oldPiece = -1;
+  static int oldSize;
+  static cairo_t *pieceSource;
+  if(piece != oldPiece || squareSize != oldSize) { // try make it faster by only changing cr if we need other piece
+    if(pieceSource) cairo_destroy (pieceSource);
+    pieceSource = cairo_create (dest);
+    cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
+    oldPiece = piece; oldSize = squareSize;
+  }
+  cairo_paint(pieceSource);
+}
+
 void
 InsertPiece (AnimNr anr, ChessSquare piece)
 {
+  if(cairoAnimate) {
+    CairoOverlayPiece(piece, c_animBufs[anr]);
+  } else
   OverlayPiece(piece, animGCs[anr+2], animGCs[anr+4], animBufs[anr]);
 }
 
 void
 DrawBlank (AnimNr anr, int x, int y, int startColor)
 {
+    if(cairoAnimate)
+    BlankSquare(x, y, startColor, EmptySquare, (Drawable) c_animBufs[anr+2], 0);
+    else
     BlankSquare(x, y, startColor, EmptySquare, animBufs[anr+2], 0);
 }
 
 void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
 		 int srcX, int srcY, int width, int height, int destX, int destY)
 {
+    if(cairoAnimate) {
+	cairo_t *cr;// = cairo_create (c_animBufs[anr+destBuf]);
+	cr = cairo_create (c_animBufs[anr+destBuf]);
+	if(c_animBufs[anr+srcBuf] == csBoardWindow)
+	cairo_set_source_surface (cr, csBoardBackup, destX - srcX, destY - srcY);
+	else
+	cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+	cairo_rectangle (cr, destX, destY, width, height);
+	cairo_fill (cr);
+	cairo_destroy (cr);
+	if(c_animBufs[anr+destBuf] == csBoardWindow) {
+	cr = cairo_create (csBoardBackup); // also draw to backup
+	cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+	cairo_rectangle (cr, destX, destY, width, height);
+	cairo_fill (cr);
+	cairo_destroy (cr);
+	}
+    } else
     XCopyArea(xDisplay, animBufs[anr+srcBuf], animBufs[anr+destBuf], animGCs[anr],
 		srcX, srcY, width, height, destX, destY);
 }
@@ -3908,6 +4162,7 @@ void
 SetDragPiece (AnimNr anr, ChessSquare piece)
 {
   Pixmap mask;
+  if(cairoAnimate) return;
   /* The piece will be drawn using its own bitmap as a matte	*/
   SelectGCMask(piece, &animGCs[anr+2], &animGCs[anr+4], &mask);
   XSetClipMask(xDisplay, animGCs[anr+2], mask);