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