[unix-history] / gnu / games / chess / Xchess / button.c


/* This file contains code for X-CHESS.
   Copyright (C) 1986 Free Software Foundation, Inc.

This file is part of X-CHESS.

X-CHESS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.  No author or distributor
accepts responsibility to anyone for the consequences of using it
or for whether it serves any particular purpose or works at all,
unless he says so in writing.  Refer to the X-CHESS General Public
License for full details.

Everyone is granted permission to copy, modify and redistribute
X-CHESS, but only under the conditions described in the
X-CHESS General Public License.   A copy of this license is
supposed to have been given to you along with X-CHESS so you
can know your rights and responsibilities.  It should be in a
file named COPYING.  Among other things, the copyright notice
and this notice must be preserved on all copies.  */


/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/26 12:09:41 $
 *           $Source: /users/faustus/xchess/RCS/button.c,v $
 * Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
 *	Permission is granted to do anything with this code except sell it
 *	or remove this message.
 *
 * Do stuff with the buttons.
 * The configuration we're using is:	Draw	Back	Pause
 *					Resign	Fwd	Flip
 *					Reset	Save	Easy (Switch)
 */

#include "xchess.h"

typedef enum choice { NOCHOICE, DRAW, RESIGN, REPLAY, SWITCH, FORE, SAVE,
		STOP, FLIP, RESTART, EASY } choice;

static struct but {
	char *label;
	int x, y;
	int width, height;
	choice which;
} buts[] = {
	{ "Draw", 0, 20, 108, 29, DRAW } ,
	{ "Back", 109, 20, 108, 29, REPLAY } ,
	{ "Pause", 219, 20, 108, 29, STOP } ,
	{ "Resign", 0, 50, 108, 29, RESIGN } ,
	{ "Fwd", 109, 50, 108, 29, FORE } ,
	{ "Flip", 219, 50, 108, 29, FLIP } ,
	{ "Reset", 0, 80, 108, 29, RESTART } ,
	{ "Save", 109, 80, 108, 29, SAVE } ,
#define EASY_OFFSET 8
	{ "Switch", 219, 80, 108, 29, SWITCH } 
/*	{ "NoEasy", 219, 80, 108, 29, EASY }*/
} ;
static int easy = 1;

void
button_draw(win)
	windata *win;
{
	int i, x, numbuts = sizeof (buts) / sizeof (struct but);

	XSetState(win->display, DefaultGC(win->display, 0),
		  win->border.pixel, WhitePixel(win->display, 0),
		  GXcopy, AllPlanes);
	XSetLineAttributes(win->display, DefaultGC(win->display, 0),
			   BORDER_WIDTH, LineSolid, CapButt,
			   JoinMiter);
	
	XDrawLine(win->display, win->buttonwin,
		  DefaultGC(win->display, 0),
		  0, 29, BUTTON_WIDTH, 29);
	XDrawLine(win->display, win->buttonwin,
		  DefaultGC(win->display, 0),
		  0, 60, BUTTON_WIDTH, 60);
	XDrawLine(win->display, win->buttonwin,
		  DefaultGC(win->display, 0),
		  108, 0, 108, BUTTON_HEIGHT);
	XDrawLine(win->display, win->buttonwin,
		  DefaultGC(win->display, 0),
		  219, 0, 219, BUTTON_HEIGHT);

	XSetFont(win->display, DefaultGC(win->display, 0), win->large->fid);
	XSetForeground(win->display, DefaultGC(win->display, 0),
		       win->textcolor.pixel); 
	XSetBackground(win->display, DefaultGC(win->display, 0),
		       win->textback.pixel); 

	for (i = 0; i < numbuts; i++) {
		x = (buts[i].width -
		     XTextWidth(win->large, buts[i].label,
				strlen(buts[i].label))) / 2;

		XDrawImageString(win->display, win->buttonwin,
				 DefaultGC(win->display, 0),
				 buts[i].x + x, buts[i].y, buts[i].label,
				 strlen(buts[i].label));
	}
	return;
}

