#define SOLID 0
#define OUTLINE 1
-cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn]; // scaled pieces as used
-cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
+Boolean cairoAnimate = True;
+static cairo_surface_t *csBoardWindow, *csBoardBackup;
+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*/
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;
}
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 != 256 || h != 256) { printf("Bad png size %dx%d in %s\n", w, h, buf); exit(1); }
+ 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(piece <= WhiteKing) pngPieceBitmaps[color][piece] = cs;
// scaled copying of the raw png image
cr = cairo_create(cs);
- cairo_scale(cr, squareSize/256., squareSize/256.);
+ cairo_scale(cr, squareSize/64., squareSize/64.);
cairo_set_source_surface (cr, img, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
TimeDelay(msec);
}
-static cairo_surface_t *cs; // to keep out of back-end :-(
-
void
-DrawBorder (int x, int y, int type)
+DoDrawBorder (cairo_surface_t *cs, int x, int y, int type)
{
cairo_t *cr;
DrawSeekOpen();
cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
SetPen(cr, lineGap, type == 1 ? appData.highlightSquareColor : appData.premoveHighlightColor, 0);
cairo_stroke(cr);
+}
- DrawSeekClose();
+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(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 (cs);
+ 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);
- DrawSeekClose();
}
typedef void (*DrawFunc)();
}
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();
cairo_stroke(cr);
cairo_destroy(cr);
- DrawSeekClose();
+}
+
+void
+DrawDot (int marker, int x, int y, int r)
+{
+ DoDrawDot(marker, x, y, r, csBoardWindow);
+ DoDrawDot(marker, x, y, r, csBoardBackup);
}
void
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,
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
+ 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,
}
}
+static void
+CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
+{
+ static ChessSquare oldPiece = -1;
+ static cairo_t *pieceSource;
+ if(piece != oldPiece) { // 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;
+ }
+ 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);
}
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);
projects / xboard.git / blobdiff