| 1 | /* This file contains code for X-CHESS. |
| 2 | Copyright (C) 1986 Free Software Foundation, Inc. |
| 3 | |
| 4 | This file is part of X-CHESS. |
| 5 | |
| 6 | X-CHESS is distributed in the hope that it will be useful, |
| 7 | but WITHOUT ANY WARRANTY. No author or distributor |
| 8 | accepts responsibility to anyone for the consequences of using it |
| 9 | or for whether it serves any particular purpose or works at all, |
| 10 | unless he says so in writing. Refer to the X-CHESS General Public |
| 11 | License for full details. |
| 12 | |
| 13 | Everyone is granted permission to copy, modify and redistribute |
| 14 | X-CHESS, but only under the conditions described in the |
| 15 | X-CHESS General Public License. A copy of this license is |
| 16 | supposed to have been given to you along with X-CHESS so you |
| 17 | can know your rights and responsibilities. It should be in a |
| 18 | file named COPYING. Among other things, the copyright notice |
| 19 | and this notice must be preserved on all copies. */ |
| 20 | |
| 21 | |
| 22 | /* RCS Info: $Revision: 1.5 $ on $Date: 86/11/26 12:11:15 $ |
| 23 | * $Source: /users/faustus/xchess/RCS/window.c,v $ |
| 24 | * Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group |
| 25 | * Permission is granted to do anything with this code except sell it |
| 26 | * or remove this message. |
| 27 | * |
| 28 | * Deal with the two (or one) windows. |
| 29 | */ |
| 30 | |
| 31 | #include "xchess.h" |
| 32 | #include <X11/Xutil.h> |
| 33 | #include <sys/time.h> |
| 34 | |
| 35 | #include "pawn.bitmap" |
| 36 | #include "rook.bitmap" |
| 37 | #include "knight.bitmap" |
| 38 | #include "bishop.bitmap" |
| 39 | #include "queen.bitmap" |
| 40 | #include "king.bitmap" |
| 41 | |
| 42 | #include "pawn_outline.bitmap" |
| 43 | #include "rook_outline.bitmap" |
| 44 | #include "knight_outline.bitmap" |
| 45 | #include "bishop_outline.bitmap" |
| 46 | #include "queen_outline.bitmap" |
| 47 | #include "king_outline.bitmap" |
| 48 | |
| 49 | #include "pawn_mask.bitmap" |
| 50 | #include "rook_mask.bitmap" |
| 51 | #include "knight_mask.bitmap" |
| 52 | #include "bishop_mask.bitmap" |
| 53 | #include "queen_mask.bitmap" |
| 54 | #include "king_mask.bitmap" |
| 55 | |
| 56 | #include "shade.bitmap" |
| 57 | |
| 58 | #include "xchess.cur" |
| 59 | #include "xchess_mask.cur" |
| 60 | |
| 61 | #include "xchess.icon" |
| 62 | |
| 63 | windata *win1, *win2; |
| 64 | bool win_flashmove = false; |
| 65 | |
| 66 | extern bool setup(); |
| 67 | extern void service(), drawgrid(), icon_refresh(); |
| 68 | |
| 69 | bool |
| 70 | win_setup(disp1, disp2) |
| 71 | char *disp1, *disp2; |
| 72 | { |
| 73 | win1 = alloc(windata); |
| 74 | if (!oneboard) |
| 75 | win2 = alloc(windata); |
| 76 | |
| 77 | if (!setup(disp1, win1) || (!oneboard && !setup(disp2, win2))) |
| 78 | return (false); |
| 79 | |
| 80 | if (blackflag) { |
| 81 | win1->color = BLACK; |
| 82 | win1->flipped = true; |
| 83 | } else |
| 84 | win1->color = WHITE; |
| 85 | win_drawboard(win1); |
| 86 | |
| 87 | if (!oneboard) { |
| 88 | win2->color = BLACK; |
| 89 | win2->flipped = true; |
| 90 | win_drawboard(win2); |
| 91 | } |
| 92 | |
| 93 | return(true); |
| 94 | } |
| 95 | |
| 96 | /* Draw the chess board... */ |
| 97 | |
| 98 | void |
| 99 | win_drawboard(win) |
| 100 | windata *win; |
| 101 | { |
| 102 | int i, j; |
| 103 | |
| 104 | drawgrid(win); |
| 105 | |
| 106 | /* Now toss on the squares... */ |
| 107 | for (i = 0; i < SIZE; i++) |
| 108 | for (j = 0; j < SIZE; j++) |
| 109 | win_erasepiece(j, i, win->color); |
| 110 | |
| 111 | return; |
| 112 | } |
| 113 | |
| 114 | /* Draw one piece. */ |
| 115 | |
| 116 | void |
| 117 | win_drawpiece(p, y, x, wnum) |
| 118 | piece *p; |
| 119 | int y, x; |
| 120 | color wnum; |
| 121 | { |
| 122 | char *bits, *maskbits, *outline; |
| 123 | windata *win; |
| 124 | char buf[BSIZE]; |
| 125 | XImage *tmpImage; |
| 126 | Pixmap tmpPM, maskPM; |
| 127 | XGCValues gc; |
| 128 | |
| 129 | if (oneboard || (wnum == win1->color)) |
| 130 | win = win1; |
| 131 | else |
| 132 | win = win2; |
| 133 | |
| 134 | if (win->flipped) { |
| 135 | y = SIZE - y - 1; |
| 136 | x = SIZE - x - 1; |
| 137 | } |
| 138 | |
| 139 | /* |
| 140 | if (debug) |
| 141 | fprintf(stderr, "draw a %s at (%d, %d) on board %d\n", |
| 142 | piecenames[(int) p->type], y, x, wnum); |
| 143 | */ |
| 144 | |
| 145 | if ((x < 0) || (x > 7) || (y < 0) || (y > 7)) exit(1); |
| 146 | |
| 147 | switch (p->type) { |
| 148 | case PAWN: |
| 149 | bits = pawn_bits; |
| 150 | maskbits = pawn_mask_bits; |
| 151 | outline = pawn_outline_bits; |
| 152 | break; |
| 153 | |
| 154 | case ROOK: |
| 155 | bits = rook_bits; |
| 156 | maskbits = rook_mask_bits; |
| 157 | outline = rook_outline_bits; |
| 158 | break; |
| 159 | |
| 160 | case KNIGHT: |
| 161 | bits = knight_bits; |
| 162 | maskbits = knight_mask_bits; |
| 163 | outline = knight_outline_bits; |
| 164 | break; |
| 165 | |
| 166 | case BISHOP: |
| 167 | bits = bishop_bits; |
| 168 | maskbits = bishop_mask_bits; |
| 169 | outline = bishop_outline_bits; |
| 170 | break; |
| 171 | |
| 172 | case QUEEN: |
| 173 | bits = queen_bits; |
| 174 | maskbits = queen_mask_bits; |
| 175 | outline = queen_outline_bits; |
| 176 | break; |
| 177 | |
| 178 | case KING: |
| 179 | bits = king_bits; |
| 180 | maskbits = king_mask_bits; |
| 181 | outline = king_outline_bits; |
| 182 | break; |
| 183 | |
| 184 | default: |
| 185 | fprintf(stderr, |
| 186 | "Internal Error: win_drawpiece: bad piece type %d\n", |
| 187 | p->type); |
| 188 | } |
| 189 | |
| 190 | /* There are two things we can do... If this is a black and white |
| 191 | * display, we have to shade the square and use an outline if the piece |
| 192 | * is white. We also have to use a mask... Since we don't want |
| 193 | * to use up too many bitmaps, create the mask bitmap, put the bits, |
| 194 | * and then destroy it. |
| 195 | */ |
| 196 | if (win->bnw && (p->color == WHITE)) |
| 197 | bits = outline; |
| 198 | if (win->bnw && !iswhite(win, x, y)) { |
| 199 | XSetState(win->display, DefaultGC(win->display, 0), |
| 200 | BlackPixel(win->display, 0), |
| 201 | WhitePixel(win->display, 0), GXcopy, AllPlanes); |
| 202 | |
| 203 | tmpPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 204 | shade_bits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 205 | |
| 206 | XCopyPlane(win->display, tmpPM, win->boardwin, DefaultGC(win->display, 0), |
| 207 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 208 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 209 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 210 | |
| 211 | XFreePixmap(win->display, tmpPM); |
| 212 | |
| 213 | XSetFunction(win->display, DefaultGC(win->display, 0), |
| 214 | GXandInverted); |
| 215 | maskPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 216 | maskbits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 217 | XCopyPlane(win->display, maskPM, win->boardwin, DefaultGC(win->display, 0), |
| 218 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 219 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 220 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 221 | XFreePixmap(win->display, maskPM); |
| 222 | |
| 223 | XSetFunction(win->display, DefaultGC(win->display, 0), |
| 224 | GXor); |
| 225 | tmpPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 226 | bits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 227 | XCopyPlane(win->display, tmpPM, win->boardwin, DefaultGC(win->display, 0), |
| 228 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 229 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 230 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 231 | XFreePixmap(win->display, tmpPM); |
| 232 | |
| 233 | XSetFunction(win->display, DefaultGC(win->display, 0), GXcopy); |
| 234 | |
| 235 | } else if (win->bnw){ |
| 236 | XSetState(win->display, DefaultGC(win->display, 0), |
| 237 | BlackPixel(win->display, 0), |
| 238 | WhitePixel(win->display, 0), GXcopy, AllPlanes); |
| 239 | |
| 240 | tmpPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 241 | bits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 242 | XCopyPlane(win->display, tmpPM, win->boardwin, DefaultGC(win->display, 0), |
| 243 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 244 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 245 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 246 | XFreePixmap(win->display, tmpPM); |
| 247 | } else { |
| 248 | XSetState(win->display, DefaultGC(win->display, 0), |
| 249 | ((p->color == WHITE) ? win->whitepiece.pixel : |
| 250 | win->blackpiece.pixel), |
| 251 | (iswhite(win, x, y) ? win->whitesquare.pixel : |
| 252 | win->blacksquare.pixel), |
| 253 | GXcopy, AllPlanes); |
| 254 | tmpPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 255 | bits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 256 | XCopyPlane(win->display, tmpPM, win->boardwin, DefaultGC(win->display, 0), |
| 257 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 258 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 259 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 260 | XFreePixmap(win->display, tmpPM); |
| 261 | } |
| 262 | |
| 263 | if (!record_english) { |
| 264 | gc.foreground = win->textcolor.pixel; |
| 265 | if (iswhite(win, x, y) || win->bnw) |
| 266 | gc.background = win->whitesquare.pixel; |
| 267 | else |
| 268 | gc.background = win->blacksquare.pixel; |
| 269 | |
| 270 | gc.font = win->small->fid; |
| 271 | |
| 272 | XChangeGC(win->display, DefaultGC(win->display, 0), |
| 273 | GCForeground | GCBackground | GCFont, &gc); |
| 274 | |
| 275 | if (!x) { |
| 276 | sprintf(buf, " %d", SIZE - y); |
| 277 | XDrawImageString(win->display, win->boardwin, |
| 278 | DefaultGC(win->display, 0), |
| 279 | 1, (y + 1) * (SQUARE_HEIGHT + |
| 280 | BORDER_WIDTH) - BORDER_WIDTH + |
| 281 | win->small->max_bounds.ascent - 1, buf, 2); |
| 282 | } |
| 283 | if (y == SIZE - 1) { |
| 284 | sprintf(buf, "%c", 'A' + x); |
| 285 | XDrawImageString(win->display, win->boardwin, |
| 286 | DefaultGC(win->display, 0), |
| 287 | x * (SQUARE_WIDTH + BORDER_WIDTH) + 1, |
| 288 | SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH + |
| 289 | win->small->max_bounds.ascent - 1, buf, 1); |
| 290 | } |
| 291 | } |
| 292 | return; |
| 293 | } |
| 294 | |
| 295 | void |
| 296 | win_erasepiece(y, x, wnum) |
| 297 | int y, x; |
| 298 | color wnum; |
| 299 | { |
| 300 | windata *win; |
| 301 | char buf[BSIZE]; |
| 302 | XGCValues gc; |
| 303 | Pixmap tmpPM; |
| 304 | |
| 305 | if (oneboard || (wnum == win1->color)) |
| 306 | win = win1; |
| 307 | else |
| 308 | win = win2; |
| 309 | |
| 310 | if (win->flipped) { |
| 311 | y = SIZE - y - 1; |
| 312 | x = SIZE - x - 1; |
| 313 | } |
| 314 | |
| 315 | /* |
| 316 | if (debug) |
| 317 | fprintf(stderr, "erase square (%d, %d) on board %d\n", y, x, |
| 318 | wnum); |
| 319 | */ |
| 320 | |
| 321 | if ((x < 0) || (x > 7) || (y < 0) || (y > 7)) exit(1); |
| 322 | |
| 323 | if (win->bnw && !iswhite(win, x, y)) { |
| 324 | XSetState(win->display, DefaultGC(win->display, 0), |
| 325 | BlackPixel(win->display, 0), |
| 326 | WhitePixel(win->display, 0), GXcopy, AllPlanes); |
| 327 | tmpPM = XCreateBitmapFromData(win->display, win->boardwin, |
| 328 | shade_bits, SQUARE_WIDTH, SQUARE_HEIGHT); |
| 329 | |
| 330 | XCopyPlane(win->display, tmpPM, win->boardwin, DefaultGC(win->display, 0), |
| 331 | 0, 0, SQUARE_WIDTH, SQUARE_HEIGHT, |
| 332 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 333 | y * (SQUARE_HEIGHT + BORDER_WIDTH), 1); |
| 334 | |
| 335 | XFreePixmap(win->display, tmpPM); |
| 336 | } else { |
| 337 | XSetFillStyle(win->display, DefaultGC(win->display, 0), |
| 338 | FillSolid); |
| 339 | XSetForeground(win->display, DefaultGC(win->display, 0), |
| 340 | iswhite(win, x, y) ? win->whitesquare.pixel : |
| 341 | win->blacksquare.pixel); |
| 342 | XFillRectangle(win->display, win->boardwin, |
| 343 | DefaultGC(win->display, 0), |
| 344 | x * (SQUARE_WIDTH + BORDER_WIDTH), |
| 345 | y * (SQUARE_HEIGHT + BORDER_WIDTH), |
| 346 | SQUARE_WIDTH, SQUARE_HEIGHT); |
| 347 | } |
| 348 | |
| 349 | if (!record_english) { |
| 350 | gc.foreground = win->textcolor.pixel; |
| 351 | if (iswhite(win, x, y) || win->bnw) |
| 352 | gc.background = win->whitesquare.pixel; |
| 353 | else |
| 354 | gc.background = win->blacksquare.pixel; |
| 355 | |
| 356 | gc.font = win->small->fid; |
| 357 | |
| 358 | XChangeGC(win->display, DefaultGC(win->display, 0), |
| 359 | GCForeground | GCBackground | GCFont, &gc); |
| 360 | |
| 361 | if (!x) { |
| 362 | sprintf(buf, " %d", SIZE - y); |
| 363 | XDrawImageString(win->display, win->boardwin, |
| 364 | DefaultGC(win->display, 0), |
| 365 | 1, (y + 1) * (SQUARE_HEIGHT + |
| 366 | BORDER_WIDTH) - BORDER_WIDTH + |
| 367 | win->small->max_bounds.ascent - 1, buf, 2); |
| 368 | } |
| 369 | if (y == SIZE - 1) { |
| 370 | sprintf(buf, "%c", 'A' + x); |
| 371 | XDrawImageString(win->display, win->boardwin, |
| 372 | DefaultGC(win->display, 0), |
| 373 | x * (SQUARE_WIDTH + BORDER_WIDTH) + 1, |
| 374 | SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH + |
| 375 | win->small->max_bounds.ascent - 1, buf, 1); |
| 376 | } |
| 377 | } |
| 378 | |
| 379 | |
| 380 | return; |
| 381 | } |
| 382 | |
| 383 | void |
| 384 | win_flash(m, wnum) |
| 385 | move *m; |
| 386 | color wnum; |
| 387 | { |
| 388 | windata *win; |
| 389 | int sx, sy, ex, ey, i; |
| 390 | |
| 391 | if (oneboard || (wnum == win1->color)) |
| 392 | win = win1; |
| 393 | else |
| 394 | win = win2; |
| 395 | |
| 396 | if (win->flipped) { |
| 397 | sx = SIZE - m->fromx - 1; |
| 398 | sy = SIZE - m->fromy - 1; |
| 399 | ex = SIZE - m->tox - 1; |
| 400 | ey = SIZE - m->toy - 1; |
| 401 | } else { |
| 402 | sx = m->fromx; |
| 403 | sy = m->fromy; |
| 404 | ex = m->tox; |
| 405 | ey = m->toy; |
| 406 | } |
| 407 | sx = sx * (SQUARE_WIDTH + BORDER_WIDTH) + SQUARE_WIDTH / 2; |
| 408 | sy = sy * (SQUARE_HEIGHT + BORDER_WIDTH) + SQUARE_HEIGHT / 2; |
| 409 | ex = ex * (SQUARE_WIDTH + BORDER_WIDTH) + SQUARE_WIDTH / 2; |
| 410 | ey = ey * (SQUARE_HEIGHT + BORDER_WIDTH) + SQUARE_HEIGHT / 2; |
| 411 | |
| 412 | XSetFunction(win->display, DefaultGC(win->display, 0), GXinvert); |
| 413 | XSetLineAttributes(win->display, DefaultGC(win->display, 0), |
| 414 | 0, LineSolid, 0, 0); |
| 415 | for (i = 0; i < num_flashes * 2; i++) { |
| 416 | XDrawLine(win->display,win->boardwin, |
| 417 | DefaultGC(win->display, 0), |
| 418 | sx, sy, ex, ey); |
| 419 | } |
| 420 | |
| 421 | XSetFunction(win->display, DefaultGC(win->display, 0), GXcopy); |
| 422 | return; |
| 423 | } |
| 424 | |
| 425 | /* Handle input from the players. */ |
| 426 | |
| 427 | void |
| 428 | win_process(quick) |
| 429 | bool quick; |
| 430 | { |
| 431 | int i, rfd = 0, wfd = 0, xfd = 0; |
| 432 | struct timeval timeout; |
| 433 | |
| 434 | timeout.tv_sec = 0; |
| 435 | timeout.tv_usec = (quick ? 0 : 500000); |
| 436 | |
| 437 | if (XPending(win1->display)) |
| 438 | service(win1); |
| 439 | if (!oneboard) { |
| 440 | if (XPending(win1->display)) |
| 441 | service(win2); |
| 442 | } |
| 443 | |
| 444 | if (oneboard) |
| 445 | rfd = 1 << win1->display->fd; |
| 446 | else |
| 447 | rfd = (1 << win1->display->fd) | (1 << win2->display->fd); |
| 448 | if (!(i = select(32, &rfd, &wfd, &xfd, &timeout))) |
| 449 | return; |
| 450 | if (i == -1) { |
| 451 | perror("select"); |
| 452 | exit(1); |
| 453 | } |
| 454 | if (rfd & (1 << win1->display->fd)) |
| 455 | service(win1); |
| 456 | if (!oneboard && (rfd & (1 << win2->display->fd))) |
| 457 | service(win2); |
| 458 | |
| 459 | return; |
| 460 | } |
| 461 | |
| 462 | static void |
| 463 | service(win) |
| 464 | windata *win; |
| 465 | { |
| 466 | XEvent ev; |
| 467 | |
| 468 | while(XPending(win->display)) { |
| 469 | XNextEvent(win->display, &ev); |
| 470 | if (TxtFilter(win->display, &ev)) |
| 471 | continue; |
| 472 | |
| 473 | if (ev.xany.window == win->boardwin) { |
| 474 | switch (ev.type) { |
| 475 | case ButtonPress: |
| 476 | button_pressed(&ev, win); |
| 477 | break; |
| 478 | |
| 479 | case ButtonRelease: |
| 480 | button_released(&ev, win); |
| 481 | break; |
| 482 | |
| 483 | case Expose: |
| 484 | /* Redraw... */ |
| 485 | win_redraw(win, &ev); |
| 486 | break; |
| 487 | |
| 488 | case 0: |
| 489 | case NoExpose: |
| 490 | break; |
| 491 | default: |
| 492 | fprintf(stderr, "Bad event type %d\n", ev.type); |
| 493 | exit(1); |
| 494 | } |
| 495 | } else if (ev.xany.window == win->wclockwin) { |
| 496 | switch (ev.type) { |
| 497 | case Expose: |
| 498 | clock_draw(win, WHITE); |
| 499 | break; |
| 500 | |
| 501 | case 0: |
| 502 | case NoExpose: |
| 503 | break; |
| 504 | default: |
| 505 | fprintf(stderr, "Bad event type %d\n", ev.type); |
| 506 | exit(1); |
| 507 | } |
| 508 | } else if (ev.xany.window == win->bclockwin) { |
| 509 | switch (ev.type) { |
| 510 | case Expose: |
| 511 | clock_draw(win, BLACK); |
| 512 | break; |
| 513 | |
| 514 | case 0: |
| 515 | case NoExpose: |
| 516 | break; |
| 517 | default: |
| 518 | fprintf(stderr, "Bad event type %d\n", ev.type); |
| 519 | exit(1); |
| 520 | } |
| 521 | } else if (ev.xany.window == win->jailwin) { |
| 522 | switch (ev.type) { |
| 523 | case Expose: |
| 524 | jail_draw(win); |
| 525 | break; |
| 526 | |
| 527 | case 0: |
| 528 | case NoExpose: |
| 529 | break; |
| 530 | default: |
| 531 | fprintf(stderr, "Bad event type %d\n", ev.type); |
| 532 | exit(1); |
| 533 | } |
| 534 | } else if (ev.xany.window == win->buttonwin) { |
| 535 | switch (ev.type) { |
| 536 | case ButtonPress: |
| 537 | button_service(win, &ev); |
| 538 | break; |
| 539 | |
| 540 | case Expose: |
| 541 | button_draw(win); |
| 542 | break; |
| 543 | |
| 544 | case 0: |
| 545 | case NoExpose: |
| 546 | break; |
| 547 | default: |
| 548 | fprintf(stderr, "Bad event type %d\n", ev.type); |
| 549 | exit(1); |
| 550 | } |
| 551 | } else if (ev.xany.window == win->icon) { |
| 552 | icon_refresh(win); |
| 553 | } else if (ev.xany.window == win->basewin) { |
| 554 | message_send(win, &ev); |
| 555 | } else { |
| 556 | fprintf(stderr, "Internal Error: service: bad win\n"); |
| 557 | fprintf(stderr, "window = %d, event = %d\n", ev.xany.window, |
| 558 | ev.type); |
| 559 | } |
| 560 | } |
| 561 | return; |
| 562 | } |
| 563 | |
| 564 | void |
| 565 | win_redraw(win, event) |
| 566 | windata *win; |
| 567 | XEvent *event; |
| 568 | { |
| 569 | XExposeEvent *ev = &event->xexpose; |
| 570 | int x1, y1, x2, y2, i, j; |
| 571 | |
| 572 | drawgrid(win); |
| 573 | if (ev) { |
| 574 | x1 = ev->x / (SQUARE_WIDTH + BORDER_WIDTH); |
| 575 | y1 = ev->y / (SQUARE_HEIGHT + BORDER_WIDTH); |
| 576 | x2 = (ev->x + ev->width) / (SQUARE_WIDTH + BORDER_WIDTH); |
| 577 | y2 = (ev->y + ev->height) / (SQUARE_HEIGHT + BORDER_WIDTH); |
| 578 | } else { |
| 579 | x1 = 0; |
| 580 | y1 = 0; |
| 581 | x2 = SIZE - 1; |
| 582 | y2 = SIZE - 1; |
| 583 | } |
| 584 | |
| 585 | if (x1 < 0) x1 = 0; |
| 586 | if (y1 < 0) y1 = 0; |
| 587 | if (x2 < 0) x2 = 0; |
| 588 | if (y2 < 0) y2 = 0; |
| 589 | if (x1 > SIZE - 1) x1 = SIZE - 1; |
| 590 | if (y1 > SIZE - 1) y1 = SIZE - 1; |
| 591 | if (x2 > SIZE - 1) x2 = SIZE - 1; |
| 592 | if (y2 > SIZE - 1) y2 = SIZE - 1; |
| 593 | |
| 594 | if (win->flipped) { |
| 595 | y1 = SIZE - y2 - 1; |
| 596 | y2 = SIZE - y1 - 1; |
| 597 | x1 = SIZE - x2 - 1; |
| 598 | x2 = SIZE - x1 - 1; |
| 599 | } |
| 600 | |
| 601 | for (i = x1; i <= x2; i++) |
| 602 | for (j = y1; j <= y2; j++) { |
| 603 | if (chessboard->square[j][i].color == NONE) |
| 604 | win_erasepiece(j, i, WHITE); |
| 605 | else |
| 606 | win_drawpiece(&chessboard->square[j][i], j, i, |
| 607 | WHITE); |
| 608 | if (!oneboard) { |
| 609 | if (chessboard->square[j][i].color == NONE) |
| 610 | win_erasepiece(j, i, BLACK); |
| 611 | else |
| 612 | win_drawpiece(&chessboard->square[j][i], |
| 613 | j, i, BLACK); |
| 614 | } |
| 615 | } |
| 616 | |
| 617 | return; |
| 618 | } |
| 619 | |
| 620 | static bool |
| 621 | setup(dispname, win) |
| 622 | char *dispname; |
| 623 | windata *win; |
| 624 | { |
| 625 | char buf[BSIZE], *s; |
| 626 | Pixmap bm, bmask; |
| 627 | Cursor cur; |
| 628 | extern char *program, *recfile; |
| 629 | XSizeHints xsizes; |
| 630 | |
| 631 | |
| 632 | if (!(win->display = XOpenDisplay(dispname))) |
| 633 | return (false); |
| 634 | |
| 635 | |
| 636 | /* Now get boolean defaults... */ |
| 637 | if ((s = XGetDefault(win->display, program, "noisy")) && eq(s, "on")) |
| 638 | noisyflag = true; |
| 639 | if ((s = XGetDefault(win->display, program, "savemoves")) && eq(s, "on")) |
| 640 | saveflag = true; |
| 641 | if ((s = XGetDefault(win->display, program, "algebraic")) && eq(s, "on")) |
| 642 | record_english = false; |
| 643 | if ((s = XGetDefault(win->display, program, "blackandwhite")) && eq(s, "on")) |
| 644 | bnwflag = true; |
| 645 | if ((s = XGetDefault(win->display, program, "quickrestore")) && eq(s, "on")) |
| 646 | quickflag = true; |
| 647 | if ((s = XGetDefault(win->display, program, "flash")) && eq(s, "on")) |
| 648 | win_flashmove = true; |
| 649 | |
| 650 | /* ... numeric variables ... */ |
| 651 | if (s = XGetDefault(win->display, program, "numflashes")) |
| 652 | num_flashes = atoi(s); |
| 653 | if (s = XGetDefault(win->display, program, "flashsize")) |
| 654 | flash_size = atoi(s); |
| 655 | |
| 656 | /* ... and strings. */ |
| 657 | if (s = XGetDefault(win->display, program, "progname")) |
| 658 | progname = s; |
| 659 | if (s = XGetDefault(win->display, program, "proghost")) |
| 660 | proghost = s; |
| 661 | if (s = XGetDefault(win->display, program, "recordfile")) |
| 662 | recfile = s; |
| 663 | if (s = XGetDefault(win->display, program, "blackpiece")) |
| 664 | black_piece_color = s; |
| 665 | if (s = XGetDefault(win->display, program, "whitepiece")) |
| 666 | white_piece_color = s; |
| 667 | if (s = XGetDefault(win->display, program, "blacksquare")) |
| 668 | black_square_color = s; |
| 669 | if (s = XGetDefault(win->display, program, "whitesquare")) |
| 670 | white_square_color = s; |
| 671 | if (s = XGetDefault(win->display, program, "bordercolor")) |
| 672 | border_color = s; |
| 673 | if (s = XGetDefault(win->display, program, "textcolor")) |
| 674 | text_color = s; |
| 675 | if (s = XGetDefault(win->display, program, "textback")) |
| 676 | text_back = s; |
| 677 | if (s = XGetDefault(win->display, program, "errortext")) |
| 678 | error_text = s; |
| 679 | if (s = XGetDefault(win->display, program, "playertext")) |
| 680 | player_text = s; |
| 681 | if (s = XGetDefault(win->display, program, "cursorcolor")) |
| 682 | cursor_color = s; |
| 683 | |
| 684 | if ((DisplayPlanes(win->display, 0) == 1) || bnwflag) |
| 685 | win->bnw = true; |
| 686 | |
| 687 | /* Allocate colors... */ |
| 688 | if (win->bnw) { |
| 689 | win->blackpiece.pixel = BlackPixel (win->display, 0); |
| 690 | win->whitepiece.pixel = WhitePixel (win->display, 0); |
| 691 | win->blacksquare.pixel = BlackPixel (win->display, 0); |
| 692 | win->whitesquare.pixel = WhitePixel (win->display, 0); |
| 693 | win->border.pixel = BlackPixel (win->display, 0); |
| 694 | win->textcolor.pixel = BlackPixel (win->display, 0); |
| 695 | win->textback.pixel = WhitePixel (win->display, 0); |
| 696 | win->playertext.pixel = BlackPixel (win->display, 0); |
| 697 | win->errortext.pixel = BlackPixel (win->display, 0); |
| 698 | win->cursorcolor.pixel = BlackPixel (win->display, 0) ; |
| 699 | } else { |
| 700 | if (!XParseColor(win->display, |
| 701 | DefaultColormap(win->display, 0), |
| 702 | black_piece_color, &win->blackpiece) || |
| 703 | !XParseColor(win->display, |
| 704 | DefaultColormap(win->display, 0), |
| 705 | white_piece_color, &win->whitepiece) || |
| 706 | !XParseColor(win->display, |
| 707 | DefaultColormap(win->display, 0), |
| 708 | black_square_color, &win->blacksquare) || |
| 709 | !XParseColor(win->display, |
| 710 | DefaultColormap(win->display, 0), |
| 711 | white_square_color, &win->whitesquare) || |
| 712 | !XParseColor(win->display, |
| 713 | DefaultColormap(win->display, 0), |
| 714 | border_color, &win->border) || |
| 715 | !XParseColor(win->display, |
| 716 | DefaultColormap(win->display, 0), |
| 717 | text_color, &win->textcolor) || |
| 718 | !XParseColor(win->display, |
| 719 | DefaultColormap(win->display, 0), |
| 720 | text_back, &win->textback) || |
| 721 | !XParseColor(win->display, |
| 722 | DefaultColormap(win->display, 0), |
| 723 | error_text, &win->errortext) || |
| 724 | !XParseColor(win->display, |
| 725 | DefaultColormap(win->display, 0), |
| 726 | player_text, &win->playertext) || |
| 727 | !XParseColor(win->display, |
| 728 | DefaultColormap(win->display, 0), |
| 729 | cursor_color, &win->cursorcolor) || |
| 730 | !XAllocColor(win->display, |
| 731 | DefaultColormap(win->display, 0), |
| 732 | &win->blackpiece) || |
| 733 | !XAllocColor(win->display, |
| 734 | DefaultColormap(win->display, 0), |
| 735 | &win->whitepiece) || |
| 736 | !XAllocColor(win->display, |
| 737 | DefaultColormap(win->display, 0), |
| 738 | &win->blacksquare) || |
| 739 | !XAllocColor(win->display, |
| 740 | DefaultColormap(win->display, 0), |
| 741 | &win->whitesquare) || |
| 742 | !XAllocColor(win->display, |
| 743 | DefaultColormap(win->display, 0), |
| 744 | &win->border) || |
| 745 | !XAllocColor(win->display, |
| 746 | DefaultColormap(win->display, 0), |
| 747 | &win->textcolor) || |
| 748 | !XAllocColor(win->display, |
| 749 | DefaultColormap(win->display, 0), |
| 750 | &win->textback) || |
| 751 | !XAllocColor(win->display, |
| 752 | DefaultColormap(win->display, 0), |
| 753 | &win->errortext) || |
| 754 | !XAllocColor(win->display, |
| 755 | DefaultColormap(win->display, 0), |
| 756 | &win->playertext) || |
| 757 | !XAllocColor(win->display, |
| 758 | DefaultColormap(win->display, 0), |
| 759 | &win->cursorcolor)) |
| 760 | fprintf(stderr, "Can't get colors...\n"); |
| 761 | } |
| 762 | |
| 763 | /* Get fonts... */ |
| 764 | if ((win->small = XLoadQueryFont(win->display,SMALL_FONT)) == |
| 765 | NULL) |
| 766 | fprintf(stderr, "Can't get small font...\n"); |
| 767 | |
| 768 | if ((win->medium = XLoadQueryFont(win->display,MEDIUM_FONT)) |
| 769 | == NULL) |
| 770 | fprintf(stderr, "Can't get medium font...\n"); |
| 771 | |
| 772 | if ((win->large = XLoadQueryFont(win->display,LARGE_FONT)) == |
| 773 | NULL) |
| 774 | fprintf(stderr, "Can't get large font...\n"); |
| 775 | |
| 776 | |
| 777 | /* Create the windows... */ |
| 778 | |
| 779 | win->basewin = |
| 780 | XCreateSimpleWindow(win->display,DefaultRootWindow(win->display), |
| 781 | BASE_XPOS, BASE_YPOS, |
| 782 | BASE_WIDTH, BASE_HEIGHT, 0, |
| 783 | BlackPixel(win->display, 0), |
| 784 | WhitePixel(win->display, 0)); |
| 785 | win->boardwin = XCreateSimpleWindow(win->display,win->basewin, |
| 786 | BOARD_XPOS, BOARD_YPOS, |
| 787 | BOARD_WIDTH, BOARD_HEIGHT, |
| 788 | BORDER_WIDTH, |
| 789 | win->border.pixel, |
| 790 | WhitePixel(win->display, 0)); |
| 791 | win->recwin = XCreateSimpleWindow(win->display,win->basewin, |
| 792 | RECORD_XPOS, RECORD_YPOS, |
| 793 | RECORD_WIDTH, RECORD_HEIGHT, |
| 794 | BORDER_WIDTH, win->border.pixel, |
| 795 | win->textback.pixel); |
| 796 | win->jailwin = XCreateSimpleWindow(win->display,win->basewin, |
| 797 | JAIL_XPOS, JAIL_YPOS, |
| 798 | JAIL_WIDTH, JAIL_HEIGHT, |
| 799 | BORDER_WIDTH, |
| 800 | win->border.pixel, |
| 801 | win->textback.pixel); |
| 802 | win->wclockwin = XCreateSimpleWindow(win->display,win->basewin, |
| 803 | WCLOCK_XPOS, WCLOCK_YPOS, |
| 804 | CLOCK_WIDTH, CLOCK_HEIGHT, |
| 805 | BORDER_WIDTH, win->border.pixel, |
| 806 | win->textback.pixel); |
| 807 | win->bclockwin = XCreateSimpleWindow(win->display,win->basewin, |
| 808 | BCLOCK_XPOS, BCLOCK_YPOS, |
| 809 | CLOCK_WIDTH, CLOCK_HEIGHT, |
| 810 | BORDER_WIDTH, win->border.pixel, |
| 811 | win->textback.pixel); |
| 812 | win->messagewin = XCreateSimpleWindow(win->display,win->basewin, |
| 813 | MESS_XPOS, MESS_YPOS, |
| 814 | MESS_WIDTH, MESS_HEIGHT, |
| 815 | BORDER_WIDTH, win->border.pixel, |
| 816 | win->textback.pixel); |
| 817 | win->buttonwin = XCreateSimpleWindow(win->display,win->basewin, |
| 818 | BUTTON_XPOS, BUTTON_YPOS, |
| 819 | BUTTON_WIDTH, BUTTON_HEIGHT, |
| 820 | BORDER_WIDTH, win->border.pixel, |
| 821 | win->textback.pixel); |
| 822 | |
| 823 | /* Let's define an icon... */ |
| 824 | win->iconpixmap = XCreatePixmapFromBitmapData(win->display, |
| 825 | win->basewin, icon_bits, |
| 826 | icon_width, icon_height, |
| 827 | win->blacksquare.pixel, |
| 828 | win->whitesquare.pixel, |
| 829 | 1); |
| 830 | xsizes.flags = PSize | PMinSize | PPosition; |
| 831 | xsizes.min_width = BASE_WIDTH; |
| 832 | xsizes.min_height = BASE_HEIGHT; |
| 833 | xsizes.x = BASE_XPOS; |
| 834 | xsizes.y = BASE_YPOS; |
| 835 | XSetStandardProperties(win->display, win->basewin, |
| 836 | program, program, win->iconpixmap, |
| 837 | 0, NULL, &xsizes); |
| 838 | |
| 839 | bm = XCreateBitmapFromData(win->display, |
| 840 | win->basewin, xchess_bits, |
| 841 | xchess_width, xchess_height); |
| 842 | bmask = XCreateBitmapFromData(win->display, |
| 843 | win->basewin, xchess_mask_bits, |
| 844 | xchess_width, xchess_height); |
| 845 | cur = XCreatePixmapCursor(win->display, bm, bmask, |
| 846 | &win->cursorcolor, |
| 847 | &WhitePixel(win->display, 0), |
| 848 | xchess_x_hot, xchess_y_hot); |
| 849 | XFreePixmap(win->display, bm); |
| 850 | XFreePixmap(win->display, bmask); |
| 851 | |
| 852 | XDefineCursor(win->display,win->basewin, cur); |
| 853 | |
| 854 | XMapSubwindows(win->display,win->basewin); |
| 855 | XMapRaised(win->display,win->basewin); |
| 856 | |
| 857 | XSelectInput(win->display,win->basewin, KeyPressMask); |
| 858 | XSelectInput(win->display,win->boardwin, |
| 859 | ButtonPressMask | ButtonReleaseMask | ExposureMask); |
| 860 | XSelectInput(win->display,win->recwin, |
| 861 | ButtonReleaseMask | ExposureMask); |
| 862 | XSelectInput(win->display,win->jailwin, ExposureMask); |
| 863 | XSelectInput(win->display,win->wclockwin, ExposureMask); |
| 864 | XSelectInput(win->display,win->bclockwin, ExposureMask); |
| 865 | XSelectInput(win->display,win->messagewin, |
| 866 | ButtonReleaseMask | ExposureMask); |
| 867 | XSelectInput(win->display,win->buttonwin, |
| 868 | ButtonPressMask | ExposureMask); |
| 869 | |
| 870 | message_init(win); |
| 871 | record_init(win); |
| 872 | button_draw(win); |
| 873 | jail_init(win); |
| 874 | clock_init(win, WHITE); |
| 875 | clock_init(win, BLACK); |
| 876 | if (timeunit) { |
| 877 | if (timeunit > 1800) |
| 878 | sprintf(buf, "%d moves every %.2lg hours.\n", |
| 879 | movesperunit, ((double) timeunit) / 3600); |
| 880 | else if (timeunit > 30) |
| 881 | sprintf(buf, "%d moves every %.2lg minutes.\n", |
| 882 | movesperunit, ((double) timeunit) / 60); |
| 883 | else |
| 884 | sprintf(buf, "%d moves every %d seconds.\n", |
| 885 | movesperunit, timeunit); |
| 886 | message_add(win, buf, false); |
| 887 | } |
| 888 | return (true); |
| 889 | } |
| 890 | |
| 891 | static void |
| 892 | drawgrid(win) |
| 893 | windata *win; |
| 894 | { |
| 895 | int i; |
| 896 | XGCValues gc; |
| 897 | |
| 898 | gc.function = GXcopy; |
| 899 | gc.plane_mask = AllPlanes; |
| 900 | gc.foreground = win->border.pixel; |
| 901 | gc.line_width = 0; |
| 902 | gc.line_style = LineSolid; |
| 903 | |
| 904 | XChangeGC(win->display, |
| 905 | DefaultGC(win->display, 0), |
| 906 | GCFunction | GCPlaneMask | GCForeground | |
| 907 | GCLineWidth | GCLineStyle, &gc); |
| 908 | |
| 909 | /* Draw the lines... horizontal, */ |
| 910 | for (i = 1; i < SIZE; i++) |
| 911 | XDrawLine(win->display, win->boardwin, |
| 912 | DefaultGC(win->display, 0), 0, |
| 913 | i * (SQUARE_WIDTH + BORDER_WIDTH) - |
| 914 | BORDER_WIDTH / 2, |
| 915 | SIZE * (SQUARE_WIDTH + BORDER_WIDTH), |
| 916 | i * (SQUARE_WIDTH + BORDER_WIDTH) - |
| 917 | BORDER_WIDTH / 2); |
| 918 | |
| 919 | /* and vertical... */ |
| 920 | for (i = 1; i < SIZE; i++) |
| 921 | XDrawLine(win->display, win->boardwin, |
| 922 | DefaultGC(win->display, 0), |
| 923 | i * (SQUARE_WIDTH + BORDER_WIDTH) - |
| 924 | BORDER_WIDTH / 2, 0, |
| 925 | i * (SQUARE_WIDTH + BORDER_WIDTH) - |
| 926 | BORDER_WIDTH / 2, |
| 927 | SIZE * (SQUARE_WIDTH + BORDER_WIDTH)); |
| 928 | return; |
| 929 | } |
| 930 | |
| 931 | void |
| 932 | win_restart() |
| 933 | { |
| 934 | win1->flipped = false; |
| 935 | win_redraw(win1, (XEvent *) NULL); |
| 936 | if (!oneboard) { |
| 937 | win2->flipped = true; |
| 938 | win_redraw(win2, (XEvent *) NULL); |
| 939 | } |
| 940 | return; |
| 941 | } |
| 942 | |
| 943 | static void |
| 944 | icon_refresh(win) |
| 945 | windata *win; |
| 946 | { |
| 947 | XCopyArea(win->display, win->iconpixmap, win->icon, |
| 948 | DefaultGC(win->display, 0), |
| 949 | 0, 0, icon_width, icon_height, 0, 0); |
| 950 | return; |
| 951 | } |
| 952 | |