void
button_service(win, event)
	windata *win;
	XEvent *event;
{
	XKeyEvent *ev = &event->xkey;
	choice c;
	int i, numbuts = sizeof (buts) / sizeof (struct but);
	char *s;

	ev->y += 15;
	for (i = 0; i < numbuts; i++)
		if ((ev->x >= buts[i].x) && (ev->x <= buts[i].x +
				buts[i].width) && (ev->y >= buts[i].y) &&
				(ev->y <= buts[i].y + buts[i].height)) {
			c = buts[i].which;
			break;
		}
	if ((i == numbuts) || (c == NOCHOICE)) {
		message_add(win, "Bad choice.\n", true);
		return;
	}

	if (loading_flag && (c != STOP)) {
		message_add(win, "You can only use PAUSE now\n", true);
		return;
	}

	switch (c) {
	    case DRAW:
		if (!oneboard) {
			message_add(win, "Just a sec...\n", false);
			if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto call the game a draw.\nDo you agree?\n")) {
				message_add(win,
				"The other player declines the draw\n", false);
				return;
			}
		}
		message_add(win1, "Draw agreed.\n", false);
		if (!oneboard)
			message_add(win2, "Draw agreed.\n", false);
		cleanup("Draw agreed.");
		break;

	    case RESIGN:
		if (!pop_question(win, "Are you sure\nyou want to resign?"))
			return;
		if ((oneboard && !progflag) || (nexttomove == win->color)) {
			if (nexttomove == WHITE)
				s = "White resigns.";
			else
				s = "Black resigns.";
			if (oneboard) {
				message_add(win, s, false);
				message_add(win, "\n", false);
			} else {
				message_add(win1, s, false);
				message_add(win, "\n", false);
				message_add(win2, s, false);
				message_add(win, "\n", false);
			}
			sleep(5);
			cleanup(s);
		} else {
			message_add(win, "It's not your turn.\n", true);
		}
		break;

	    case REPLAY:
		if (!oneboard) {
			message_add(win, "Just a sec...\n", false);
			if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto take back his last move.\nDo you let him?\n")) {
				message_add(win,
				"The other player refuses...\n", false);
				return;
			}
		}
		if (!moves) {
			message_add(win, "Can't back up...\n", true);
			break;
		}
		message_add(win1, "Replaying...\n", false);
		if (!oneboard)
			message_add(win2, "Replaying...\n", false);
		replay();
		if (progflag)
		    replay();
		break;

	    case FORE:
		if (!oneboard) {
			message_add(win, "Just a sec...\n", false);
			if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto do a 'fore'.\nIs that ok with you?\n")) {
				message_add(win,
				"The other player refuses...\n", false);
				return;
			}
		}
		if (!foremoves) {
			message_add(win, "Can't go forward...\n", true);
			break;
		}
		message_add(win1, "Moving forward...\n", false);
		if (!oneboard)
			message_add(win2, "Moving forward...\n", false);
		forward();
		break;

	    case SWITCH:
		message_add(win, "You can't switch yet.\n", false);
		break;

	    case SAVE:
		if (saveflag) {
			message_add(win, 
				"Game is already being logged in file '", true);
			message_add(win, record_file, true);
			message_add(win, "'.\n", true);
		} else {
			message_add(win, "Saving game to file '", false);
			message_add(win, record_file, false);
			message_add(win, "'.\n", false);
			record_save();
		}
		break;

	    case STOP:
		if (loading_flag) {
			loading_paused = (loading_paused ? false : true);
			message_add(win, loading_paused ?
				"Stopped.\nHit 'Pause' again to restart.\n" :
				"Restarted.\n", false);
		} else if (clock_started) {
			if (!oneboard) {
				message_add(win, "Just a sec...\n", false);
				if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto stop the clock.\nDo you let him?\n")) {
					message_add(win,
					"The other player refuses to pause.\n",
					false);
					return;
				}
			}
			message_add(win1, 
			"Clock stopped.\nHit 'Pause' again to restart.\n",
					false);
			if (!oneboard)
				message_add(win2, 
			"Clock stopped.\nHit 'Pause' again to restart.\n", 
					false);
			clock_started = false;
		} else {
			if (!oneboard) {
				message_add(win, "Just a sec...\n", false);
				if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto start the clock again.\nIs that ok?\n")) {
					message_add(win,
				"The other player refuses to resume.\n",
					false);
					return;
				}
			}
			message_add(win1, "Clock restarted.\n", false);
			if (!oneboard)
				message_add(win2, "Clock restarted.\n", false);
			clock_started = true;
		}
		break;

	    case FLIP:
		message_add(win, "Flipping window...\n", false);
		win->flipped = win->flipped ? false : true;
		win_redraw(win, (XEvent *) NULL);
		break;

	    case RESTART:
		if (!oneboard) {
			message_add(win, "Just a sec...\n", false);
			if (!pop_question(((win == win1) ? win2 : win1),
"The other player wants\nto restart the game.\nDo you agree?\n")) {
				message_add(win,
				"The other player refuses to reset\n", false);
				return;
			}
		}
		message_add(win, "Restarting game.\n", false);
		restart();
		break;
	    case EASY:
		if (oneboard) {
			int x;
			if (easy)
				 easy = 0;
			else
				easy = 1;

			if (easy)
				buts[EASY_OFFSET].label = " Easy ";
			else
				buts[EASY_OFFSET].label = "NoEasy";

			program_easy(easy);

			x = (buts[EASY_OFFSET].width -
				   XTextWidth(win->large,
					 buts[EASY_OFFSET].label,
					 strlen(buts[EASY_OFFSET].label))) / 2;

			XSetFont(win->display, DefaultGC(win->display,
							 0), win->large->fid);
			XSetForeground(win->display,
				       DefaultGC(win->display, 0),
				       win->textcolor.pixel);
			XSetBackground(win->display,
				       DefaultGC(win->display, 0),
				       win->textback.pixel); 

			XDrawImageString(win->display,
					 win->buttonwin,
					 DefaultGC(win->display, 0),
					 buts[EASY_OFFSET].x + x,
					 buts[EASY_OFFSET].y,
					 buts[EASY_OFFSET].label,
					 strlen(buts[EASY_OFFSET].label));
		}
		break;
	}
	return;
}
Commit	Line	Data
15637ed4 RG	1
	2	/* This file contains code for X-CHESS.
	3	Copyright (C) 1986 Free Software Foundation, Inc.
	4
	5	This file is part of X-CHESS.
	6
	7	X-CHESS is distributed in the hope that it will be useful,
	8	but WITHOUT ANY WARRANTY. No author or distributor
	9	accepts responsibility to anyone for the consequences of using it
	10	or for whether it serves any particular purpose or works at all,
	11	unless he says so in writing. Refer to the X-CHESS General Public
	12	License for full details.
	13
	14	Everyone is granted permission to copy, modify and redistribute
	15	X-CHESS, but only under the conditions described in the
	16	X-CHESS General Public License. A copy of this license is
	17	supposed to have been given to you along with X-CHESS so you
	18	can know your rights and responsibilities. It should be in a
	19	file named COPYING. Among other things, the copyright notice
	20	and this notice must be preserved on all copies. */
	21
	22
	23	/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/26 12:09:41 $
	24	* $Source: /users/faustus/xchess/RCS/button.c,v $
	25	* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
	26	* Permission is granted to do anything with this code except sell it
	27	* or remove this message.
	28	*
	29	* Do stuff with the buttons.
	30	* The configuration we're using is: Draw Back Pause
	31	* Resign Fwd Flip
	32	* Reset Save Easy (Switch)
	33	*/
	34
	35	#include "xchess.h"
	36
	37	typedef enum choice { NOCHOICE, DRAW, RESIGN, REPLAY, SWITCH, FORE, SAVE,
	38	STOP, FLIP, RESTART, EASY } choice;
	39
	40	static struct but {
	41	char *label;
	42	int x, y;
	43	int width, height;
	44	choice which;
	45	} buts[] = {
	46	{ "Draw", 0, 20, 108, 29, DRAW } ,
	47	{ "Back", 109, 20, 108, 29, REPLAY } ,
	48	{ "Pause", 219, 20, 108, 29, STOP } ,
	49	{ "Resign", 0, 50, 108, 29, RESIGN } ,
	50	{ "Fwd", 109, 50, 108, 29, FORE } ,
	51	{ "Flip", 219, 50, 108, 29, FLIP } ,
	52	{ "Reset", 0, 80, 108, 29, RESTART } ,
	53	{ "Save", 109, 80, 108, 29, SAVE } ,
	54	#define EASY_OFFSET 8
	55	{ "Switch", 219, 80, 108, 29, SWITCH }
	56	/* { "NoEasy", 219, 80, 108, 29, EASY }*/
	57	} ;
	58	static int easy = 1;
	59
	60	void
	61	button_draw(win)
	62	windata *win;
	63	{
	64	int i, x, numbuts = sizeof (buts) / sizeof (struct but);
65
66	XSetState(win->display, DefaultGC(win->display, 0),
67	win->border.pixel, WhitePixel(win->display, 0),
68	GXcopy, AllPlanes);
69	XSetLineAttributes(win->display, DefaultGC(win->display, 0),
70	BORDER_WIDTH, LineSolid, CapButt,
71	JoinMiter);
72
73	XDrawLine(win->display, win->buttonwin,
74	DefaultGC(win->display, 0),
75	0, 29, BUTTON_WIDTH, 29);
76	XDrawLine(win->display, win->buttonwin,
77	DefaultGC(win->display, 0),
78	0, 60, BUTTON_WIDTH, 60);
79	XDrawLine(win->display, win->buttonwin,
80	DefaultGC(win->display, 0),
81	108, 0, 108, BUTTON_HEIGHT);
82	XDrawLine(win->display, win->buttonwin,
83	DefaultGC(win->display, 0),
84	219, 0, 219, BUTTON_HEIGHT);
85
86	XSetFont(win->display, DefaultGC(win->display, 0), win->large->fid);
87	XSetForeground(win->display, DefaultGC(win->display, 0),
88	win->textcolor.pixel);
89	XSetBackground(win->display, DefaultGC(win->display, 0),
90	win->textback.pixel);
91
92	for (i = 0; i < numbuts; i++) {
93	x = (buts[i].width -
94	XTextWidth(win->large, buts[i].label,
95	strlen(buts[i].label))) / 2;
96
97	XDrawImageString(win->display, win->buttonwin,
98	DefaultGC(win->display, 0),
99	buts[i].x + x, buts[i].y, buts[i].label,
100	strlen(buts[i].label));
101	}
102	return;
103	}
104
105	void
106	button_service(win, event)
107	windata *win;
108	XEvent *event;
109	{
110	XKeyEvent *ev = &event->xkey;
111	choice c;
112	int i, numbuts = sizeof (buts) / sizeof (struct but);
113	char *s;
114
115	ev->y += 15;
116	for (i = 0; i < numbuts; i++)
117	if ((ev->x >= buts[i].x) && (ev->x <= buts[i].x +
118	buts[i].width) && (ev->y >= buts[i].y) &&
119	(ev->y <= buts[i].y + buts[i].height)) {
120	c = buts[i].which;
121	break;
122	}
123	if ((i == numbuts) \|\| (c == NOCHOICE)) {
124	message_add(win, "Bad choice.\n", true);
125	return;
126	}
127
128	if (loading_flag && (c != STOP)) {
129	message_add(win, "You can only use PAUSE now\n", true);
130	return;
131	}
132
133	switch (c) {
134	case DRAW:
135	if (!oneboard) {
136	message_add(win, "Just a sec...\n", false);
137	if (!pop_question(((win == win1) ? win2 : win1),
138	"The other player wants\nto call the game a draw.\nDo you agree?\n")) {
139	message_add(win,
140	"The other player declines the draw\n", false);
141	return;
142	}
143	}
144	message_add(win1, "Draw agreed.\n", false);
145	if (!oneboard)
146	message_add(win2, "Draw agreed.\n", false);
147	cleanup("Draw agreed.");
148	break;
149
150	case RESIGN:
151	if (!pop_question(win, "Are you sure\nyou want to resign?"))
152	return;
153	if ((oneboard && !progflag) \|\| (nexttomove == win->color)) {
154	if (nexttomove == WHITE)
155	s = "White resigns.";
156	else
157	s = "Black resigns.";
158	if (oneboard) {
159	message_add(win, s, false);
160	message_add(win, "\n", false);
161	} else {
162	message_add(win1, s, false);
163	message_add(win, "\n", false);
164	message_add(win2, s, false);
165	message_add(win, "\n", false);
166	}
167	sleep(5);
168	cleanup(s);
169	} else {
170	message_add(win, "It's not your turn.\n", true);
171	}
172	break;
173
174	case REPLAY:
175	if (!oneboard) {
176	message_add(win, "Just a sec...\n", false);
177	if (!pop_question(((win == win1) ? win2 : win1),
178	"The other player wants\nto take back his last move.\nDo you let him?\n")) {
179	message_add(win,
180	"The other player refuses...\n", false);
181	return;
182	}
183	}
184	if (!moves) {
185	message_add(win, "Can't back up...\n", true);
186	break;
187	}
188	message_add(win1, "Replaying...\n", false);
189	if (!oneboard)
190	message_add(win2, "Replaying...\n", false);
191	replay();
192	if (progflag)
193	replay();
194	break;
195
196	case FORE:
197	if (!oneboard) {
198	message_add(win, "Just a sec...\n", false);
199	if (!pop_question(((win == win1) ? win2 : win1),
200	"The other player wants\nto do a 'fore'.\nIs that ok with you?\n")) {
201	message_add(win,
202	"The other player refuses...\n", false);
203	return;
204	}
205	}
206	if (!foremoves) {
207	message_add(win, "Can't go forward...\n", true);
208	break;
209	}
210	message_add(win1, "Moving forward...\n", false);
211	if (!oneboard)
212	message_add(win2, "Moving forward...\n", false);
213	forward();
214	break;
215
216	case SWITCH:
217	message_add(win, "You can't switch yet.\n", false);
218	break;
219
220	case SAVE:
221	if (saveflag) {
222	message_add(win,
223	"Game is already being logged in file '", true);
224	message_add(win, record_file, true);
225	message_add(win, "'.\n", true);
226	} else {
227	message_add(win, "Saving game to file '", false);
228	message_add(win, record_file, false);
229	message_add(win, "'.\n", false);
230	record_save();
231	}
232	break;
233
234	case STOP:
235	if (loading_flag) {
236	loading_paused = (loading_paused ? false : true);
237	message_add(win, loading_paused ?
238	"Stopped.\nHit 'Pause' again to restart.\n" :
239	"Restarted.\n", false);
240	} else if (clock_started) {
241	if (!oneboard) {
242	message_add(win, "Just a sec...\n", false);
243	if (!pop_question(((win == win1) ? win2 : win1),
244	"The other player wants\nto stop the clock.\nDo you let him?\n")) {
245	message_add(win,
246	"The other player refuses to pause.\n",
247	false);
248	return;
249	}
250	}
251	message_add(win1,
252	"Clock stopped.\nHit 'Pause' again to restart.\n",
253	false);
254	if (!oneboard)
255	message_add(win2,
256	"Clock stopped.\nHit 'Pause' again to restart.\n",
257	false);
258	clock_started = false;
259	} else {
260	if (!oneboard) {
261	message_add(win, "Just a sec...\n", false);
262	if (!pop_question(((win == win1) ? win2 : win1),
263	"The other player wants\nto start the clock again.\nIs that ok?\n")) {
264	message_add(win,
265	"The other player refuses to resume.\n",
266	false);
267	return;
268	}
269	}
270	message_add(win1, "Clock restarted.\n", false);
271	if (!oneboard)
272	message_add(win2, "Clock restarted.\n", false);
273	clock_started = true;
274	}
275	break;
276
277	case FLIP:
278	message_add(win, "Flipping window...\n", false);
279	win->flipped = win->flipped ? false : true;
280	win_redraw(win, (XEvent *) NULL);
281	break;
282
283	case RESTART:
284	if (!oneboard) {
285	message_add(win, "Just a sec...\n", false);
286	if (!pop_question(((win == win1) ? win2 : win1),
287	"The other player wants\nto restart the game.\nDo you agree?\n")) {
288	message_add(win,
289	"The other player refuses to reset\n", false);
290	return;
291	}
292	}
293	message_add(win, "Restarting game.\n", false);
294	restart();
295	break;
296	case EASY:
297	if (oneboard) {
298	int x;
299	if (easy)
300	easy = 0;
301	else
302	easy = 1;
303
304	if (easy)
305	buts[EASY_OFFSET].label = " Easy ";
306	else
307	buts[EASY_OFFSET].label = "NoEasy";
308
309	program_easy(easy);
310
311	x = (buts[EASY_OFFSET].width -
312	XTextWidth(win->large,
313	buts[EASY_OFFSET].label,
314	strlen(buts[EASY_OFFSET].label))) / 2;
315
316	XSetFont(win->display, DefaultGC(win->display,
317	0), win->large->fid);
318	XSetForeground(win->display,
319	DefaultGC(win->display, 0),
320	win->textcolor.pixel);
321	XSetBackground(win->display,
322	DefaultGC(win->display, 0),
323	win->textback.pixel);
324
325	XDrawImageString(win->display,
326	win->buttonwin,
327	DefaultGC(win->display, 0),
328	buts[EASY_OFFSET].x + x,
329	buts[EASY_OFFSET].y,
330	buts[EASY_OFFSET].label,
331	strlen(buts[EASY_OFFSET].label));
332	}
333	break;
334	}
335	return;
336	}
337