#include "childio.h"
#include "xgamelist.h"
#include "xhistory.h"
+#include "xevalgraph.h"
#include "xedittags.h"
#include "menus.h"
#include "board.h"
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));
#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*/
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
//--------------------------------------------------------------------------------------------
+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)
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();
}
}
}
+ for(i=0; i<2; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ pngPieceBitmaps[i][(int)WhiteCannon] = pngPieceBitmaps2[i][(int)WhiteKing+1];
+ pngPieceBitmaps[i][(int)WhiteNightrider] = pngPieceBitmaps2[i][(int)WhiteKing+2];
+ pngPieceBitmaps[i][(int)WhiteSilver] = pngPieceBitmaps2[i][(int)WhiteKing+3];
+ pngPieceBitmaps[i][(int)WhiteGrasshopper] = pngPieceBitmaps2[i][(int)WhiteKing+4];
+ pngPieceBitmaps[i][(int)WhiteQueen] = pngPieceBitmaps2[i][(int)WhiteLance];
+ }
+ if(gameInfo.variant == VariantGothic) {
+ pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteSilver];
+ }
+ if(gameInfo.variant == VariantSChess) {
+ pngPieceBitmaps[i][(int)WhiteAngel] = pngPieceBitmaps2[i][(int)WhiteFalcon];
+ pngPieceBitmaps[i][(int)WhiteMarshall] = pngPieceBitmaps2[i][(int)WhiteAlfil];
+ }
+ }
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;
CreateXPMBoard(appData.liteBackTextureFile, 1);
CreateXPMBoard(appData.darkBackTextureFile, 0);
}
+ if (appData.pngDirectory[0] != NULLCHAR) { // for now do in parallel
+ CreatePNGPieces();
+ }
#else
CreateXIMPieces();
/* Create regular pieces */
/*
* 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;
CreateGCs(False);
CreateGrid();
- CreateAnyPieces();
if(appData.logoSize)
{ // locate and read user logo
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;
}
}
#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()
}
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();
+ char *col;
- if(type == 1) gc = highlineGC; else if(type == 2) gc = prelineGC;
+ switch(type) {
+ case 0: col = "#000000"; break;
+ case 1: col = appData.highlightSquareColor; break;
+ case 2: col = appData.premoveHighlightColor; break;
+ }
+ cr = cairo_create(cs);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
+ SetPen(cr, lineGap, col, 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
{ // [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
+ if(csBoardWindow) {
+ cairo_t *cr = cairo_create (csBoardWindow);
+ char *col;
+ switch (color) {
+ case 0: col = appData.darkSquareColor; break;
+ case 1: col = appData.lightSquareColor; break;
+ case 2: col = "#000000"; break;
+ }
+ SetPen(cr, 2.0, col, 0);
+ cairo_rectangle (cr, x, y, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ SetPen(cr, 2.0, col, 0);
+ cairo_rectangle (cr, x, y, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ } else
if (useImages && useImageSqs) {
Pixmap pm;
switch (color) {
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
} else {
return monoDrawPiece;
}
+ } else if(appData.pngDirectory[0]) {
+ return pngDrawPiece;
} else {
if (useImages)
return colorDrawPieceImage;
}
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
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);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ 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);
+ cairo_destroy (cr);
+ } else
XDrawString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
}
}
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);
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;
}
{
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
// [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)
{
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 );
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);
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,
cairo_set_font_size (cr, 12.0);
cairo_move_to (cr, x, y+4);
- cairo_show_text( cr, buf);
-
cairo_set_source_rgba(cr, 0, 0, 0,1.0);
- cairo_stroke(cr);
+ cairo_show_text( cr, buf);
/* free memory */
cairo_destroy (cr);
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;
{
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;
/* free memory */
cairo_destroy (cr);
- DrawSeekClose();
return;
}
+void
+DrawGrid()
+{
+ DoDrawGrid(csBoardWindow);
+ DoDrawGrid(csBoardBackup);
+}
+
/*
* event handler for redrawing the board
*/
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)
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,
{
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);
InitAnimState(Player, &info);
/* For XPM pieces, we need bitmaps to use as masks. */
- if (useImages)
+ if (useImages & !xpmDone)
CreateAnimMasks(info.depth), xpmDone = 1;
}
}
}
+static void
+CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
+{
+ static cairo_t *pieceSource;
+ pieceSource = cairo_create (dest);
+ cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
+ if(doubleClick) cairo_paint_with_alpha (pieceSource, 0.6);
+ else cairo_paint(pieceSource);
+ cairo_destroy (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);
}
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);
/* [AS] Arrow highlighting support */
-void DrawPolygon(Pnt arrow[], int nr)
-{ // for now on own surface; eventually this should become a global that is only destroyed on resize
- cairo_surface_t *boardSurface;
+void
+DoDrawPolygon (cairo_surface_t *cs, Pnt arrow[], int nr)
+{
cairo_t *cr;
int i;
- int w = lineGap + BOARD_WIDTH * (squareSize + lineGap);
- int h = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
- boardSurface = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), w, h);
- cr = cairo_create (boardSurface);
+ cr = cairo_create (cs);
cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
for (i=0;i<nr;i++) {
cairo_line_to(cr, arrow[i].x, arrow[i].y);
/* free memory */
cairo_destroy (cr);
- cairo_surface_destroy (boardSurface);
+}
+
+void
+DrawPolygon (Pnt arrow[], int nr)
+{
+ DoDrawPolygon(csBoardWindow, arrow, nr);
+ DoDrawPolygon(csBoardBackup, arrow, nr);
}
static void
projects / xboard.git / blobdiff