added firstOptions, secondOptions, noGUI, firstXBook, secondXBook
[xboard.git] / xboard.c
1 /*\r
2  * xboard.c -- X front end for XBoard\r
3  * $Id: xboard.c,v 2.2 2003/11/06 07:22:14 mann Exp $\r
4  *\r
5  * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.\r
6  * Enhancements Copyright 1992-2001 Free Software Foundation, Inc.\r
7  *\r
8  * The following terms apply to Digital Equipment Corporation's copyright\r
9  * interest in XBoard:\r
10  * ------------------------------------------------------------------------\r
11  * All Rights Reserved\r
12  *\r
13  * Permission to use, copy, modify, and distribute this software and its\r
14  * documentation for any purpose and without fee is hereby granted,\r
15  * provided that the above copyright notice appear in all copies and that\r
16  * both that copyright notice and this permission notice appear in\r
17  * supporting documentation, and that the name of Digital not be\r
18  * used in advertising or publicity pertaining to distribution of the\r
19  * software without specific, written prior permission.\r
20  *\r
21  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING\r
22  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL\r
23  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR\r
24  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\r
25  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,\r
26  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\r
27  * SOFTWARE.\r
28  * ------------------------------------------------------------------------\r
29  *\r
30  * The following terms apply to the enhanced version of XBoard distributed\r
31  * by the Free Software Foundation:\r
32  * ------------------------------------------------------------------------\r
33  * This program is free software; you can redistribute it and/or modify\r
34  * it under the terms of the GNU General Public License as published by\r
35  * the Free Software Foundation; either version 2 of the License, or\r
36  * (at your option) any later version.\r
37  *\r
38  * This program is distributed in the hope that it will be useful,\r
39  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
41  * GNU General Public License for more details.\r
42  *\r
43  * You should have received a copy of the GNU General Public License\r
44  * along with this program; if not, write to the Free Software\r
45  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\r
46  * ------------------------------------------------------------------------\r
47  *\r
48  * See the file ChangeLog for a revision history.\r
49  */\r
50 \r
51 #include "config.h"\r
52 \r
53 #include <stdio.h>\r
54 #include <ctype.h>\r
55 #include <signal.h>\r
56 #include <errno.h>\r
57 #include <sys/types.h>\r
58 #include <sys/stat.h>\r
59 #include <pwd.h>\r
60 \r
61 #if !OMIT_SOCKETS\r
62 # if HAVE_SYS_SOCKET_H\r
63 #  include <sys/socket.h>\r
64 #  include <netinet/in.h>\r
65 #  include <netdb.h>\r
66 # else /* not HAVE_SYS_SOCKET_H */\r
67 #  if HAVE_LAN_SOCKET_H\r
68 #   include <lan/socket.h>\r
69 #   include <lan/in.h>\r
70 #   include <lan/netdb.h>\r
71 #  else /* not HAVE_LAN_SOCKET_H */\r
72 #   define OMIT_SOCKETS 1\r
73 #  endif /* not HAVE_LAN_SOCKET_H */\r
74 # endif /* not HAVE_SYS_SOCKET_H */\r
75 #endif /* !OMIT_SOCKETS */\r
76 \r
77 #if STDC_HEADERS\r
78 # include <stdlib.h>\r
79 # include <string.h>\r
80 #else /* not STDC_HEADERS */\r
81 extern char *getenv();\r
82 # if HAVE_STRING_H\r
83 #  include <string.h>\r
84 # else /* not HAVE_STRING_H */\r
85 #  include <strings.h>\r
86 # endif /* not HAVE_STRING_H */\r
87 #endif /* not STDC_HEADERS */\r
88 \r
89 #if HAVE_SYS_FCNTL_H\r
90 # include <sys/fcntl.h>\r
91 #else /* not HAVE_SYS_FCNTL_H */\r
92 # if HAVE_FCNTL_H\r
93 #  include <fcntl.h>\r
94 # endif /* HAVE_FCNTL_H */\r
95 #endif /* not HAVE_SYS_FCNTL_H */\r
96 \r
97 #if HAVE_SYS_SYSTEMINFO_H\r
98 # include <sys/systeminfo.h>\r
99 #endif /* HAVE_SYS_SYSTEMINFO_H */\r
100 \r
101 #if TIME_WITH_SYS_TIME\r
102 # include <sys/time.h>\r
103 # include <time.h>\r
104 #else\r
105 # if HAVE_SYS_TIME_H\r
106 #  include <sys/time.h>\r
107 # else\r
108 #  include <time.h>\r
109 # endif\r
110 #endif\r
111 \r
112 #if HAVE_UNISTD_H\r
113 # include <unistd.h>\r
114 #endif\r
115 \r
116 #if HAVE_SYS_WAIT_H\r
117 # include <sys/wait.h>\r
118 #endif\r
119 \r
120 #if HAVE_DIRENT_H\r
121 # include <dirent.h>\r
122 # define NAMLEN(dirent) strlen((dirent)->d_name)\r
123 # define HAVE_DIR_STRUCT\r
124 #else\r
125 # define dirent direct\r
126 # define NAMLEN(dirent) (dirent)->d_namlen\r
127 # if HAVE_SYS_NDIR_H\r
128 #  include <sys/ndir.h>\r
129 #  define HAVE_DIR_STRUCT\r
130 # endif\r
131 # if HAVE_SYS_DIR_H\r
132 #  include <sys/dir.h>\r
133 #  define HAVE_DIR_STRUCT\r
134 # endif\r
135 # if HAVE_NDIR_H\r
136 #  include <ndir.h>\r
137 #  define HAVE_DIR_STRUCT\r
138 # endif\r
139 #endif\r
140 \r
141 #include <X11/Intrinsic.h>\r
142 #include <X11/StringDefs.h>\r
143 #include <X11/Shell.h>\r
144 #include <X11/cursorfont.h>\r
145 #include <X11/Xatom.h>\r
146 #if USE_XAW3D\r
147 #include <X11/Xaw3d/Dialog.h>\r
148 #include <X11/Xaw3d/Form.h>\r
149 #include <X11/Xaw3d/List.h>\r
150 #include <X11/Xaw3d/Label.h>\r
151 #include <X11/Xaw3d/SimpleMenu.h>\r
152 #include <X11/Xaw3d/SmeBSB.h>\r
153 #include <X11/Xaw3d/SmeLine.h>\r
154 #include <X11/Xaw3d/Box.h>\r
155 #include <X11/Xaw3d/MenuButton.h>\r
156 #include <X11/Xaw3d/Text.h>\r
157 #include <X11/Xaw3d/AsciiText.h>\r
158 #else\r
159 #include <X11/Xaw/Dialog.h>\r
160 #include <X11/Xaw/Form.h>\r
161 #include <X11/Xaw/List.h>\r
162 #include <X11/Xaw/Label.h>\r
163 #include <X11/Xaw/SimpleMenu.h>\r
164 #include <X11/Xaw/SmeBSB.h>\r
165 #include <X11/Xaw/SmeLine.h>\r
166 #include <X11/Xaw/Box.h>\r
167 #include <X11/Xaw/MenuButton.h>\r
168 #include <X11/Xaw/Text.h>\r
169 #include <X11/Xaw/AsciiText.h>\r
170 #endif\r
171 \r
172 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.\r
173 #include "common.h"\r
174 \r
175 #if HAVE_LIBXPM\r
176 #include <X11/xpm.h>\r
177 #include "pixmaps/pixmaps.h"\r
178 #define IMAGE_EXT "xpm"\r
179 #else\r
180 #define IMAGE_EXT "xim"\r
181 #include "bitmaps/bitmaps.h"\r
182 #endif\r
183 \r
184 #include "bitmaps/icon_white.bm"\r
185 #include "bitmaps/icon_black.bm"\r
186 #include "bitmaps/checkmark.bm"\r
187 \r
188 #include "frontend.h"\r
189 #include "backend.h"\r
190 #include "moves.h"\r
191 #include "xboard.h"\r
192 #include "childio.h"\r
193 #include "xgamelist.h"\r
194 #include "xhistory.h"\r
195 #include "xedittags.h"\r
196 #include "gettext.h"\r
197 \r
198 // must be moved to xengineoutput.h\r
199 \r
200 void EngineOutputProc P((Widget w, XEvent *event,\r
201  String *prms, Cardinal *nprms));\r
202 \r
203 void EngineOutputPopDown();\r
204 \r
205 \r
206 #ifdef __EMX__\r
207 #ifndef HAVE_USLEEP\r
208 #define HAVE_USLEEP\r
209 #endif\r
210 #define usleep(t)   _sleep2(((t)+500)/1000)\r
211 #endif\r
212 \r
213 #ifdef ENABLE_NLS\r
214 # define  _(s) gettext (s)\r
215 # define N_(s) gettext_noop (s)\r
216 #else\r
217 # define  _(s) (s)\r
218 # define N_(s)  s\r
219 #endif\r
220 \r
221 typedef struct {\r
222     String string;\r
223     XtActionProc proc;\r
224 } MenuItem;\r
225 \r
226 typedef struct {\r
227     String name;\r
228     MenuItem *mi;\r
229 } Menu;\r
230 \r
231 int main P((int argc, char **argv));\r
232 RETSIGTYPE CmailSigHandler P((int sig));\r
233 RETSIGTYPE IntSigHandler P((int sig));\r
234 void CreateGCs P((void));\r
235 void CreateXIMPieces P((void));\r
236 void CreateXPMPieces P((void));\r
237 void CreatePieces P((void));\r
238 void CreatePieceMenus P((void));\r
239 Widget CreateMenuBar P((Menu *mb));\r
240 Widget CreateButtonBar P ((MenuItem *mi));\r
241 char *FindFont P((char *pattern, int targetPxlSize));\r
242 void PieceMenuPopup P((Widget w, XEvent *event,\r
243                        String *params, Cardinal *num_params));\r
244 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));\r
245 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));\r
246 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],\r
247                    u_int wreq, u_int hreq));\r
248 void CreateGrid P((void));\r
249 int EventToSquare P((int x, int limit));\r
250 void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));\r
251 void EventProc P((Widget widget, caddr_t unused, XEvent *event));\r
252 void HandleUserMove P((Widget w, XEvent *event,\r
253                      String *prms, Cardinal *nprms));\r
254 void AnimateUserMove P((Widget w, XEvent * event,\r
255                      String * params, Cardinal * nParams));\r
256 void WhiteClock P((Widget w, XEvent *event,\r
257                    String *prms, Cardinal *nprms));\r
258 void BlackClock P((Widget w, XEvent *event,\r
259                    String *prms, Cardinal *nprms));\r
260 void DrawPositionProc P((Widget w, XEvent *event,\r
261                      String *prms, Cardinal *nprms));\r
262 void XDrawPosition P((Widget w, /*Boolean*/int repaint, \r
263                      Board board));\r
264 void CommentPopUp P((char *title, char *label));\r
265 void CommentPopDown P((void));\r
266 void CommentCallback P((Widget w, XtPointer client_data,\r
267                         XtPointer call_data));\r
268 void ICSInputBoxPopUp P((void));\r
269 void ICSInputBoxPopDown P((void));\r
270 void FileNamePopUp P((char *label, char *def,\r
271                       FileProc proc, char *openMode));\r
272 void FileNamePopDown P((void));\r
273 void FileNameCallback P((Widget w, XtPointer client_data,\r
274                          XtPointer call_data));\r
275 void FileNameAction P((Widget w, XEvent *event,\r
276                        String *prms, Cardinal *nprms));\r
277 void AskQuestionReplyAction P((Widget w, XEvent *event,\r
278                           String *prms, Cardinal *nprms));\r
279 void AskQuestionProc P((Widget w, XEvent *event,\r
280                           String *prms, Cardinal *nprms));\r
281 void AskQuestionPopDown P((void));\r
282 void PromotionPopUp P((void));\r
283 void PromotionPopDown P((void));\r
284 void PromotionCallback P((Widget w, XtPointer client_data,\r
285                           XtPointer call_data));\r
286 void EditCommentPopDown P((void));\r
287 void EditCommentCallback P((Widget w, XtPointer client_data,\r
288                             XtPointer call_data));\r
289 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));\r
290 void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
291 void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
292 void LoadNextGameProc P((Widget w, XEvent *event, String *prms,\r
293                          Cardinal *nprms));\r
294 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,\r
295                          Cardinal *nprms));\r
296 void ReloadGameProc P((Widget w, XEvent *event, String *prms,\r
297                        Cardinal *nprms));\r
298 void LoadPositionProc P((Widget w, XEvent *event,\r
299                          String *prms, Cardinal *nprms));\r
300 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,\r
301                          Cardinal *nprms));\r
302 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,\r
303                          Cardinal *nprms));\r
304 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,\r
305                        Cardinal *nprms));\r
306 void CopyPositionProc P((Widget w, XEvent *event, String *prms,\r
307                          Cardinal *nprms));\r
308 void PastePositionProc P((Widget w, XEvent *event, String *prms,\r
309                           Cardinal *nprms));\r
310 void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
311 void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
312 void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
313 void SavePositionProc P((Widget w, XEvent *event,\r
314                          String *prms, Cardinal *nprms));\r
315 void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
316 void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,\r
317                             Cardinal *nprms));\r
318 void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
319 void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
320 void MachineBlackProc P((Widget w, XEvent *event, String *prms,\r
321                          Cardinal *nprms));\r
322 void MachineWhiteProc P((Widget w, XEvent *event,\r
323                          String *prms, Cardinal *nprms));\r
324 void AnalyzeModeProc P((Widget w, XEvent *event,\r
325                          String *prms, Cardinal *nprms));\r
326 void AnalyzeFileProc P((Widget w, XEvent *event,\r
327                          String *prms, Cardinal *nprms));\r
328 void TwoMachinesProc P((Widget w, XEvent *event, String *prms,\r
329                         Cardinal *nprms));\r
330 void IcsClientProc P((Widget w, XEvent *event, String *prms,\r
331                       Cardinal *nprms));\r
332 void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
333 void EditPositionProc P((Widget w, XEvent *event,\r
334                          String *prms, Cardinal *nprms));\r
335 void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
336 void EditCommentProc P((Widget w, XEvent *event,\r
337                         String *prms, Cardinal *nprms));\r
338 void IcsInputBoxProc P((Widget w, XEvent *event,\r
339                         String *prms, Cardinal *nprms));\r
340 void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
341 void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
342 void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
343 void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
344 void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
345 void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
346 void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
347 void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
348 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
349 void StopObservingProc P((Widget w, XEvent *event, String *prms,\r
350                           Cardinal *nprms));\r
351 void StopExaminingProc P((Widget w, XEvent *event, String *prms,\r
352                           Cardinal *nprms));\r
353 void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
354 void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
355 void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
356 void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
357 void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
358 void TruncateGameProc P((Widget w, XEvent *event, String *prms,\r
359                          Cardinal *nprms));\r
360 void RetractMoveProc P((Widget w, XEvent *event, String *prms,\r
361                         Cardinal *nprms));\r
362 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
363 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,\r
364                         Cardinal *nprms));\r
365 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,\r
366                          Cardinal *nprms));\r
367 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,\r
368                          Cardinal *nprms));\r
369 void AutocommProc P((Widget w, XEvent *event, String *prms,\r
370                      Cardinal *nprms));\r
371 void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
372 void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
373 void AutobsProc P((Widget w, XEvent *event, String *prms,\r
374                         Cardinal *nprms));\r
375 void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
376 void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
377 void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
378 void FlashMovesProc P((Widget w, XEvent *event, String *prms,\r
379                        Cardinal *nprms));\r
380 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
381 void GetMoveListProc P((Widget w, XEvent *event, String *prms,\r
382                         Cardinal *nprms));\r
383 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,\r
384                               Cardinal *nprms));\r
385 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,\r
386                               Cardinal *nprms));\r
387 void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
388 void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
389 void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,\r
390                          Cardinal *nprms));\r
391 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,\r
392                          Cardinal *nprms));\r
393 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,\r
394                            Cardinal *nprms));\r
395 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,\r
396                         Cardinal *nprms));\r
397 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,\r
398                              Cardinal *nprms));\r
399 void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
400 void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
401 void ShowCoordsProc P((Widget w, XEvent *event, String *prms,\r
402                        Cardinal *nprms));\r
403 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,\r
404                          Cardinal *nprms));\r
405 void HideThinkingProc P((Widget w, XEvent *event, String *prms,\r
406                          Cardinal *nprms));\r
407 void TestLegalityProc P((Widget w, XEvent *event, String *prms,\r
408                           Cardinal *nprms));\r
409 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
410 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
411 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
412 void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
413 void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
414 void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
415 void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
416 void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
417 void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
418 void DisplayMove P((int moveNumber));\r
419 void DisplayTitle P((char *title));\r
420 void ICSInitScript P((void));\r
421 int LoadGamePopUp P((FILE *f, int gameNumber, char *title));\r
422 void ErrorPopUp P((char *title, char *text, int modal));\r
423 void ErrorPopDown P((void));\r
424 static char *ExpandPathName P((char *path));\r
425 static void CreateAnimVars P((void));\r
426 static void DragPieceBegin P((int x, int y));\r
427 static void DragPieceMove P((int x, int y));\r
428 static void DragPieceEnd P((int x, int y));\r
429 static void DrawDragPiece P((void));\r
430 char *ModeToWidgetName P((GameMode mode));\r
431 void EngineOutputUpdate( FrontEndProgramStats * stats );\r
432 void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
433 void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
434 void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
435 void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
436 void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
437 void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
438 void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
439 void ShufflePopDown P(());\r
440 void EnginePopDown P(());\r
441 void UciPopDown P(());\r
442 void TimeControlPopDown P(());\r
443 void NewVariantPopDown P(());\r
444 void SettingsPopDown P(());\r
445 /*\r
446 * XBoard depends on Xt R4 or higher\r
447 */\r
448 int xtVersion = XtSpecificationRelease;\r
449 \r
450 int xScreen;\r
451 Display *xDisplay;\r
452 Window xBoardWindow;\r
453 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,\r
454   jailSquareColor, highlightSquareColor, premoveHighlightColor;\r
455 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,\r
456   bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,\r
457   wjPieceGC, bjPieceGC, prelineGC, countGC;\r
458 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;\r
459 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget, \r
460   whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16], \r
461   commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,\r
462   menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,\r
463   ICSInputShell, fileNameShell, askQuestionShell;\r
464 XSegment gridSegments[(BOARD_SIZE + 1) * 2];\r
465 XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];\r
466 Font clockFontID, coordFontID, countFontID;\r
467 XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;\r
468 XtAppContext appContext;\r
469 char *layoutName;\r
470 char *oldICSInteractionTitle;\r
471 \r
472 FileProc fileProc;\r
473 char *fileOpenMode;\r
474 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion\r
475 \r
476 Position commentX = -1, commentY = -1;\r
477 Dimension commentW, commentH;\r
478 \r
479 int squareSize, smallLayout = 0, tinyLayout = 0,\r
480   marginW, marginH, // [HGM] for run-time resizing\r
481   fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,\r
482   ICSInputBoxUp = False, askQuestionUp = False,\r
483   filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,\r
484   editUp = False, errorUp = False, errorExitStatus = -1, lineGap;\r
485 Pixel timerForegroundPixel, timerBackgroundPixel;\r
486 Pixel buttonForegroundPixel, buttonBackgroundPixel;\r
487 char *chessDir, *programName, *programVersion,\r
488   *gameCopyFilename, *gamePasteFilename;\r
489 \r
490 #define SOLID 0\r
491 #define OUTLINE 1\r
492 Pixmap pieceBitmap[2][(int)BlackPawn];\r
493 Pixmap xpmPieceBitmap[4][(int)BlackPawn];       /* LL, LD, DL, DD */\r
494 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;\r
495 int useImages, useImageSqs;\r
496 XImage *ximPieceBitmap[4][(int)BlackPawn];      /* LL, LD, DL, DD */\r
497 Pixmap ximMaskPm[(int)BlackPawn];            /* clipmasks, used for XIM pieces */\r
498 XImage *ximLightSquare, *ximDarkSquare;\r
499 XImage *xim_Cross;\r
500 \r
501 #define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % (int)BlackPawn]\r
502 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % (int)BlackPawn]\r
503 \r
504 #define White(piece) ((int)(piece) < (int)BlackPawn)\r
505 \r
506 /* Variables for doing smooth animation. This whole thing\r
507    would be much easier if the board was double-buffered,\r
508    but that would require a fairly major rewrite.       */\r
509 \r
510 typedef struct {\r
511         Pixmap  saveBuf;\r
512         Pixmap  newBuf;\r
513         GC      blitGC, pieceGC, outlineGC;\r
514         XPoint  startSquare, prevFrame, mouseDelta;\r
515         int     startColor;\r
516         int     dragPiece;\r
517         Boolean dragActive;\r
518         int     startBoardX, startBoardY;\r
519     } AnimState;\r
520 \r
521 /* There can be two pieces being animated at once: a player\r
522    can begin dragging a piece before the remote opponent has moved. */\r
523 \r
524 static AnimState game, player;\r
525 \r
526 /* Bitmaps for use as masks when drawing XPM pieces.\r
527    Need one for each black and white piece.             */\r
528 static Pixmap xpmMask[BlackKing + 1];\r
529 \r
530 /* This magic number is the number of intermediate frames used\r
531    in each half of the animation. For short moves it's reduced\r
532    by 1. The total number of frames will be factor * 2 + 1.  */\r
533 #define kFactor    4\r
534 \r
535 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;\r
536 \r
537 MenuItem fileMenu[] = {\r
538     {N_("New Game"), ResetProc},\r
539     {N_("New Shuffle Game ..."), ShuffleMenuProc},\r
540     {N_("New Variant ..."), NewVariantProc},      // [HGM] variant: not functional yet\r
541     {"----", NothingProc},\r
542     {N_("Load Game"), LoadGameProc},\r
543     {N_("Load Next Game"), LoadNextGameProc},\r
544     {N_("Load Previous Game"), LoadPrevGameProc},\r
545     {N_("Reload Same Game"), ReloadGameProc},\r
546     {N_("Save Game"), SaveGameProc},\r
547     {"----", NothingProc},\r
548     {N_("Copy Game"), CopyGameProc},\r
549     {N_("Paste Game"), PasteGameProc},\r
550     {"----", NothingProc},\r
551     {N_("Load Position"), LoadPositionProc},\r
552     {N_("Load Next Position"), LoadNextPositionProc},\r
553     {N_("Load Previous Position"), LoadPrevPositionProc},\r
554     {N_("Reload Same Position"), ReloadPositionProc},\r
555     {N_("Save Position"), SavePositionProc},\r
556     {"----", NothingProc},\r
557     {N_("Copy Position"), CopyPositionProc},\r
558     {N_("Paste Position"), PastePositionProc},\r
559     {"----", NothingProc},\r
560     {N_("Mail Move"), MailMoveProc},\r
561     {N_("Reload CMail Message"), ReloadCmailMsgProc},\r
562     {"----", NothingProc},\r
563     {N_("Exit"), QuitProc},\r
564     {NULL, NULL}\r
565 };\r
566 \r
567 MenuItem modeMenu[] = {\r
568     {N_("Machine White"), MachineWhiteProc},\r
569     {N_("Machine Black"), MachineBlackProc},\r
570     {N_("Two Machines"), TwoMachinesProc},\r
571     {N_("Analysis Mode"), AnalyzeModeProc},\r
572     {N_("Analyze File"), AnalyzeFileProc },\r
573     {N_("ICS Client"), IcsClientProc},\r
574     {N_("Edit Game"), EditGameProc},\r
575     {N_("Edit Position"), EditPositionProc},\r
576     {N_("Training"), TrainingProc},\r
577     {"----", NothingProc},\r
578     {N_("Show Engine Output"), EngineOutputProc},\r
579     {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet\r
580     {N_("Show Game List"), ShowGameListProc},\r
581     {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code\r
582     {"----", NothingProc},\r
583     {N_("Edit Tags"), EditTagsProc},\r
584     {N_("Edit Comment"), EditCommentProc},\r
585     {N_("ICS Input Box"), IcsInputBoxProc},\r
586     {N_("Pause"), PauseProc},\r
587     {NULL, NULL}\r
588 };\r
589 \r
590 MenuItem actionMenu[] = {\r
591     {N_("Accept"), AcceptProc},\r
592     {N_("Decline"), DeclineProc},\r
593     {N_("Rematch"), RematchProc},\r
594     {"----", NothingProc},    \r
595     {N_("Call Flag"), CallFlagProc},\r
596     {N_("Draw"), DrawProc},\r
597     {N_("Adjourn"), AdjournProc},\r
598     {N_("Abort"), AbortProc},\r
599     {N_("Resign"), ResignProc},\r
600     {"----", NothingProc},    \r
601     {N_("Stop Observing"), StopObservingProc},\r
602     {N_("Stop Examining"), StopExaminingProc},\r
603     {NULL, NULL}\r
604 };\r
605 \r
606 MenuItem stepMenu[] = {\r
607     {N_("Backward"), BackwardProc},\r
608     {N_("Forward"), ForwardProc},\r
609     {N_("Back to Start"), ToStartProc},\r
610     {N_("Forward to End"), ToEndProc},\r
611     {N_("Revert"), RevertProc},\r
612     {N_("Truncate Game"), TruncateGameProc},\r
613     {"----", NothingProc},    \r
614     {N_("Move Now"), MoveNowProc},\r
615     {N_("Retract Move"), RetractMoveProc},\r
616     {NULL, NULL}\r
617 };    \r
618 \r
619 MenuItem optionsMenu[] = {\r
620     {N_("Flip View"), FlipViewProc},\r
621     {"----", NothingProc},    \r
622     {N_("Adjudications ..."), EngineMenuProc},    \r
623     {N_("General Settings ..."), UciMenuProc},    \r
624     {N_("Engine #1 Settings ..."), FirstSettingsProc},    \r
625     {N_("Engine #2 Settings ..."), SecondSettingsProc},    \r
626     {N_("Time Control ..."), TimeControlProc},    \r
627     {"----", NothingProc},    \r
628     {N_("Always Queen"), AlwaysQueenProc},\r
629     {N_("Animate Dragging"), AnimateDraggingProc},\r
630     {N_("Animate Moving"), AnimateMovingProc},\r
631     {N_("Auto Comment"), AutocommProc},\r
632     {N_("Auto Flag"), AutoflagProc},\r
633     {N_("Auto Flip View"), AutoflipProc},\r
634     {N_("Auto Observe"), AutobsProc},\r
635     {N_("Auto Raise Board"), AutoraiseProc},\r
636     {N_("Auto Save"), AutosaveProc},\r
637     {N_("Blindfold"), BlindfoldProc},\r
638     {N_("Flash Moves"), FlashMovesProc},\r
639     {N_("Get Move List"), GetMoveListProc},\r
640 #if HIGHDRAG\r
641     {N_("Highlight Dragging"), HighlightDraggingProc},\r
642 #endif\r
643     {N_("Highlight Last Move"), HighlightLastMoveProc},\r
644     {N_("Move Sound"), MoveSoundProc},\r
645     {N_("ICS Alarm"), IcsAlarmProc},\r
646     {N_("Old Save Style"), OldSaveStyleProc},\r
647     {N_("Periodic Updates"), PeriodicUpdatesProc},      \r
648     {N_("Ponder Next Move"), PonderNextMoveProc},\r
649     {N_("Popup Exit Message"), PopupExitMessageProc},   \r
650     {N_("Popup Move Errors"), PopupMoveErrorsProc},     \r
651     {N_("Premove"), PremoveProc},\r
652     {N_("Quiet Play"), QuietPlayProc},\r
653     {N_("Show Coords"), ShowCoordsProc},\r
654     {N_("Hide Thinking"), HideThinkingProc},\r
655     {N_("Test Legality"), TestLegalityProc},\r
656     {NULL, NULL}\r
657 };\r
658 \r
659 MenuItem helpMenu[] = {\r
660     {N_("Info XBoard"), InfoProc},\r
661     {N_("Man XBoard"), ManProc},\r
662     {"----", NothingProc},\r
663     {N_("Hint"), HintProc},\r
664     {N_("Book"), BookProc},\r
665     {"----", NothingProc},\r
666     {N_("About XBoard"), AboutProc},\r
667     {NULL, NULL}\r
668 };\r
669 \r
670 Menu menuBar[] = {\r
671     {N_("File"), fileMenu},\r
672     {N_("Mode"), modeMenu},\r
673     {N_("Action"), actionMenu},\r
674     {N_("Step"), stepMenu},\r
675     {N_("Options"), optionsMenu},\r
676     {N_("Help"), helpMenu},\r
677     {NULL, NULL}\r
678 };\r
679 \r
680 #define PAUSE_BUTTON N_("P")\r
681 MenuItem buttonBar[] = {\r
682     {"<<", ToStartProc},\r
683     {"<", BackwardProc},\r
684     {PAUSE_BUTTON, PauseProc},\r
685     {">", ForwardProc},\r
686     {">>", ToEndProc},\r
687     {NULL, NULL}\r
688 };\r
689 \r
690 #define PIECE_MENU_SIZE 11\r
691 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {\r
692     { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),\r
693       N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },\r
694     { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),\r
695       N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },  \r
696 };\r
697 /* must be in same order as PieceMenuStrings! */\r
698 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {\r
699     { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,\r
700         WhiteRook, WhiteQueen, WhiteKing,\r
701         (ChessSquare) 0, EmptySquare, ClearBoard },\r
702     { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,\r
703         BlackRook, BlackQueen, BlackKing,\r
704         (ChessSquare) 0, EmptySquare, ClearBoard },\r
705 };\r
706 \r
707 #define DROP_MENU_SIZE 6\r
708 String dropMenuStrings[DROP_MENU_SIZE] = {\r
709     "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")\r
710   };\r
711 /* must be in same order as PieceMenuStrings! */\r
712 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {\r
713     (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,\r
714     WhiteRook, WhiteQueen\r
715 };\r
716 \r
717 typedef struct {\r
718     char piece;\r
719     char* widget;\r
720 } DropMenuEnables;\r
721 \r
722 DropMenuEnables dmEnables[] = {\r
723     { 'P', "Pawn" },\r
724     { 'N', "Knight" },\r
725     { 'B', "Bishop" },\r
726     { 'R', "Rook" },\r
727     { 'Q', "Queen" }\r
728 };\r
729 \r
730 Arg shellArgs[] = {\r
731     { XtNwidth, 0 },\r
732     { XtNheight, 0 },\r
733     { XtNminWidth, 0 },\r
734     { XtNminHeight, 0 },\r
735     { XtNmaxWidth, 0 },\r
736     { XtNmaxHeight, 0 }\r
737 };\r
738 \r
739 Arg layoutArgs[] = {\r
740     { XtNborderWidth, 0 },\r
741     { XtNdefaultDistance, 0 },\r
742 };\r
743 \r
744 Arg formArgs[] = {\r
745     { XtNborderWidth, 0 },\r
746     { XtNresizable, (XtArgVal) True },\r
747 };\r
748 \r
749 Arg boardArgs[] = {\r
750     { XtNborderWidth, 0 },\r
751     { XtNwidth, 0 },\r
752     { XtNheight, 0 }\r
753 };\r
754 \r
755 Arg titleArgs[] = {\r
756     { XtNjustify, (XtArgVal) XtJustifyRight },\r
757     { XtNlabel, (XtArgVal) "..." },\r
758     { XtNresizable, (XtArgVal) True },\r
759     { XtNresize, (XtArgVal) False }\r
760 };\r
761 \r
762 Arg messageArgs[] = {\r
763     { XtNjustify, (XtArgVal) XtJustifyLeft },\r
764     { XtNlabel, (XtArgVal) "..." },\r
765     { XtNresizable, (XtArgVal) True },\r
766     { XtNresize, (XtArgVal) False }\r
767 };\r
768 \r
769 Arg timerArgs[] = {\r
770     { XtNborderWidth, 0 },\r
771     { XtNjustify, (XtArgVal) XtJustifyLeft }\r
772 };\r
773 \r
774 XtResource clientResources[] = {\r
775     { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),\r
776         XtOffset(AppDataPtr, whitePieceColor), XtRString,\r
777         WHITE_PIECE_COLOR },\r
778     { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),\r
779         XtOffset(AppDataPtr, blackPieceColor), XtRString,\r
780         BLACK_PIECE_COLOR },\r
781     { "lightSquareColor", "lightSquareColor", XtRString,\r
782         sizeof(String), XtOffset(AppDataPtr, lightSquareColor),\r
783         XtRString, LIGHT_SQUARE_COLOR }, \r
784     { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),\r
785         XtOffset(AppDataPtr, darkSquareColor), XtRString,\r
786         DARK_SQUARE_COLOR },\r
787     { "highlightSquareColor", "highlightSquareColor", XtRString,\r
788         sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),\r
789         XtRString, HIGHLIGHT_SQUARE_COLOR },\r
790     { "premoveHighlightColor", "premoveHighlightColor", XtRString,\r
791         sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),\r
792         XtRString, PREMOVE_HIGHLIGHT_COLOR },\r
793     { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),\r
794         XtOffset(AppDataPtr, movesPerSession), XtRImmediate,\r
795         (XtPointer) MOVES_PER_SESSION },\r
796     { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),\r
797         XtOffset(AppDataPtr, timeIncrement), XtRImmediate,\r
798         (XtPointer) TIME_INCREMENT },\r
799     { "initString", "initString", XtRString, sizeof(String),\r
800         XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },\r
801     { "secondInitString", "secondInitString", XtRString, sizeof(String),\r
802         XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },\r
803     { "firstComputerString", "firstComputerString", XtRString,\r
804         sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,\r
805       COMPUTER_STRING },\r
806     { "secondComputerString", "secondComputerString", XtRString,\r
807         sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,\r
808       COMPUTER_STRING },\r
809     { "firstChessProgram", "firstChessProgram", XtRString,\r
810         sizeof(String), XtOffset(AppDataPtr, firstChessProgram),\r
811         XtRString, FIRST_CHESS_PROGRAM },\r
812     { "secondChessProgram", "secondChessProgram", XtRString,\r
813         sizeof(String), XtOffset(AppDataPtr, secondChessProgram),\r
814         XtRString, SECOND_CHESS_PROGRAM },\r
815     { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,\r
816         sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),\r
817         XtRImmediate, (XtPointer) False },\r
818     { "noChessProgram", "noChessProgram", XtRBoolean,\r
819         sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),\r
820         XtRImmediate, (XtPointer) False },\r
821     { "firstHost", "firstHost", XtRString, sizeof(String),\r
822         XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },\r
823     { "secondHost", "secondHost", XtRString, sizeof(String),\r
824         XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },\r
825     { "firstDirectory", "firstDirectory", XtRString, sizeof(String),\r
826         XtOffset(AppDataPtr, firstDirectory), XtRString, "." },\r
827     { "secondDirectory", "secondDirectory", XtRString, sizeof(String),\r
828         XtOffset(AppDataPtr, secondDirectory), XtRString, "." },\r
829     { "bitmapDirectory", "bitmapDirectory", XtRString,\r
830         sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),\r
831         XtRString, "" },\r
832     { "remoteShell", "remoteShell", XtRString, sizeof(String),\r
833         XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },\r
834     { "remoteUser", "remoteUser", XtRString, sizeof(String),\r
835         XtOffset(AppDataPtr, remoteUser), XtRString, "" },\r
836     { "timeDelay", "timeDelay", XtRFloat, sizeof(float),\r
837         XtOffset(AppDataPtr, timeDelay), XtRString,\r
838         (XtPointer) TIME_DELAY_QUOTE },\r
839     { "timeControl", "timeControl", XtRString, sizeof(String),\r
840         XtOffset(AppDataPtr, timeControl), XtRString,\r
841         (XtPointer) TIME_CONTROL },\r
842     { "internetChessServerMode", "internetChessServerMode",\r
843         XtRBoolean, sizeof(Boolean),\r
844         XtOffset(AppDataPtr, icsActive), XtRImmediate,\r
845         (XtPointer) False },\r
846     { "internetChessServerHost", "internetChessServerHost",\r
847         XtRString, sizeof(String),\r
848         XtOffset(AppDataPtr, icsHost),\r
849         XtRString, (XtPointer) ICS_HOST },\r
850     { "internetChessServerPort", "internetChessServerPort",\r
851         XtRString, sizeof(String),\r
852         XtOffset(AppDataPtr, icsPort), XtRString,\r
853         (XtPointer) ICS_PORT },\r
854     { "internetChessServerCommPort", "internetChessServerCommPort",\r
855         XtRString, sizeof(String),\r
856         XtOffset(AppDataPtr, icsCommPort), XtRString,\r
857         ICS_COMM_PORT },\r
858     { "internetChessServerLogonScript", "internetChessServerLogonScript",\r
859         XtRString, sizeof(String),\r
860         XtOffset(AppDataPtr, icsLogon), XtRString,\r
861         ICS_LOGON },\r
862     { "internetChessServerHelper", "internetChessServerHelper",\r
863         XtRString, sizeof(String),\r
864         XtOffset(AppDataPtr, icsHelper), XtRString, "" },\r
865     { "internetChessServerInputBox", "internetChessServerInputBox",\r
866         XtRBoolean, sizeof(Boolean),\r
867         XtOffset(AppDataPtr, icsInputBox), XtRImmediate,\r
868         (XtPointer) False },\r
869     { "icsAlarm", "icsAlarm",\r
870         XtRBoolean, sizeof(Boolean),\r
871         XtOffset(AppDataPtr, icsAlarm), XtRImmediate,\r
872         (XtPointer) True },\r
873     { "icsAlarmTime", "icsAlarmTime",\r
874         XtRInt, sizeof(int),\r
875         XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,\r
876         (XtPointer) 5000 },\r
877     { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),\r
878         XtOffset(AppDataPtr, useTelnet), XtRImmediate,\r
879         (XtPointer) False },\r
880     { "telnetProgram", "telnetProgram", XtRString, sizeof(String),\r
881         XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },\r
882     { "gateway", "gateway", XtRString, sizeof(String),\r
883         XtOffset(AppDataPtr, gateway), XtRString, "" },\r
884     { "loadGameFile", "loadGameFile", XtRString, sizeof(String),\r
885         XtOffset(AppDataPtr, loadGameFile), XtRString, "" },\r
886     { "loadGameIndex", "loadGameIndex",\r
887         XtRInt, sizeof(int),\r
888         XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,\r
889         (XtPointer) 0 },\r
890     { "saveGameFile", "saveGameFile", XtRString, sizeof(String),\r
891         XtOffset(AppDataPtr, saveGameFile), XtRString, "" },\r
892     { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,\r
893         sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),\r
894         XtRImmediate, (XtPointer) True },\r
895     { "autoSaveGames", "autoSaveGames", XtRBoolean,\r
896         sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),\r
897         XtRImmediate, (XtPointer) False },\r
898     { "blindfold", "blindfold", XtRBoolean,\r
899         sizeof(Boolean), XtOffset(AppDataPtr, blindfold),\r
900         XtRImmediate, (XtPointer) False },\r
901     { "loadPositionFile", "loadPositionFile", XtRString,\r
902         sizeof(String), XtOffset(AppDataPtr, loadPositionFile),\r
903         XtRString, "" },\r
904     { "loadPositionIndex", "loadPositionIndex",\r
905         XtRInt, sizeof(int),\r
906         XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,\r
907         (XtPointer) 1 },\r
908     { "savePositionFile", "savePositionFile", XtRString,\r
909         sizeof(String), XtOffset(AppDataPtr, savePositionFile),\r
910         XtRString, "" },\r
911     { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),\r
912         XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },\r
913     { "matchGames", "matchGames", XtRInt, sizeof(int),\r
914         XtOffset(AppDataPtr, matchGames), XtRImmediate,\r
915         (XtPointer) 0 },\r
916     { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),\r
917         XtOffset(AppDataPtr, monoMode), XtRImmediate,\r
918         (XtPointer) False },\r
919     { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),\r
920         XtOffset(AppDataPtr, debugMode), XtRImmediate,\r
921         (XtPointer) False },\r
922     { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),\r
923         XtOffset(AppDataPtr, clockMode), XtRImmediate,\r
924         (XtPointer) True },\r
925     { "boardSize", "boardSize", XtRString, sizeof(String),\r
926         XtOffset(AppDataPtr, boardSize), XtRString, "" },\r
927     { "searchTime", "searchTime", XtRString, sizeof(String),\r
928         XtOffset(AppDataPtr, searchTime), XtRString,\r
929         (XtPointer) "" },\r
930     { "searchDepth", "searchDepth", XtRInt, sizeof(int),\r
931         XtOffset(AppDataPtr, searchDepth), XtRImmediate, \r
932         (XtPointer) 0 },\r
933     { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),\r
934         XtOffset(AppDataPtr, showCoords), XtRImmediate,\r
935         (XtPointer) False },\r
936     { "showJail", "showJail", XtRInt, sizeof(int),\r
937         XtOffset(AppDataPtr, showJail), XtRImmediate,\r
938         (XtPointer) 0 },\r
939     { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),\r
940         XtOffset(AppDataPtr, showThinking), XtRImmediate,\r
941         (XtPointer) True },\r
942     { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),\r
943         XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,\r
944         (XtPointer) True },\r
945     { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),\r
946         XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,\r
947         (XtPointer) True },\r
948     { "clockFont", "clockFont", XtRString, sizeof(String),\r
949         XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },\r
950     { "coordFont", "coordFont", XtRString, sizeof(String),\r
951         XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },\r
952     { "font", "font", XtRString, sizeof(String),\r
953         XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },\r
954     { "ringBellAfterMoves", "ringBellAfterMoves",\r
955         XtRBoolean, sizeof(Boolean),\r
956         XtOffset(AppDataPtr, ringBellAfterMoves),\r
957         XtRImmediate, (XtPointer) False },\r
958     { "autoCallFlag", "autoCallFlag", XtRBoolean,\r
959         sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),\r
960         XtRImmediate, (XtPointer) False },\r
961     { "autoFlipView", "autoFlipView", XtRBoolean,\r
962         sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),\r
963         XtRImmediate, (XtPointer) True },\r
964     { "autoObserve", "autoObserve", XtRBoolean,\r
965         sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),\r
966         XtRImmediate, (XtPointer) False },\r
967     { "autoComment", "autoComment", XtRBoolean,\r
968         sizeof(Boolean), XtOffset(AppDataPtr, autoComment),\r
969         XtRImmediate, (XtPointer) False },\r
970     { "getMoveList", "getMoveList", XtRBoolean,\r
971         sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),\r
972         XtRImmediate, (XtPointer) True },\r
973 #if HIGHDRAG\r
974     { "highlightDragging", "highlightDragging", XtRBoolean,\r
975         sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),\r
976         XtRImmediate, (XtPointer) False },\r
977 #endif\r
978     { "highlightLastMove", "highlightLastMove", XtRBoolean,\r
979         sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),\r
980         XtRImmediate, (XtPointer) False },\r
981     { "premove", "premove", XtRBoolean,\r
982         sizeof(Boolean), XtOffset(AppDataPtr, premove),\r
983         XtRImmediate, (XtPointer) True },\r
984     { "testLegality", "testLegality", XtRBoolean,\r
985         sizeof(Boolean), XtOffset(AppDataPtr, testLegality),\r
986         XtRImmediate, (XtPointer) True },\r
987     { "flipView", "flipView", XtRBoolean,\r
988         sizeof(Boolean), XtOffset(AppDataPtr, flipView),\r
989         XtRImmediate, (XtPointer) False },\r
990     { "cmail", "cmailGameName", XtRString, sizeof(String),\r
991         XtOffset(AppDataPtr, cmailGameName), XtRString, "" },\r
992     { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,\r
993         sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),\r
994         XtRImmediate, (XtPointer) False },\r
995     { "oldSaveStyle", "oldSaveStyle", XtRBoolean,\r
996         sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),\r
997         XtRImmediate, (XtPointer) False },\r
998     { "quietPlay", "quietPlay", XtRBoolean,\r
999         sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),\r
1000         XtRImmediate, (XtPointer) False },\r
1001     { "titleInWindow", "titleInWindow", XtRBoolean,\r
1002         sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),\r
1003         XtRImmediate, (XtPointer) False },\r
1004     { "localLineEditing", "localLineEditing", XtRBoolean,\r
1005         sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),\r
1006         XtRImmediate, (XtPointer) True }, /* not implemented, must be True */\r
1007 #ifdef ZIPPY\r
1008     { "zippyTalk", "zippyTalk", XtRBoolean,\r
1009         sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),\r
1010         XtRImmediate, (XtPointer) ZIPPY_TALK },\r
1011     { "zippyPlay", "zippyPlay", XtRBoolean,\r
1012         sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),\r
1013         XtRImmediate, (XtPointer) ZIPPY_PLAY },\r
1014     { "zippyLines", "zippyLines", XtRString, sizeof(String),\r
1015         XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },\r
1016     { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),\r
1017         XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },\r
1018     { "zippyPassword", "zippyPassword", XtRString, sizeof(String),\r
1019         XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },\r
1020     { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),\r
1021         XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },\r
1022     { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),\r
1023         XtOffset(AppDataPtr, zippyWrongPassword), XtRString,\r
1024         ZIPPY_WRONG_PASSWORD },\r
1025     { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),\r
1026         XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },\r
1027     { "zippyUseI", "zippyUseI", XtRBoolean,\r
1028         sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),\r
1029         XtRImmediate, (XtPointer) ZIPPY_USE_I },\r
1030     { "zippyBughouse", "zippyBughouse", XtRInt,\r
1031         sizeof(int), XtOffset(AppDataPtr, zippyBughouse),\r
1032         XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },\r
1033     { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,\r
1034         sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),\r
1035         XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },\r
1036     { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),\r
1037         XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },\r
1038     { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),\r
1039         XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },\r
1040     { "zippyAdjourn", "zippyAdjourn", XtRBoolean,\r
1041         sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),\r
1042         XtRImmediate, (XtPointer) ZIPPY_ADJOURN },\r
1043     { "zippyAbort", "zippyAbort", XtRBoolean,\r
1044         sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),\r
1045         XtRImmediate, (XtPointer) ZIPPY_ABORT },\r
1046     { "zippyVariants", "zippyVariants", XtRString, sizeof(String),\r
1047         XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },\r
1048     { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),\r
1049         XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,\r
1050         (XtPointer) ZIPPY_MAX_GAMES },\r
1051     { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),\r
1052         XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,\r
1053         (XtPointer) ZIPPY_REPLAY_TIMEOUT },\r
1054 #endif\r
1055     { "flashCount", "flashCount", XtRInt, sizeof(int),\r
1056         XtOffset(AppDataPtr, flashCount), XtRImmediate,\r
1057         (XtPointer) FLASH_COUNT  },\r
1058     { "flashRate", "flashRate", XtRInt, sizeof(int),\r
1059         XtOffset(AppDataPtr, flashRate), XtRImmediate,\r
1060         (XtPointer) FLASH_RATE },\r
1061     { "pixmapDirectory", "pixmapDirectory", XtRString,\r
1062         sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),\r
1063         XtRString, "" },\r
1064     { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),\r
1065         XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,\r
1066         (XtPointer) MS_LOGIN_DELAY },\r
1067     { "colorizeMessages", "colorizeMessages", XtRBoolean,\r
1068         sizeof(Boolean), XtOffset(AppDataPtr, colorize),\r
1069         XtRImmediate, (XtPointer) False },      \r
1070     { "colorShout", "colorShout", XtRString,\r
1071         sizeof(String), XtOffset(AppDataPtr, colorShout),\r
1072         XtRString, COLOR_SHOUT },\r
1073     { "colorSShout", "colorSShout", XtRString,\r
1074         sizeof(String), XtOffset(AppDataPtr, colorSShout),\r
1075         XtRString, COLOR_SSHOUT },\r
1076     { "colorChannel1", "colorChannel1", XtRString,\r
1077         sizeof(String), XtOffset(AppDataPtr, colorChannel1),\r
1078         XtRString, COLOR_CHANNEL1 },\r
1079     { "colorChannel", "colorChannel", XtRString,\r
1080         sizeof(String), XtOffset(AppDataPtr, colorChannel),\r
1081         XtRString, COLOR_CHANNEL },\r
1082     { "colorKibitz", "colorKibitz", XtRString,\r
1083         sizeof(String), XtOffset(AppDataPtr, colorKibitz),\r
1084         XtRString, COLOR_KIBITZ },\r
1085     { "colorTell", "colorTell", XtRString,\r
1086         sizeof(String), XtOffset(AppDataPtr, colorTell),\r
1087         XtRString, COLOR_TELL },\r
1088     { "colorChallenge", "colorChallenge", XtRString,\r
1089         sizeof(String), XtOffset(AppDataPtr, colorChallenge),\r
1090         XtRString, COLOR_CHALLENGE },\r
1091     { "colorRequest", "colorRequest", XtRString,\r
1092         sizeof(String), XtOffset(AppDataPtr, colorRequest),\r
1093         XtRString, COLOR_REQUEST },\r
1094     { "colorSeek", "colorSeek", XtRString,\r
1095         sizeof(String), XtOffset(AppDataPtr, colorSeek),\r
1096         XtRString, COLOR_SEEK },\r
1097     { "colorNormal", "colorNormal", XtRString,\r
1098         sizeof(String), XtOffset(AppDataPtr, colorNormal),\r
1099         XtRString, COLOR_NORMAL },      \r
1100     { "soundProgram", "soundProgram", XtRString,\r
1101       sizeof(String), XtOffset(AppDataPtr, soundProgram),\r
1102       XtRString, "play" },\r
1103     { "soundShout", "soundShout", XtRString,\r
1104       sizeof(String), XtOffset(AppDataPtr, soundShout),\r
1105       XtRString, "" },\r
1106     { "soundSShout", "soundSShout", XtRString,\r
1107       sizeof(String), XtOffset(AppDataPtr, soundSShout),\r
1108       XtRString, "" },\r
1109     { "soundChannel1", "soundChannel1", XtRString,\r
1110       sizeof(String), XtOffset(AppDataPtr, soundChannel1),\r
1111       XtRString, "" },\r
1112     { "soundChannel", "soundChannel", XtRString,\r
1113       sizeof(String), XtOffset(AppDataPtr, soundChannel),\r
1114       XtRString, "" },\r
1115     { "soundKibitz", "soundKibitz", XtRString,\r
1116       sizeof(String), XtOffset(AppDataPtr, soundKibitz),\r
1117       XtRString, "" },\r
1118     { "soundTell", "soundTell", XtRString,\r
1119       sizeof(String), XtOffset(AppDataPtr, soundTell),\r
1120       XtRString, "" },\r
1121     { "soundChallenge", "soundChallenge", XtRString,\r
1122       sizeof(String), XtOffset(AppDataPtr, soundChallenge),\r
1123       XtRString, "" },\r
1124     { "soundRequest", "soundRequest", XtRString,\r
1125       sizeof(String), XtOffset(AppDataPtr, soundRequest),\r
1126       XtRString, "" },\r
1127     { "soundSeek", "soundSeek", XtRString,\r
1128       sizeof(String), XtOffset(AppDataPtr, soundSeek),\r
1129       XtRString, "" },\r
1130     { "soundMove", "soundMove", XtRString,\r
1131       sizeof(String), XtOffset(AppDataPtr, soundMove),\r
1132       XtRString, "$" },\r
1133     { "soundIcsWin", "soundIcsWin", XtRString,\r
1134       sizeof(String), XtOffset(AppDataPtr, soundIcsWin),\r
1135       XtRString, "" },\r
1136     { "soundIcsLoss", "soundIcsLoss", XtRString,\r
1137       sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),\r
1138       XtRString, "" },\r
1139     { "soundIcsDraw", "soundIcsDraw", XtRString,\r
1140       sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),\r
1141       XtRString, "" },\r
1142     { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,\r
1143       sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),\r
1144       XtRString, "" },\r
1145     { "soundIcsAlarm", "soundIcsAlarm", XtRString,\r
1146       sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),\r
1147       XtRString, "$" },\r
1148     { "reuseFirst", "reuseFirst", XtRBoolean,\r
1149         sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),\r
1150         XtRImmediate, (XtPointer) True },\r
1151     { "reuseSecond", "reuseSecond", XtRBoolean,\r
1152         sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),\r
1153         XtRImmediate, (XtPointer) True },\r
1154     { "animateDragging", "animateDragging", XtRBoolean,\r
1155         sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),\r
1156         XtRImmediate, (XtPointer) True },\r
1157     { "animateMoving", "animateMoving", XtRBoolean,\r
1158         sizeof(Boolean), XtOffset(AppDataPtr, animate),\r
1159         XtRImmediate, (XtPointer) True },\r
1160     { "animateSpeed", "animateSpeed", XtRInt,\r
1161         sizeof(int), XtOffset(AppDataPtr, animSpeed),\r
1162         XtRImmediate, (XtPointer)10 },\r
1163     { "popupExitMessage", "popupExitMessage", XtRBoolean,\r
1164         sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),\r
1165         XtRImmediate, (XtPointer) True },\r
1166     { "popupMoveErrors", "popupMoveErrors", XtRBoolean,\r
1167         sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),\r
1168         XtRImmediate, (XtPointer) False },\r
1169     { "fontSizeTolerance", "fontSizeTolerance", XtRInt,\r
1170         sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),\r
1171         XtRImmediate, (XtPointer)4 },\r
1172     { "initialMode", "initialMode", XtRString,\r
1173         sizeof(String), XtOffset(AppDataPtr, initialMode),\r
1174         XtRImmediate, (XtPointer) "" },\r
1175     { "variant", "variant", XtRString,\r
1176         sizeof(String), XtOffset(AppDataPtr, variant),\r
1177         XtRImmediate, (XtPointer) "normal" },\r
1178     { "firstProtocolVersion", "firstProtocolVersion", XtRInt,\r
1179         sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),\r
1180         XtRImmediate, (XtPointer)PROTOVER },\r
1181     { "secondProtocolVersion", "secondProtocolVersion", XtRInt,\r
1182         sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),\r
1183         XtRImmediate, (XtPointer)PROTOVER },\r
1184     { "showButtonBar", "showButtonBar", XtRBoolean,\r
1185         sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),\r
1186         XtRImmediate, (XtPointer) True },\r
1187     {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean,        /* [DM] icsEngineAnalyze */\r
1188         sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),\r
1189         XtRImmediate, (XtPointer) False },\r
1190     { "firstScoreAbs", "firstScoreAbs", XtRBoolean,\r
1191         sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),\r
1192         XtRImmediate, (XtPointer) False },\r
1193     { "secondScoreAbs", "secondScoreAbs", XtRBoolean,\r
1194         sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),\r
1195         XtRImmediate, (XtPointer) False },\r
1196     { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,\r
1197         sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),\r
1198         XtRImmediate, (XtPointer) False },\r
1199     { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,\r
1200         sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),\r
1201         XtRImmediate, (XtPointer) True },\r
1202     { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,\r
1203         sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),\r
1204         XtRImmediate, (XtPointer) 0},\r
1205     { "pgnEventHeader", "pgnEventHeader", XtRString,\r
1206         sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),\r
1207         XtRImmediate, (XtPointer) "Computer Chess Game" },    \r
1208     { "defaultFrcPosition", "defaultFrcPositon", XtRInt,\r
1209         sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),\r
1210         XtRImmediate, (XtPointer) -1},\r
1211 \r
1212     // [HGM] 4.3.xx options\r
1213     { "boardWidth", "boardWidth", XtRInt,\r
1214         sizeof(int), XtOffset(AppDataPtr, NrFiles),\r
1215         XtRImmediate, (XtPointer) -1},\r
1216     { "boardHeight", "boardHeight", XtRInt,\r
1217         sizeof(int), XtOffset(AppDataPtr, NrRanks),\r
1218         XtRImmediate, (XtPointer) -1},\r
1219     { "matchPause", "matchPause", XtRInt,\r
1220         sizeof(int), XtOffset(AppDataPtr, matchPause),\r
1221         XtRImmediate, (XtPointer) 10000},\r
1222     { "holdingsSize", "holdingsSize", XtRInt,\r
1223         sizeof(int), XtOffset(AppDataPtr, holdingsSize),\r
1224         XtRImmediate, (XtPointer) -1},\r
1225     { "flipBlack", "flipBlack", XtRBoolean,\r
1226         sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),\r
1227         XtRImmediate, (XtPointer) False},\r
1228     { "allWhite", "allWhite", XtRBoolean,\r
1229         sizeof(Boolean), XtOffset(AppDataPtr, allWhite),\r
1230         XtRImmediate, (XtPointer) False},\r
1231     { "pieceToCharTable", "pieceToCharTable", XtRString,\r
1232         sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),\r
1233         XtRImmediate, (XtPointer) 0},\r
1234     { "alphaRank", "alphaRank", XtRBoolean,\r
1235         sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),\r
1236         XtRImmediate, (XtPointer) False},\r
1237     { "testClaims", "testClaims", XtRBoolean,\r
1238         sizeof(Boolean), XtOffset(AppDataPtr, testClaims),\r
1239         XtRImmediate, (XtPointer) True},\r
1240     { "checkMates", "checkMates", XtRBoolean,\r
1241         sizeof(Boolean), XtOffset(AppDataPtr, checkMates),\r
1242         XtRImmediate, (XtPointer) True},\r
1243     { "materialDraws", "materialDraws", XtRBoolean,\r
1244         sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),\r
1245         XtRImmediate, (XtPointer) True},\r
1246     { "trivialDraws", "trivialDraws", XtRBoolean,\r
1247         sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),\r
1248         XtRImmediate, (XtPointer) False},\r
1249     { "ruleMoves", "ruleMoves", XtRInt,\r
1250         sizeof(int), XtOffset(AppDataPtr, ruleMoves),\r
1251         XtRImmediate, (XtPointer) 51},\r
1252     { "repeatsToDraw", "repeatsToDraw", XtRInt,\r
1253         sizeof(int), XtOffset(AppDataPtr, drawRepeats),\r
1254         XtRImmediate, (XtPointer) 6},\r
1255     { "engineDebugOutput", "engineDebugOutput", XtRInt,\r
1256         sizeof(int), XtOffset(AppDataPtr, engineComments),\r
1257         XtRImmediate, (XtPointer) 1},\r
1258     { "userName", "userName", XtRString,\r
1259         sizeof(int), XtOffset(AppDataPtr, userName),\r
1260         XtRImmediate, (XtPointer) 0},\r
1261     { "autoKibitz", "autoKibitz", XtRBoolean,\r
1262         sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),\r
1263         XtRImmediate, (XtPointer) False},\r
1264     { "firstTimeOdds", "firstTimeOdds", XtRInt,\r
1265         sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),\r
1266         XtRImmediate, (XtPointer) 1},\r
1267     { "secondTimeOdds", "secondTimeOdds", XtRInt,\r
1268         sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),\r
1269         XtRImmediate, (XtPointer) 1},\r
1270     { "timeOddsMode", "timeOddsMode", XtRInt,\r
1271         sizeof(int), XtOffset(AppDataPtr, timeOddsMode),\r
1272         XtRImmediate, (XtPointer) 0},\r
1273     { "firstAccumulateTC", "firstAccumulateTC", XtRInt,\r
1274         sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),\r
1275         XtRImmediate, (XtPointer) 1},\r
1276     { "secondAccumulateTC", "secondAccumulateTC", XtRInt,\r
1277         sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),\r
1278         XtRImmediate, (XtPointer) 1},\r
1279     { "firstNPS", "firstNPS", XtRInt,\r
1280         sizeof(int), XtOffset(AppDataPtr, firstNPS),\r
1281         XtRImmediate, (XtPointer) -1},\r
1282     { "secondNPS", "secondNPS", XtRInt,\r
1283         sizeof(int), XtOffset(AppDataPtr, secondNPS),\r
1284         XtRImmediate, (XtPointer) -1},\r
1285     { "serverMoves", "serverMoves", XtRString,\r
1286         sizeof(String), XtOffset(AppDataPtr, serverMovesName),\r
1287         XtRImmediate, (XtPointer) 0},\r
1288     { "serverPause", "serverPause", XtRInt,\r
1289         sizeof(int), XtOffset(AppDataPtr, serverPause),\r
1290         XtRImmediate, (XtPointer) 0},\r
1291     { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,\r
1292         sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),\r
1293         XtRImmediate, (XtPointer) False},\r
1294     { "userName", "userName", XtRString,\r
1295         sizeof(String), XtOffset(AppDataPtr, userName),\r
1296         XtRImmediate, (XtPointer) 0},\r
1297     { "egtFormats", "egtFormats", XtRString,\r
1298         sizeof(String), XtOffset(AppDataPtr, egtFormats),\r
1299         XtRImmediate, (XtPointer) 0},\r
1300     { "rewindIndex", "rewindIndex", XtRInt,\r
1301         sizeof(int), XtOffset(AppDataPtr, rewindIndex),\r
1302         XtRImmediate, (XtPointer) 0},\r
1303     { "sameColorGames", "sameColorGames", XtRInt,\r
1304         sizeof(int), XtOffset(AppDataPtr, sameColorGames),\r
1305         XtRImmediate, (XtPointer) 0},\r
1306     { "smpCores", "smpCores", XtRInt,\r
1307         sizeof(int), XtOffset(AppDataPtr, smpCores),\r
1308         XtRImmediate, (XtPointer) 1},\r
1309     { "niceEngines", "niceEngines", XtRInt,\r
1310         sizeof(int), XtOffset(AppDataPtr, niceEngines),\r
1311         XtRImmediate, (XtPointer) 0},\r
1312     { "nameOfDebugFile", "nameOfDebugFile", XtRString,\r
1313         sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),\r
1314         XtRImmediate, (XtPointer) "xboard.debug"},\r
1315     { "noGUI", "noGUI", XtRBoolean,\r
1316         sizeof(Boolean), XtOffset(AppDataPtr, noGUI),\r
1317         XtRImmediate, (XtPointer) 0},\r
1318     { "firstOptions", "firstOptions", XtRString,\r
1319         sizeof(String), XtOffset(AppDataPtr, firstOptions),\r
1320         XtRImmediate, (XtPointer) "" },\r
1321     { "secondOptions", "secondOptions", XtRString,\r
1322         sizeof(String), XtOffset(AppDataPtr, secondOptions),\r
1323         XtRImmediate, (XtPointer) "" },\r
1324 \r
1325     // [HGM] Winboard_x UCI options\r
1326     { "firstIsUCI", "firstIsUCI", XtRBoolean,\r
1327         sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),\r
1328         XtRImmediate, (XtPointer) False},\r
1329     { "secondIsUCI", "secondIsUCI", XtRBoolean,\r
1330         sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),\r
1331         XtRImmediate, (XtPointer) False},\r
1332     { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,\r
1333         sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),\r
1334         XtRImmediate, (XtPointer) True},\r
1335     { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,\r
1336         sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),\r
1337         XtRImmediate, (XtPointer) True},\r
1338     { "usePolyglotBook", "usePolyglotBook", XtRBoolean,\r
1339         sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),\r
1340         XtRImmediate, (XtPointer) False},\r
1341     { "defaultHashSize", "defaultHashSize", XtRInt,\r
1342         sizeof(int), XtOffset(AppDataPtr, defaultHashSize),\r
1343         XtRImmediate, (XtPointer) 64},\r
1344     { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,\r
1345         sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),\r
1346         XtRImmediate, (XtPointer) 4},\r
1347     { "polyglotDir", "polyglotDir", XtRString,\r
1348         sizeof(String), XtOffset(AppDataPtr, polyglotDir),\r
1349         XtRImmediate, (XtPointer) "." },\r
1350     { "polyglotBook", "polyglotBook", XtRString,\r
1351         sizeof(String), XtOffset(AppDataPtr, polyglotBook),\r
1352         XtRImmediate, (XtPointer) "" },    \r
1353     { "defaultPathEGTB", "defaultPathEGTB", XtRString,\r
1354         sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),\r
1355         XtRImmediate, (XtPointer) "/usr/local/share/egtb"},\r
1356     { "delayBeforeQuit", "delayBeforeQuit", XtRInt,\r
1357         sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),\r
1358         XtRImmediate, (XtPointer) 0},\r
1359     { "delayAfterQuit", "delayAfterQuit", XtRInt,\r
1360         sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),\r
1361         XtRImmediate, (XtPointer) 0},\r
1362 };\r
1363 \r
1364 XrmOptionDescRec shellOptions[] = {\r
1365     { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },\r
1366     { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },\r
1367     { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },\r
1368     { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },\r
1369     { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },\r
1370     { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},\r
1371     { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },\r
1372     { "-mps", "movesPerSession", XrmoptionSepArg, NULL },\r
1373     { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },\r
1374     { "-inc", "timeIncrement", XrmoptionSepArg, NULL },\r
1375     { "-initString", "initString", XrmoptionSepArg, NULL },\r
1376     { "-firstInitString", "initString", XrmoptionSepArg, NULL },\r
1377     { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },\r
1378     { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },\r
1379     { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },\r
1380     { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },\r
1381     { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },\r
1382     { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },\r
1383     { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },\r
1384     { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },\r
1385     { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },\r
1386     { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },\r
1387     { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },\r
1388     { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },\r
1389     { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },\r
1390     { "-firstHost", "firstHost", XrmoptionSepArg, NULL },\r
1391     { "-fh", "firstHost", XrmoptionSepArg, NULL },\r
1392     { "-secondHost", "secondHost", XrmoptionSepArg, NULL },\r
1393     { "-sh", "secondHost", XrmoptionSepArg, NULL },\r
1394     { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },\r
1395     { "-fd", "firstDirectory", XrmoptionSepArg, NULL },\r
1396     { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },\r
1397     { "-sd", "secondDirectory", XrmoptionSepArg, NULL },\r
1398     { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },\r
1399     { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },\r
1400     { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },\r
1401     { "-rsh", "remoteShell", XrmoptionSepArg, NULL },\r
1402     { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },\r
1403     { "-ruser", "remoteUser", XrmoptionSepArg, NULL },\r
1404     { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },\r
1405     { "-td", "timeDelay", XrmoptionSepArg, NULL },\r
1406     { "-timeControl", "timeControl", XrmoptionSepArg, NULL },\r
1407     { "-tc", "timeControl", XrmoptionSepArg, NULL },\r
1408     { "-internetChessServerMode", "internetChessServerMode",\r
1409         XrmoptionSepArg, NULL },\r
1410     { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },\r
1411     { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },\r
1412     { "-internetChessServerHost", "internetChessServerHost",\r
1413         XrmoptionSepArg, NULL },\r
1414     { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },\r
1415     { "-internetChessServerPort", "internetChessServerPort",\r
1416         XrmoptionSepArg, NULL },\r
1417     { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },\r
1418     { "-internetChessServerCommPort", "internetChessServerCommPort",\r
1419         XrmoptionSepArg, NULL },\r
1420     { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },\r
1421     { "-internetChessServerLogonScript", "internetChessServerLogonScript",\r
1422         XrmoptionSepArg, NULL },\r
1423     { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },\r
1424     { "-internetChessServerHelper", "internetChessServerHelper",\r
1425         XrmoptionSepArg, NULL },\r
1426     { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },\r
1427     { "-internetChessServerInputBox", "internetChessServerInputBox",\r
1428         XrmoptionSepArg, NULL },\r
1429     { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },\r
1430     { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },\r
1431     { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },\r
1432     { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },\r
1433     { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },\r
1434     { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },\r
1435     { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },\r
1436     { "-telnet", "useTelnet", XrmoptionNoArg, "True" },\r
1437     { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },\r
1438     { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },\r
1439     { "-gateway", "gateway", XrmoptionSepArg, NULL },\r
1440     { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },\r
1441     { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },\r
1442     { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },\r
1443     { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },\r
1444     { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },\r
1445     { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },\r
1446     { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },\r
1447     { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },\r
1448     { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },\r
1449     { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },\r
1450     { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },\r
1451     { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },\r
1452     { "-blindfold", "blindfold", XrmoptionSepArg, NULL },\r
1453     { "-blind", "blindfold", XrmoptionNoArg, "True" },\r
1454     { "-xblind", "blindfold", XrmoptionNoArg, "False" },\r
1455     { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },\r
1456     { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },\r
1457     { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },\r
1458     { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },\r
1459     { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },\r
1460     { "-spf", "savePositionFile", XrmoptionSepArg, NULL },\r
1461     { "-matchMode", "matchMode", XrmoptionSepArg, NULL },\r
1462     { "-mm", "matchMode", XrmoptionNoArg, "True" },\r
1463     { "-xmm", "matchMode", XrmoptionNoArg, "False" },\r
1464     { "-matchGames", "matchGames", XrmoptionSepArg, NULL },\r
1465     { "-mg", "matchGames", XrmoptionSepArg, NULL },\r
1466     { "-monoMode", "monoMode", XrmoptionSepArg, NULL },\r
1467     { "-mono", "monoMode", XrmoptionNoArg, "True" },\r
1468     { "-xmono", "monoMode", XrmoptionNoArg, "False" },\r
1469     { "-debugMode", "debugMode", XrmoptionSepArg, NULL },\r
1470     { "-debug", "debugMode", XrmoptionNoArg, "True" },\r
1471     { "-xdebug", "debugMode", XrmoptionNoArg, "False" },\r
1472     { "-clockMode", "clockMode", XrmoptionSepArg, NULL },\r
1473     { "-clock", "clockMode", XrmoptionNoArg, "True" },\r
1474     { "-xclock", "clockMode", XrmoptionNoArg, "False" },\r
1475     { "-boardSize", "boardSize", XrmoptionSepArg, NULL },\r
1476     { "-size", "boardSize", XrmoptionSepArg, NULL },\r
1477     { "-searchTime", "searchTime", XrmoptionSepArg, NULL },\r
1478     { "-st", "searchTime", XrmoptionSepArg, NULL },\r
1479     { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },\r
1480     { "-depth", "searchDepth", XrmoptionSepArg, NULL },\r
1481     { "-showCoords", "showCoords", XrmoptionSepArg, NULL },\r
1482     { "-coords", "showCoords", XrmoptionNoArg, "True" },\r
1483     { "-xcoords", "showCoords", XrmoptionNoArg, "False" },\r
1484 #if JAIL\r
1485     { "-showJail", "showJail", XrmoptionSepArg, NULL },\r
1486     { "-jail", "showJail", XrmoptionNoArg, "1" },\r
1487     { "-sidejail", "showJail", XrmoptionNoArg, "2" },\r
1488     { "-xjail", "showJail", XrmoptionNoArg, "0" },\r
1489 #endif\r
1490     { "-showThinking", "showThinking", XrmoptionSepArg, NULL },\r
1491     { "-thinking", "showThinking", XrmoptionNoArg, "True" },\r
1492     { "-xthinking", "showThinking", XrmoptionNoArg, "False" },\r
1493     { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },\r
1494     { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },\r
1495     { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },\r
1496     { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },\r
1497     { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },\r
1498     { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },\r
1499     { "-clockFont", "clockFont", XrmoptionSepArg, NULL },\r
1500     { "-coordFont", "coordFont", XrmoptionSepArg, NULL },\r
1501     { "-font", "font", XrmoptionSepArg, NULL },\r
1502     { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },\r
1503     { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },\r
1504     { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },\r
1505     { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },\r
1506     { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },\r
1507     { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },\r
1508     { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },\r
1509     { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },\r
1510     { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },\r
1511     { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },\r
1512     { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },\r
1513     { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },\r
1514     { "-autobs", "autoObserve", XrmoptionNoArg, "True" },\r
1515     { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },\r
1516     { "-autoComment", "autoComment", XrmoptionSepArg, NULL },\r
1517     { "-autocomm", "autoComment", XrmoptionNoArg, "True" },\r
1518     { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },\r
1519     { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },\r
1520     { "-moves", "getMoveList", XrmoptionNoArg, "True" },\r
1521     { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },\r
1522 #if HIGHDRAG\r
1523     { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },\r
1524     { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },\r
1525     { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },\r
1526 #endif\r
1527     { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },\r
1528     { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },\r
1529     { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },\r
1530     { "-premove", "premove", XrmoptionSepArg, NULL },\r
1531     { "-pre", "premove", XrmoptionNoArg, "True" },\r
1532     { "-xpre", "premove", XrmoptionNoArg, "False" },\r
1533     { "-testLegality", "testLegality", XrmoptionSepArg, NULL },\r
1534     { "-legal", "testLegality", XrmoptionNoArg, "True" },\r
1535     { "-xlegal", "testLegality", XrmoptionNoArg, "False" },\r
1536     { "-flipView", "flipView", XrmoptionSepArg, NULL },\r
1537     { "-flip", "flipView", XrmoptionNoArg, "True" },\r
1538     { "-xflip", "flipView", XrmoptionNoArg, "False" },\r
1539     { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },\r
1540     { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",\r
1541         XrmoptionSepArg, NULL },\r
1542     { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },\r
1543     { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },\r
1544     { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },\r
1545     { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },\r
1546     { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },\r
1547     { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },\r
1548     { "-quiet", "quietPlay", XrmoptionNoArg, "True" },\r
1549     { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },\r
1550     { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },\r
1551     { "-title", "titleInWindow", XrmoptionNoArg, "True" },\r
1552     { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },\r
1553 #ifdef ZIPPY\r
1554     { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },\r
1555     { "-zt", "zippyTalk", XrmoptionNoArg, "True" },\r
1556     { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },\r
1557     { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },\r
1558     { "-zp", "zippyPlay", XrmoptionNoArg, "True" },\r
1559     { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },\r
1560     { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },\r
1561     { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },\r
1562     { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },\r
1563     { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },\r
1564     { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },\r
1565     { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },\r
1566     { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },\r
1567     { "-zui", "zippyUseI", XrmoptionNoArg, "True" },\r
1568     { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },\r
1569     { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },\r
1570     { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },\r
1571     { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },\r
1572     { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },\r
1573     { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },\r
1574     { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },\r
1575     { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },\r
1576     { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },\r
1577     { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },\r
1578     { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },\r
1579     { "-zab", "zippyAbort", XrmoptionNoArg, "True" },\r
1580     { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },\r
1581     { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },\r
1582     { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },\r
1583     { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },\r
1584 #endif\r
1585     { "-flashCount", "flashCount", XrmoptionSepArg, NULL },\r
1586     { "-flash", "flashCount", XrmoptionNoArg, "3" },\r
1587     { "-xflash", "flashCount", XrmoptionNoArg, "0" },\r
1588     { "-flashRate", "flashRate", XrmoptionSepArg, NULL },\r
1589     { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },\r
1590     { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },\r
1591     { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },\r
1592     { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },\r
1593     { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },\r
1594     { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },\r
1595     { "-colorShout", "colorShout", XrmoptionSepArg, NULL },\r
1596     { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },\r
1597     { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/\r
1598     { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },\r
1599     { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },\r
1600     { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },\r
1601     { "-colorTell", "colorTell", XrmoptionSepArg, NULL },\r
1602     { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },\r
1603     { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },\r
1604     { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },\r
1605     { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },\r
1606     { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },\r
1607     { "-soundShout", "soundShout", XrmoptionSepArg, NULL },\r
1608     { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },\r
1609     { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/\r
1610     { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },\r
1611     { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },\r
1612     { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },\r
1613     { "-soundTell", "soundTell", XrmoptionSepArg, NULL },\r
1614     { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },\r
1615     { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },\r
1616     { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },\r
1617     { "-soundMove", "soundMove", XrmoptionSepArg, NULL },\r
1618     { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },\r
1619     { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },\r
1620     { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },\r
1621     { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },\r
1622     { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },\r
1623     { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },\r
1624     { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/\r
1625     { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },\r
1626     { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },\r
1627     { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },\r
1628     { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },\r
1629     { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },\r
1630     { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },\r
1631     { "-animate", "animateMoving", XrmoptionNoArg, "True" },\r
1632     { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },\r
1633     { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },\r
1634     { "-drag", "animateDragging", XrmoptionNoArg, "True" },\r
1635     { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },\r
1636     { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },\r
1637     { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },\r
1638     { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },\r
1639     { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },\r
1640     { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },\r
1641     { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },\r
1642     { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },\r
1643     { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },\r
1644     { "-initialMode", "initialMode", XrmoptionSepArg, NULL },\r
1645     { "-mode", "initialMode", XrmoptionSepArg, NULL },\r
1646     { "-variant", "variant", XrmoptionSepArg, NULL },\r
1647     { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },\r
1648     { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },\r
1649     { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },\r
1650     { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },\r
1651     { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },\r
1652     /* [AS,HR] New features */\r
1653     { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },\r
1654     { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },\r
1655     { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },\r
1656     { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },\r
1657     { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },\r
1658     { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },\r
1659     { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },\r
1660     { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },\r
1661     { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },\r
1662     { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },\r
1663     { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },\r
1664     { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },\r
1665     { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },\r
1666     { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },\r
1667     { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },\r
1668     { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },\r
1669     { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },\r
1670     { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },\r
1671     { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },\r
1672     { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },\r
1673     { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },\r
1674     { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },\r
1675     { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },\r
1676     // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c\r
1677 \r
1678     /* [HGM,HR] User-selectable board size */\r
1679     { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL }, \r
1680     { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL }, \r
1681     { "-matchPause", "matchPause", XrmoptionSepArg, NULL }, \r
1682 \r
1683     /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */\r
1684     { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work\r
1685     { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL },       // requires front-end changes to work\r
1686     { "-allWhite", "allWhite", XrmoptionSepArg, NULL },         // requires front-end changes to work\r
1687     { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL }, \r
1688     { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL }, \r
1689     { "-testClaims", "testClaims", XrmoptionSepArg, NULL }, \r
1690     { "-checkMates", "checkMates", XrmoptionSepArg, NULL }, \r
1691     { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL }, \r
1692     { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL }, \r
1693     { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL }, \r
1694     { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },\r
1695     { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL }, \r
1696     { "-userName", "userName", XrmoptionSepArg, NULL }, \r
1697     { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" }, \r
1698     { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL }, \r
1699     { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL }, \r
1700     { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL }, \r
1701     { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL }, \r
1702     { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL }, \r
1703     { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL }, \r
1704     { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL }, \r
1705     { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL }, \r
1706     { "-serverPause", "serverPause", XrmoptionSepArg, NULL }, \r
1707     { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL }, \r
1708     { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL }, \r
1709     { "-userName", "userName", XrmoptionSepArg, NULL }, \r
1710     { "-smpCores", "smpCores", XrmoptionSepArg, NULL }, \r
1711     { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL }, \r
1712     { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL }, \r
1713     { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL }, \r
1714     { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL }, \r
1715     { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL }, \r
1716     { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL }, \r
1717     { "-noGUI", "noGUI", XrmoptionNoArg, "True" }, \r
1718     { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL }, \r
1719     { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL }, \r
1720 };\r
1721 \r
1722 \r
1723 XtActionsRec boardActions[] = {\r
1724     { "DrawPosition", DrawPositionProc },\r
1725     { "HandleUserMove", HandleUserMove },\r
1726     { "AnimateUserMove", AnimateUserMove },\r
1727     { "FileNameAction", FileNameAction },\r
1728     { "AskQuestionProc", AskQuestionProc },\r
1729     { "AskQuestionReplyAction", AskQuestionReplyAction },\r
1730     { "PieceMenuPopup", PieceMenuPopup },\r
1731     { "WhiteClock", WhiteClock },\r
1732     { "BlackClock", BlackClock },\r
1733     { "Iconify", Iconify },\r
1734     { "ResetProc", ResetProc },\r
1735     { "LoadGameProc", LoadGameProc },\r
1736     { "LoadNextGameProc", LoadNextGameProc },\r
1737     { "LoadPrevGameProc", LoadPrevGameProc },\r
1738     { "LoadSelectedProc", LoadSelectedProc },\r
1739     { "ReloadGameProc", ReloadGameProc },\r
1740     { "LoadPositionProc", LoadPositionProc },\r
1741     { "LoadNextPositionProc", LoadNextPositionProc },\r
1742     { "LoadPrevPositionProc", LoadPrevPositionProc },\r
1743     { "ReloadPositionProc", ReloadPositionProc },\r
1744     { "CopyPositionProc", CopyPositionProc },\r
1745     { "PastePositionProc", PastePositionProc },\r
1746     { "CopyGameProc", CopyGameProc },\r
1747     { "PasteGameProc", PasteGameProc },\r
1748     { "SaveGameProc", SaveGameProc },\r
1749     { "SavePositionProc", SavePositionProc },\r
1750     { "MailMoveProc", MailMoveProc },\r
1751     { "ReloadCmailMsgProc", ReloadCmailMsgProc },\r
1752     { "QuitProc", QuitProc },\r
1753     { "MachineWhiteProc", MachineWhiteProc },\r
1754     { "MachineBlackProc", MachineBlackProc },\r
1755     { "AnalysisModeProc", AnalyzeModeProc },\r
1756     { "AnalyzeFileProc", AnalyzeFileProc },\r
1757     { "TwoMachinesProc", TwoMachinesProc },\r
1758     { "IcsClientProc", IcsClientProc },\r
1759     { "EditGameProc", EditGameProc },\r
1760     { "EditPositionProc", EditPositionProc },\r
1761     { "TrainingProc", EditPositionProc },\r
1762     { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window\r
1763     { "ShowGameListProc", ShowGameListProc },\r
1764     { "ShowMoveListProc", HistoryShowProc},\r
1765     { "EditTagsProc", EditCommentProc },\r
1766     { "EditCommentProc", EditCommentProc },\r
1767     { "IcsAlarmProc", IcsAlarmProc },\r
1768     { "IcsInputBoxProc", IcsInputBoxProc },\r
1769     { "PauseProc", PauseProc },\r
1770     { "AcceptProc", AcceptProc },\r
1771     { "DeclineProc", DeclineProc },\r
1772     { "RematchProc", RematchProc },\r
1773     { "CallFlagProc", CallFlagProc },\r
1774     { "DrawProc", DrawProc },\r
1775     { "AdjournProc", AdjournProc },\r
1776     { "AbortProc", AbortProc },\r
1777     { "ResignProc", ResignProc },\r
1778     { "EnterKeyProc", EnterKeyProc },\r
1779     { "StopObservingProc", StopObservingProc },\r
1780     { "StopExaminingProc", StopExaminingProc },\r
1781     { "BackwardProc", BackwardProc },\r
1782     { "ForwardProc", ForwardProc },\r
1783     { "ToStartProc", ToStartProc },\r
1784     { "ToEndProc", ToEndProc },\r
1785     { "RevertProc", RevertProc },\r
1786     { "TruncateGameProc", TruncateGameProc },\r
1787     { "MoveNowProc", MoveNowProc },\r
1788     { "RetractMoveProc", RetractMoveProc },\r
1789     { "AlwaysQueenProc", AlwaysQueenProc },\r
1790     { "AnimateDraggingProc", AnimateDraggingProc },\r
1791     { "AnimateMovingProc", AnimateMovingProc },\r
1792     { "AutoflagProc", AutoflagProc },\r
1793     { "AutoflipProc", AutoflipProc },\r
1794     { "AutobsProc", AutobsProc },\r
1795     { "AutoraiseProc", AutoraiseProc },\r
1796     { "AutosaveProc", AutosaveProc },\r
1797     { "BlindfoldProc", BlindfoldProc },\r
1798     { "FlashMovesProc", FlashMovesProc },\r
1799     { "FlipViewProc", FlipViewProc },\r
1800     { "GetMoveListProc", GetMoveListProc },\r
1801 #if HIGHDRAG\r
1802     { "HighlightDraggingProc", HighlightDraggingProc },\r
1803 #endif\r
1804     { "HighlightLastMoveProc", HighlightLastMoveProc },\r
1805     { "IcsAlarmProc", IcsAlarmProc },\r
1806     { "MoveSoundProc", MoveSoundProc },\r
1807     { "OldSaveStyleProc", OldSaveStyleProc },\r
1808     { "PeriodicUpdatesProc", PeriodicUpdatesProc },     \r
1809     { "PonderNextMoveProc", PonderNextMoveProc },\r
1810     { "PopupExitMessageProc", PopupExitMessageProc },   \r
1811     { "PopupMoveErrorsProc", PopupMoveErrorsProc },     \r
1812     { "PremoveProc", PremoveProc },\r
1813     { "QuietPlayProc", QuietPlayProc },\r
1814     { "ShowCoordsProc", ShowCoordsProc },\r
1815     { "ShowThinkingProc", ShowThinkingProc },\r
1816     { "HideThinkingProc", HideThinkingProc },\r
1817     { "TestLegalityProc", TestLegalityProc },\r
1818     { "InfoProc", InfoProc },\r
1819     { "ManProc", ManProc },\r
1820     { "HintProc", HintProc },\r
1821     { "BookProc", BookProc },\r
1822     { "AboutGameProc", AboutGameProc },\r
1823     { "AboutProc", AboutProc },\r
1824     { "DebugProc", DebugProc },\r
1825     { "NothingProc", NothingProc },\r
1826     { "CommentPopDown", (XtActionProc) CommentPopDown },\r
1827     { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },\r
1828     { "TagsPopDown", (XtActionProc) TagsPopDown },\r
1829     { "ErrorPopDown", (XtActionProc) ErrorPopDown },\r
1830     { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },\r
1831     { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },\r
1832     { "FileNamePopDown", (XtActionProc) FileNamePopDown },\r
1833     { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },\r
1834     { "GameListPopDown", (XtActionProc) GameListPopDown },\r
1835     { "PromotionPopDown", (XtActionProc) PromotionPopDown },\r
1836     { "HistoryPopDown", (XtActionProc) HistoryPopDown },\r
1837     { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },\r
1838     { "ShufflePopDown", (XtActionProc) ShufflePopDown },\r
1839     { "EnginePopDown", (XtActionProc) EnginePopDown },\r
1840     { "UciPopDown", (XtActionProc) UciPopDown },\r
1841     { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },\r
1842     { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },\r
1843     { "SettingsPopDown", (XtActionProc) SettingsPopDown },\r
1844 };\r
1845      \r
1846 char globalTranslations[] =\r
1847   ":<Key>R: ResignProc() \n \\r
1848    :<Key>r: ResetProc() \n \\r
1849    :<Key>g: LoadGameProc() \n \\r
1850    :<Key>N: LoadNextGameProc() \n \\r
1851    :<Key>P: LoadPrevGameProc() \n \\r
1852    :<Key>Q: QuitProc() \n \\r
1853    :<Key>F: ToEndProc() \n \\r
1854    :<Key>f: ForwardProc() \n \\r
1855    :<Key>B: ToStartProc() \n \\r
1856    :<Key>b: BackwardProc() \n \\r
1857    :<Key>p: PauseProc() \n \\r
1858    :<Key>d: DrawProc() \n \\r
1859    :<Key>t: CallFlagProc() \n \\r
1860    :<Key>i: Iconify() \n \\r
1861    :<Key>c: Iconify() \n \\r
1862    :<Key>v: FlipViewProc() \n \\r
1863    <KeyDown>Control_L: BackwardProc() \n \\r
1864    <KeyUp>Control_L: ForwardProc() \n \\r
1865    <KeyDown>Control_R: BackwardProc() \n \\r
1866    <KeyUp>Control_R: ForwardProc() \n \\r
1867    Shift<Key>1: AskQuestionProc(\"Direct command\",\\r
1868                                 \"Send to chess program:\",,1) \n \\r
1869    Shift<Key>2: AskQuestionProc(\"Direct command\",\\r
1870                                 \"Send to second chess program:\",,2) \n";\r
1871 \r
1872 char boardTranslations[] =\r
1873    "<Btn1Down>: HandleUserMove() \n \\r
1874    <Btn1Up>: HandleUserMove() \n \\r
1875    <Btn1Motion>: AnimateUserMove() \n \\r
1876    Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\\r
1877                  PieceMenuPopup(menuB) \n \\r
1878    Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \\r
1879                  PieceMenuPopup(menuW) \n \\r
1880    Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\\r
1881                  PieceMenuPopup(menuW) \n \\r
1882    Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \\r
1883                  PieceMenuPopup(menuB) \n";\r
1884      \r
1885 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";\r
1886 char blackTranslations[] = "<BtnDown>: BlackClock()\n";\r
1887      \r
1888 char ICSInputTranslations[] =\r
1889     "<Key>Return: EnterKeyProc() \n";\r
1890 \r
1891 String xboardResources[] = {\r
1892     "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",\r
1893     "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",\r
1894     "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",\r
1895     NULL\r
1896   };\r
1897      \r
1898 \r
1899 /* Max possible square size */\r
1900 #define MAXSQSIZE 256\r
1901 \r
1902 static int xpm_avail[MAXSQSIZE];\r
1903 \r
1904 #ifdef HAVE_DIR_STRUCT\r
1905 \r
1906 /* Extract piece size from filename */\r
1907 static int\r
1908 xpm_getsize(name, len, ext)\r
1909      char *name;\r
1910      int len;\r
1911      char *ext;\r
1912 {\r
1913     char *p, *d;\r
1914     char buf[10];\r
1915   \r
1916     if (len < 4)\r
1917       return 0;\r
1918 \r
1919     if ((p=strchr(name, '.')) == NULL ||\r
1920         StrCaseCmp(p+1, ext) != 0)\r
1921       return 0;\r
1922   \r
1923     p = name + 3;\r
1924     d = buf;\r
1925 \r
1926     while (*p && isdigit(*p))\r
1927       *(d++) = *(p++);\r
1928 \r
1929     *d = 0;\r
1930     return atoi(buf);\r
1931 }\r
1932 \r
1933 /* Setup xpm_avail */\r
1934 static int\r
1935 xpm_getavail(dirname, ext)\r
1936      char *dirname;\r
1937      char *ext;\r
1938 {\r
1939     DIR *dir;\r
1940     struct dirent *ent;\r
1941     int  i;\r
1942 \r
1943     for (i=0; i<MAXSQSIZE; ++i)\r
1944       xpm_avail[i] = 0;\r
1945 \r
1946     if (appData.debugMode)\r
1947       fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);\r
1948   \r
1949     dir = opendir(dirname);\r
1950     if (!dir)\r
1951       {\r
1952           fprintf(stderr, _("%s: Can't access XPM directory %s\n"), \r
1953                   programName, dirname);\r
1954           exit(1);\r
1955       }\r
1956   \r
1957     while ((ent=readdir(dir)) != NULL) {\r
1958         i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);\r
1959         if (i > 0 && i < MAXSQSIZE)\r
1960           xpm_avail[i] = 1;\r
1961     }\r
1962 \r
1963     closedir(dir);\r
1964 \r
1965     return 0;\r
1966 }\r
1967 \r
1968 void\r
1969 xpm_print_avail(fp, ext)\r
1970      FILE *fp;\r
1971      char *ext;\r
1972 {\r
1973     int i;\r
1974 \r
1975     fprintf(fp, _("Available `%s' sizes:\n"), ext);\r
1976     for (i=1; i<MAXSQSIZE; ++i) {\r
1977         if (xpm_avail[i])\r
1978           printf("%d\n", i);\r
1979     }\r
1980 }\r
1981 \r
1982 /* Return XPM piecesize closest to size */\r
1983 int\r
1984 xpm_closest_to(dirname, size, ext)\r
1985      char *dirname;\r
1986      int size;\r
1987      char *ext;\r
1988 {\r
1989     int i;\r
1990     int sm_diff = MAXSQSIZE;\r
1991     int sm_index = 0;\r
1992     int diff;\r
1993   \r
1994     xpm_getavail(dirname, ext);\r
1995 \r
1996     if (appData.debugMode)\r
1997       xpm_print_avail(stderr, ext);\r
1998   \r
1999     for (i=1; i<MAXSQSIZE; ++i) {\r
2000         if (xpm_avail[i]) {\r
2001             diff = size - i;\r
2002             diff = (diff<0) ? -diff : diff;\r
2003             if (diff < sm_diff) {\r
2004                 sm_diff = diff;\r
2005                 sm_index = i;\r
2006             }\r
2007         }\r
2008     }\r
2009 \r
2010     if (!sm_index) {\r
2011         fprintf(stderr, _("Error: No `%s' files!\n"), ext);\r
2012         exit(1);\r
2013     }\r
2014 \r
2015     return sm_index;\r
2016 }\r
2017 #else   /* !HAVE_DIR_STRUCT */\r
2018 /* If we are on a system without a DIR struct, we can't\r
2019    read the directory, so we can't collect a list of\r
2020    filenames, etc., so we can't do any size-fitting. */\r
2021 int\r
2022 xpm_closest_to(dirname, size, ext)\r
2023      char *dirname;\r
2024      int size;\r
2025      char *ext;\r
2026 {\r
2027     fprintf(stderr, _("\\r
2028 Warning: No DIR structure found on this system --\n\\r
2029          Unable to autosize for XPM/XIM pieces.\n\\r
2030    Please report this error to frankm@hiwaay.net.\n\\r
2031    Include system type & operating system in message.\n"));\r
2032     return size;\r
2033 }\r
2034 #endif /* HAVE_DIR_STRUCT */\r
2035 \r
2036 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",\r
2037                              "magenta", "cyan", "white" };\r
2038 typedef struct {\r
2039     int attr, bg, fg;\r
2040 } TextColors;\r
2041 TextColors textColors[(int)NColorClasses];\r
2042 \r
2043 /* String is: "fg, bg, attr". Which is 0, 1, 2 */\r
2044 static int\r
2045 parse_color(str, which)\r
2046      char *str;\r
2047      int which;\r
2048 {\r
2049     char *p, buf[100], *d;\r
2050     int i;\r
2051   \r
2052     if (strlen(str) > 99)       /* watch bounds on buf */\r
2053       return -1;\r
2054 \r
2055     p = str;\r
2056     d = buf;\r
2057     for (i=0; i<which; ++i) {\r
2058         p = strchr(p, ',');\r
2059         if (!p)\r
2060           return -1;\r
2061         ++p;\r
2062     }\r
2063 \r
2064     /* Could be looking at something like:\r
2065        black, , 1\r
2066        .. in which case we want to stop on a comma also */\r
2067     while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))\r
2068       ++p;\r
2069 \r
2070     if (*p == ',') {\r
2071         return -1;              /* Use default for empty field */\r
2072     }\r
2073     \r
2074     if (which == 2 || isdigit(*p))\r
2075       return atoi(p);\r
2076  \r
2077     while (*p && isalpha(*p))\r
2078       *(d++) = *(p++);\r
2079 \r
2080     *d = 0;\r
2081 \r
2082     for (i=0; i<8; ++i) {\r
2083         if (!StrCaseCmp(buf, cnames[i]))\r
2084           return which? (i+40) : (i+30);\r
2085     }\r
2086     if (!StrCaseCmp(buf, "default")) return -1;\r
2087 \r
2088     fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);\r
2089     return -2;\r
2090 }\r
2091 \r
2092 static int\r
2093 parse_cpair(cc, str)\r
2094      ColorClass cc;\r
2095      char *str;\r
2096 {\r
2097     if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {\r
2098         fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),\r
2099                 programName, str);\r
2100         return -1;\r
2101     }\r
2102 \r
2103     /* bg and attr are optional */\r
2104     textColors[(int)cc].bg = parse_color(str, 1);\r
2105     if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {\r
2106         textColors[(int)cc].attr = 0;\r
2107     }\r
2108     return 0;\r
2109 }\r
2110 \r
2111 \r
2112 /* Arrange to catch delete-window events */\r
2113 Atom wm_delete_window;\r
2114 void\r
2115 CatchDeleteWindow(Widget w, String procname)\r
2116 {\r
2117   char buf[MSG_SIZ];\r
2118   XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);\r
2119   sprintf(buf, "<Message>WM_PROTOCOLS: %s() \n", procname);\r
2120   XtAugmentTranslations(w, XtParseTranslationTable(buf));\r
2121 }\r
2122 \r
2123 void\r
2124 BoardToTop()\r
2125 {\r
2126   Arg args[16];\r
2127   XtSetArg(args[0], XtNiconic, False);\r
2128   XtSetValues(shellWidget, args, 1);\r
2129 \r
2130   XtPopup(shellWidget, XtGrabNone); /* Raise if lowered  */\r
2131 }\r
2132 \r
2133 #ifdef IDSIZES\r
2134   // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined\r
2135 #else\r
2136 #define BoardSize int\r
2137 void InitDrawingSizes(BoardSize boardSize, int flags)\r
2138 {   // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)\r
2139     Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;\r
2140     Arg args[16];\r
2141     XtGeometryResult gres;\r
2142     int i;\r
2143 \r
2144     if(!formWidget) return;\r
2145 \r
2146     /*\r
2147      * Enable shell resizing.\r
2148      */\r
2149     shellArgs[0].value = (XtArgVal) &w;\r
2150     shellArgs[1].value = (XtArgVal) &h;\r
2151     XtGetValues(shellWidget, shellArgs, 2);\r
2152 \r
2153     shellArgs[4].value = 2*w; shellArgs[2].value = 10;\r
2154     shellArgs[5].value = 2*h; shellArgs[3].value = 10;\r
2155     XtSetValues(shellWidget, &shellArgs[2], 4);\r
2156 \r
2157     XtSetArg(args[0], XtNdefaultDistance, &sep);\r
2158     XtGetValues(formWidget, args, 1);\r
2159 \r
2160     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);\r
2161     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);\r
2162     CreateGrid();\r
2163 \r
2164     XtSetArg(args[0], XtNwidth, boardWidth);\r
2165     XtSetArg(args[1], XtNheight, boardHeight);\r
2166     XtSetValues(boardWidget, args, 2);\r
2167 \r
2168     timerWidth = (boardWidth - sep) / 2;\r
2169     XtSetArg(args[0], XtNwidth, timerWidth);\r
2170     XtSetValues(whiteTimerWidget, args, 1);\r
2171     XtSetValues(blackTimerWidget, args, 1);\r
2172 \r
2173     XawFormDoLayout(formWidget, False);\r
2174 \r
2175     if (appData.titleInWindow) {\r
2176         i = 0;\r
2177         XtSetArg(args[i], XtNborderWidth, &bor); i++;\r
2178         XtSetArg(args[i], XtNheight, &h);  i++;\r
2179         XtGetValues(titleWidget, args, i);\r
2180         if (smallLayout) {\r
2181             w = boardWidth - 2*bor;\r
2182         } else {\r
2183             XtSetArg(args[0], XtNwidth, &w);\r
2184             XtGetValues(menuBarWidget, args, 1);\r
2185             w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE\r
2186         }\r
2187 \r
2188         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);\r
2189         if (gres != XtGeometryYes && appData.debugMode) {\r
2190             fprintf(stderr,\r
2191                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),\r
2192                     programName, gres, w, h, wr, hr);\r
2193         }\r
2194     }\r
2195 \r
2196     XawFormDoLayout(formWidget, True);\r
2197 \r
2198     /*\r
2199      * Inhibit shell resizing.\r
2200      */\r
2201     shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;\r
2202     shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;\r
2203     shellArgs[4].value = shellArgs[2].value = w;\r
2204     shellArgs[5].value = shellArgs[3].value = h;\r
2205     XtSetValues(shellWidget, &shellArgs[0], 6);\r
2206 }\r
2207 #endif\r
2208 \r
2209 int\r
2210 main(argc, argv)\r
2211      int argc;\r
2212      char **argv;\r
2213 {\r
2214     int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;\r
2215     XSetWindowAttributes window_attributes;\r
2216     Arg args[16];\r
2217     Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;\r
2218     XrmValue vFrom, vTo;\r
2219     XtGeometryResult gres;\r
2220     char *p;\r
2221     XrmDatabase xdb;\r
2222     int forceMono = False;\r
2223 #define INDIRECTION\r
2224 #ifdef INDIRECTION\r
2225     // [HGM] before anything else, expand any indirection files amongst options\r
2226     char *argvCopy[1000]; // 1000 seems enough\r
2227     char newArgs[10000];  // holds actual characters\r
2228     int k = 0;\r
2229 \r
2230     srandom(time(0)); // [HGM] book: make random truly random\r
2231 \r
2232     j = 0;\r
2233     for(i=0; i<argc; i++) {\r
2234         if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }\r
2235 //fprintf(stderr, "arg %s\n", argv[i]);\r
2236         if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {\r
2237             char c;\r
2238             FILE *f = fopen(argv[i]+1, "rb");\r
2239             if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing\r
2240             argvCopy[j++] = newArgs + k; // get ready for first argument from file\r
2241             while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list\r
2242                 if(c == '\n') {\r
2243                     if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }\r
2244                     newArgs[k++] = 0;  // terminate current arg\r
2245                     if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }\r
2246                     argvCopy[j++] = newArgs + k; // get ready for next\r
2247                 } else {\r
2248                     if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }\r
2249                     newArgs[k++] = c;\r
2250                 }\r
2251             }\r
2252             newArgs[k] = 0;\r
2253             j--;\r
2254             fclose(f);\r
2255         }\r
2256     }\r
2257     argvCopy[j] = NULL;\r
2258     argv = argvCopy;\r
2259     argc = j;\r
2260 #if 0\r
2261     if(appData.debugMode,1) { // OK, appData is not initialized here yet...\r
2262         for(i=0; i<argc; i++) fprintf(stderr, "argv[%2d] = '%s'\n", i, argv[i]);\r
2263     }\r
2264 #endif\r
2265 #endif\r
2266 \r
2267 \r
2268     setbuf(stdout, NULL);\r
2269     setbuf(stderr, NULL);\r
2270     debugFP = stderr;\r
2271     \r
2272     programName = strrchr(argv[0], '/');\r
2273     if (programName == NULL)\r
2274       programName = argv[0];\r
2275     else\r
2276       programName++;\r
2277 \r
2278 #ifdef ENABLE_NLS\r
2279     XtSetLanguageProc(NULL, NULL, NULL);\r
2280     bindtextdomain(PRODUCT, LOCALEDIR);\r
2281     textdomain(PRODUCT);\r
2282 #endif\r
2283 \r
2284     shellWidget =\r
2285       XtAppInitialize(&appContext, "XBoard", shellOptions,\r
2286                       XtNumber(shellOptions),\r
2287                       &argc, argv, xboardResources, NULL, 0);\r
2288     if (argc > 1) {\r
2289         fprintf(stderr, _("%s: unrecognized argument %s\n"),\r
2290                 programName, argv[1]);\r
2291         exit(2);\r
2292     }\r
2293     \r
2294     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {\r
2295         chessDir = ".";\r
2296     } else {\r
2297         if (chdir(chessDir) != 0) {\r
2298             fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);\r
2299             perror(chessDir);\r
2300             exit(1);\r
2301         }\r
2302     }\r
2303     \r
2304     p = getenv("HOME");\r
2305     if (p == NULL) p = "/tmp";\r
2306     i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;\r
2307     gameCopyFilename = (char*) malloc(i);\r
2308     gamePasteFilename = (char*) malloc(i);\r
2309     sprintf(gameCopyFilename, "%s/.xboard%05uc.pgn", p, getpid());\r
2310     sprintf(gamePasteFilename, "%s/.xboard%05up.pgn", p, getpid());\r
2311 \r
2312     XtGetApplicationResources(shellWidget, (XtPointer) &appData,\r
2313                               clientResources, XtNumber(clientResources),\r
2314                               NULL, 0);\r
2315 \r
2316     if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {\r
2317         /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */\r
2318         if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL)  {\r
2319            printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);\r
2320            exit(errno);\r
2321         }\r
2322         setbuf(debugFP, NULL);\r
2323     }\r
2324     \r
2325     /* [HGM,HR] make sure board size is acceptable */\r
2326     if(appData.NrFiles > BOARD_SIZE ||\r
2327        appData.NrRanks > BOARD_SIZE   )\r
2328          DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);\r
2329 \r
2330 #if !HIGHDRAG\r
2331     /* This feature does not work; animation needs a rewrite */\r
2332     appData.highlightDragging = FALSE;\r
2333 #endif\r
2334     InitBackEnd1();\r
2335 \r
2336     xDisplay = XtDisplay(shellWidget);\r
2337     xScreen = DefaultScreen(xDisplay);\r
2338     wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);\r
2339 \r
2340         gameInfo.variant = StringToVariant(appData.variant);\r
2341         InitPosition(FALSE);\r
2342 #if 0\r
2343     /*\r
2344      * Determine boardSize\r
2345      */\r
2346     gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8\r
2347 \r
2348 //#ifndef IDSIZE\r
2349     // [HGM] as long as we have not created the possibility to change size while running, start with requested size\r
2350     gameInfo.boardWidth    = appData.NrFiles > 0 ? appData.NrFiles : 8; \r
2351     gameInfo.boardHeight   = appData.NrRanks > 0 ? appData.NrRanks : 8;\r
2352     gameInfo.holdingsWidth = appData.holdingsSize > 0 ? 2 : 0;\r
2353 #endif\r
2354 \r
2355 \r
2356 #ifdef IDSIZE\r
2357     InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine\r
2358 #else\r
2359     if (isdigit(appData.boardSize[0])) {\r
2360         i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,\r
2361                    &lineGap, &clockFontPxlSize, &coordFontPxlSize,\r
2362                    &fontPxlSize, &smallLayout, &tinyLayout);\r
2363         if (i == 0) {\r
2364             fprintf(stderr, _("%s: bad boardSize syntax %s\n"),\r
2365                     programName, appData.boardSize);\r
2366             exit(2);\r
2367         }\r
2368         if (i < 7) {\r
2369             /* Find some defaults; use the nearest known size */\r
2370             SizeDefaults *szd, *nearest;\r
2371             int distance = 99999;\r
2372             nearest = szd = sizeDefaults;\r
2373             while (szd->name != NULL) {\r
2374                 if (abs(szd->squareSize - squareSize) < distance) {\r
2375                     nearest = szd;\r
2376                     distance = abs(szd->squareSize - squareSize);\r
2377                     if (distance == 0) break;\r
2378                 }\r
2379                 szd++;\r
2380             }\r
2381             if (i < 2) lineGap = nearest->lineGap;\r
2382             if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;\r
2383             if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;\r
2384             if (i < 5) fontPxlSize = nearest->fontPxlSize;\r
2385             if (i < 6) smallLayout = nearest->smallLayout;\r
2386             if (i < 7) tinyLayout = nearest->tinyLayout;\r
2387         }\r
2388     } else {\r
2389         SizeDefaults *szd = sizeDefaults;\r
2390         if (*appData.boardSize == NULLCHAR) {\r
2391             while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||\r
2392                    DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {\r
2393               szd++;\r
2394             }\r
2395             if (szd->name == NULL) szd--;\r
2396         } else {\r
2397             while (szd->name != NULL &&\r
2398                    StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;\r
2399             if (szd->name == NULL) {\r
2400                 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),\r
2401                         programName, appData.boardSize);\r
2402                 exit(2);\r
2403             }\r
2404         }\r
2405         squareSize = szd->squareSize;\r
2406         lineGap = szd->lineGap;\r
2407         clockFontPxlSize = szd->clockFontPxlSize;\r
2408         coordFontPxlSize = szd->coordFontPxlSize;\r
2409         fontPxlSize = szd->fontPxlSize;\r
2410         smallLayout = szd->smallLayout;\r
2411         tinyLayout = szd->tinyLayout;\r
2412     }\r
2413 \r
2414     /* Now, using squareSize as a hint, find a good XPM/XIM set size */\r
2415     if (strlen(appData.pixmapDirectory) > 0) {\r
2416         p = ExpandPathName(appData.pixmapDirectory);\r
2417         if (!p) {\r
2418             fprintf(stderr, _("Error expanding path name \"%s\"\n"),\r
2419                    appData.pixmapDirectory);\r
2420             exit(1);\r
2421         }\r
2422         if (appData.debugMode) {\r
2423           fprintf(stderr, _("\\r
2424 XBoard square size (hint): %d\n\\r
2425 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);\r
2426         }\r
2427         squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);\r
2428         if (appData.debugMode) {\r
2429             fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);\r
2430         }\r
2431     }\r
2432                 \r
2433     /* [HR] height treated separately (hacked) */\r
2434     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);\r
2435     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);\r
2436     if (appData.showJail == 1) {\r
2437         /* Jail on top and bottom */\r
2438         XtSetArg(boardArgs[1], XtNwidth, boardWidth);\r
2439         XtSetArg(boardArgs[2], XtNheight,\r
2440                  boardHeight + 2*(lineGap + squareSize));\r
2441     } else if (appData.showJail == 2) {\r
2442         /* Jail on sides */\r
2443         XtSetArg(boardArgs[1], XtNwidth,\r
2444                  boardWidth + 2*(lineGap + squareSize));\r
2445         XtSetArg(boardArgs[2], XtNheight, boardHeight);\r
2446     } else {\r
2447         /* No jail */\r
2448         XtSetArg(boardArgs[1], XtNwidth, boardWidth);\r
2449         XtSetArg(boardArgs[2], XtNheight, boardHeight);\r
2450     }\r
2451 \r
2452     /*\r
2453      * Determine what fonts to use.\r
2454      */\r
2455     appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);\r
2456     clockFontID = XLoadFont(xDisplay, appData.clockFont);\r
2457     clockFontStruct = XQueryFont(xDisplay, clockFontID);\r
2458     appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);\r
2459     coordFontID = XLoadFont(xDisplay, appData.coordFont);\r
2460     coordFontStruct = XQueryFont(xDisplay, coordFontID);\r
2461     appData.font = FindFont(appData.font, fontPxlSize);\r
2462     countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings\r
2463     countFontStruct = XQueryFont(xDisplay, countFontID);\r
2464 //    appData.font = FindFont(appData.font, fontPxlSize);\r
2465 \r
2466     xdb = XtDatabase(xDisplay);\r
2467     XrmPutStringResource(&xdb, "*font", appData.font);\r
2468 \r
2469     /*\r
2470      * Detect if there are not enough colors available and adapt.\r
2471      */\r
2472     if (DefaultDepth(xDisplay, xScreen) <= 2) {\r
2473       appData.monoMode = True;\r
2474     }\r
2475 \r
2476     if (!appData.monoMode) {\r
2477         vFrom.addr = (caddr_t) appData.lightSquareColor;\r
2478         vFrom.size = strlen(appData.lightSquareColor);\r
2479         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2480         if (vTo.addr == NULL) {\r
2481           appData.monoMode = True;\r
2482           forceMono = True;\r
2483         } else {\r
2484           lightSquareColor = *(Pixel *) vTo.addr;\r
2485         }\r
2486     }\r
2487     if (!appData.monoMode) {\r
2488         vFrom.addr = (caddr_t) appData.darkSquareColor;\r
2489         vFrom.size = strlen(appData.darkSquareColor);\r
2490         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2491         if (vTo.addr == NULL) {\r
2492           appData.monoMode = True;\r
2493           forceMono = True;\r
2494         } else {\r
2495           darkSquareColor = *(Pixel *) vTo.addr;\r
2496         }\r
2497     }\r
2498     if (!appData.monoMode) {\r
2499         vFrom.addr = (caddr_t) appData.whitePieceColor;\r
2500         vFrom.size = strlen(appData.whitePieceColor);\r
2501         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2502         if (vTo.addr == NULL) {\r
2503           appData.monoMode = True;\r
2504           forceMono = True;\r
2505         } else {\r
2506           whitePieceColor = *(Pixel *) vTo.addr;\r
2507         }\r
2508     }\r
2509     if (!appData.monoMode) {\r
2510         vFrom.addr = (caddr_t) appData.blackPieceColor;\r
2511         vFrom.size = strlen(appData.blackPieceColor);\r
2512         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2513         if (vTo.addr == NULL) {\r
2514           appData.monoMode = True;\r
2515           forceMono = True;\r
2516         } else {\r
2517           blackPieceColor = *(Pixel *) vTo.addr;\r
2518         }\r
2519     }\r
2520 \r
2521     if (!appData.monoMode) {\r
2522         vFrom.addr = (caddr_t) appData.highlightSquareColor;\r
2523         vFrom.size = strlen(appData.highlightSquareColor);\r
2524         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2525         if (vTo.addr == NULL) {\r
2526           appData.monoMode = True;\r
2527           forceMono = True;\r
2528         } else {\r
2529           highlightSquareColor = *(Pixel *) vTo.addr;\r
2530         }\r
2531     }\r
2532 \r
2533     if (!appData.monoMode) {\r
2534         vFrom.addr = (caddr_t) appData.premoveHighlightColor;\r
2535         vFrom.size = strlen(appData.premoveHighlightColor);\r
2536         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
2537         if (vTo.addr == NULL) {\r
2538           appData.monoMode = True;\r
2539           forceMono = True;\r
2540         } else {\r
2541           premoveHighlightColor = *(Pixel *) vTo.addr;\r
2542         }\r
2543     }\r
2544 \r
2545     if (forceMono) {\r
2546       fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),\r
2547               programName);\r
2548     }\r
2549 \r
2550     if (appData.monoMode && appData.debugMode) {\r
2551         fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),\r
2552                 (unsigned long) XWhitePixel(xDisplay, xScreen),\r
2553                 (unsigned long) XBlackPixel(xDisplay, xScreen));\r
2554     }\r
2555     \r
2556     if (parse_cpair(ColorShout, appData.colorShout) < 0 ||\r
2557         parse_cpair(ColorSShout, appData.colorSShout) < 0 ||\r
2558         parse_cpair(ColorChannel1, appData.colorChannel1) < 0  ||\r
2559         parse_cpair(ColorChannel, appData.colorChannel) < 0  ||\r
2560         parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||\r
2561         parse_cpair(ColorTell, appData.colorTell) < 0 ||\r
2562         parse_cpair(ColorChallenge, appData.colorChallenge) < 0  ||\r
2563         parse_cpair(ColorRequest, appData.colorRequest) < 0  ||\r
2564         parse_cpair(ColorSeek, appData.colorSeek) < 0  ||\r
2565         parse_cpair(ColorNormal, appData.colorNormal) < 0)\r
2566       {\r
2567           if (appData.colorize) {\r
2568               fprintf(stderr,\r
2569                       _("%s: can't parse color names; disabling colorization\n"),\r
2570                       programName);\r
2571           }\r
2572           appData.colorize = FALSE;\r
2573       }\r
2574     textColors[ColorNone].fg = textColors[ColorNone].bg = -1;\r
2575     textColors[ColorNone].attr = 0;\r
2576     \r
2577     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));\r
2578     \r
2579     /*\r
2580      * widget hierarchy\r
2581      */\r
2582     if (tinyLayout) {\r
2583         layoutName = "tinyLayout";\r
2584     } else if (smallLayout) {\r
2585         layoutName = "smallLayout";\r
2586     } else {\r
2587         layoutName = "normalLayout";\r
2588     }\r
2589     /* Outer layoutWidget is there only to provide a name for use in\r
2590        resources that depend on the layout style */\r
2591     layoutWidget =\r
2592       XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,\r
2593                             layoutArgs, XtNumber(layoutArgs));\r
2594     formWidget =\r
2595       XtCreateManagedWidget("form", formWidgetClass, layoutWidget,\r
2596                             formArgs, XtNumber(formArgs));\r
2597     XtSetArg(args[0], XtNdefaultDistance, &sep);\r
2598     XtGetValues(formWidget, args, 1);\r
2599 \r
2600     j = 0;\r
2601     widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);\r
2602     XtSetArg(args[0], XtNtop,    XtChainTop);\r
2603     XtSetArg(args[1], XtNbottom, XtChainTop);\r
2604     XtSetValues(menuBarWidget, args, 2);\r
2605 \r
2606     widgetList[j++] = whiteTimerWidget =\r
2607       XtCreateWidget("whiteTime", labelWidgetClass,\r
2608                      formWidget, timerArgs, XtNumber(timerArgs));\r
2609     XtSetArg(args[0], XtNfont, clockFontStruct);\r
2610     XtSetArg(args[1], XtNtop,    XtChainTop);\r
2611     XtSetArg(args[2], XtNbottom, XtChainTop);\r
2612     XtSetValues(whiteTimerWidget, args, 3);\r
2613     \r
2614     widgetList[j++] = blackTimerWidget =\r
2615       XtCreateWidget("blackTime", labelWidgetClass,\r
2616                      formWidget, timerArgs, XtNumber(timerArgs));\r
2617     XtSetArg(args[0], XtNfont, clockFontStruct);\r
2618     XtSetArg(args[1], XtNtop,    XtChainTop);\r
2619     XtSetArg(args[2], XtNbottom, XtChainTop);\r
2620     XtSetValues(blackTimerWidget, args, 3);\r
2621     \r
2622     if (appData.titleInWindow) {\r
2623         widgetList[j++] = titleWidget = \r
2624           XtCreateWidget("title", labelWidgetClass, formWidget,\r
2625                          titleArgs, XtNumber(titleArgs));\r
2626         XtSetArg(args[0], XtNtop,    XtChainTop);\r
2627         XtSetArg(args[1], XtNbottom, XtChainTop);\r
2628         XtSetValues(titleWidget, args, 2);\r
2629     }\r
2630 \r
2631     if (appData.showButtonBar) {\r
2632       widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);\r
2633       XtSetArg(args[0], XtNleft,  XtChainRight); // [HGM] glue to right window edge\r
2634       XtSetArg(args[1], XtNright, XtChainRight); //       for good run-time sizing\r
2635       XtSetArg(args[2], XtNtop,    XtChainTop);\r
2636       XtSetArg(args[3], XtNbottom, XtChainTop);\r
2637       XtSetValues(buttonBarWidget, args, 4);\r
2638     }\r
2639 \r
2640     widgetList[j++] = messageWidget =\r
2641       XtCreateWidget("message", labelWidgetClass, formWidget,\r
2642                      messageArgs, XtNumber(messageArgs));\r
2643     XtSetArg(args[0], XtNtop,    XtChainTop);\r
2644     XtSetArg(args[1], XtNbottom, XtChainTop);\r
2645     XtSetValues(messageWidget, args, 2);\r
2646 \r
2647     widgetList[j++] = boardWidget =\r
2648       XtCreateWidget("board", widgetClass, formWidget, boardArgs,\r
2649                      XtNumber(boardArgs));\r
2650 \r
2651     XtManageChildren(widgetList, j);\r
2652     \r
2653     timerWidth = (boardWidth - sep) / 2;\r
2654     XtSetArg(args[0], XtNwidth, timerWidth);\r
2655     XtSetValues(whiteTimerWidget, args, 1);\r
2656     XtSetValues(blackTimerWidget, args, 1);\r
2657     \r
2658     XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);\r
2659     XtSetArg(args[1], XtNforeground, &timerForegroundPixel);\r
2660     XtGetValues(whiteTimerWidget, args, 2);\r
2661     \r
2662     if (appData.showButtonBar) {\r
2663       XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);\r
2664       XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);\r
2665       XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);\r
2666     }\r
2667 \r
2668     /*\r
2669      * formWidget uses these constraints but they are stored\r
2670      * in the children.\r
2671      */\r
2672     i = 0;\r
2673     XtSetArg(args[i], XtNfromHoriz, 0); i++;\r
2674     XtSetValues(menuBarWidget, args, i);\r
2675     if (appData.titleInWindow) {\r
2676         if (smallLayout) {\r
2677             i = 0;\r
2678             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
2679             XtSetValues(whiteTimerWidget, args, i);\r
2680             i = 0;\r
2681             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
2682             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
2683             XtSetValues(blackTimerWidget, args, i);\r
2684             i = 0;\r
2685             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
2686             XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;\r
2687             XtSetValues(titleWidget, args, i);\r
2688             i = 0;\r
2689             XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
2690             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
2691             XtSetValues(messageWidget, args, i);\r
2692             if (appData.showButtonBar) {\r
2693               i = 0;\r
2694               XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
2695               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
2696               XtSetValues(buttonBarWidget, args, i);\r
2697             }\r
2698         } else {\r
2699             i = 0;\r
2700             XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
2701             XtSetValues(whiteTimerWidget, args, i);\r
2702             i = 0;\r
2703             XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
2704             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
2705             XtSetValues(blackTimerWidget, args, i);\r
2706             i = 0;\r
2707             XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;\r
2708             XtSetValues(titleWidget, args, i);\r
2709             i = 0;\r
2710             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
2711             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
2712             XtSetValues(messageWidget, args, i);\r
2713             if (appData.showButtonBar) {\r
2714               i = 0;\r
2715               XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
2716               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
2717               XtSetValues(buttonBarWidget, args, i);\r
2718             }\r
2719         }\r
2720     } else {\r
2721         i = 0;\r
2722         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
2723         XtSetValues(whiteTimerWidget, args, i);\r
2724         i = 0;\r
2725         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
2726         XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
2727         XtSetValues(blackTimerWidget, args, i);\r
2728         i = 0;\r
2729         XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
2730         XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
2731         XtSetValues(messageWidget, args, i);\r
2732         if (appData.showButtonBar) {\r
2733           i = 0;\r
2734           XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
2735           XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
2736           XtSetValues(buttonBarWidget, args, i);\r
2737         }\r
2738     }\r
2739     i = 0;\r
2740     XtSetArg(args[0], XtNfromVert, messageWidget);\r
2741     XtSetArg(args[1], XtNtop,    XtChainTop);\r
2742     XtSetArg(args[2], XtNbottom, XtChainBottom);\r
2743     XtSetArg(args[3], XtNleft,   XtChainLeft);\r
2744     XtSetArg(args[4], XtNright,  XtChainRight);\r
2745     XtSetValues(boardWidget, args, 5);\r
2746 \r
2747     XtRealizeWidget(shellWidget);\r
2748 \r
2749     /*\r
2750      * Correct the width of the message and title widgets.\r
2751      * It is not known why some systems need the extra fudge term.\r
2752      * The value "2" is probably larger than needed.\r
2753      */\r
2754     XawFormDoLayout(formWidget, False);\r
2755 \r
2756 #define WIDTH_FUDGE 2\r
2757     i = 0;\r
2758     XtSetArg(args[i], XtNborderWidth, &bor);  i++;\r
2759     XtSetArg(args[i], XtNheight, &h);  i++;\r
2760     XtGetValues(messageWidget, args, i);\r
2761     if (appData.showButtonBar) {\r
2762       i = 0;\r
2763       XtSetArg(args[i], XtNwidth, &w);  i++;\r
2764       XtGetValues(buttonBarWidget, args, i);\r
2765       w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;\r
2766     } else {\r
2767       w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */\r
2768     }\r
2769 \r
2770     gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);\r
2771     if (gres != XtGeometryYes && appData.debugMode) {\r
2772       fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),\r
2773               programName, gres, w, h, wr, hr);\r
2774     }\r
2775     \r
2776     /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */\r
2777     /* The size used for the child widget in layout lags one resize behind\r
2778        its true size, so we resize a second time, 1 pixel smaller.  Yeech! */\r
2779     w--;\r
2780     gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);\r
2781     if (gres != XtGeometryYes && appData.debugMode) {\r
2782       fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),\r
2783               programName, gres, w, h, wr, hr);\r
2784     }\r
2785     /* !! end hack */\r
2786     XtSetArg(args[0], XtNleft,  XtChainLeft);  // [HGM] glue ends for good run-time sizing\r
2787     XtSetArg(args[1], XtNright, XtChainRight);\r
2788     XtSetValues(messageWidget, args, 2);\r
2789 \r
2790     if (appData.titleInWindow) {\r
2791         i = 0;\r
2792         XtSetArg(args[i], XtNborderWidth, &bor); i++;\r
2793         XtSetArg(args[i], XtNheight, &h);  i++;\r
2794         XtGetValues(titleWidget, args, i);\r
2795         if (smallLayout) {\r
2796             w = boardWidth - 2*bor;\r
2797         } else {\r
2798             XtSetArg(args[0], XtNwidth, &w);\r
2799             XtGetValues(menuBarWidget, args, 1);\r
2800             w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;\r
2801         }\r
2802 \r
2803         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);\r
2804         if (gres != XtGeometryYes && appData.debugMode) {\r
2805             fprintf(stderr,\r
2806                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),\r
2807                     programName, gres, w, h, wr, hr);\r
2808         }\r
2809     }\r
2810     XawFormDoLayout(formWidget, True);\r
2811 \r
2812     xBoardWindow = XtWindow(boardWidget);\r
2813 \r
2814     // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would\r
2815     //       not need to go into InitDrawingSizes().\r
2816 #endif    \r
2817 \r
2818     /* \r
2819      * Create X checkmark bitmap and initialize option menu checks.\r
2820      */\r
2821     ReadBitmap(&xMarkPixmap, "checkmark.bm",\r
2822                checkmark_bits, checkmark_width, checkmark_height);\r
2823     XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
2824     if (appData.alwaysPromoteToQueen) {\r
2825         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),\r
2826                     args, 1);\r
2827     }\r
2828     if (appData.animateDragging) {\r
2829         XtSetValues(XtNameToWidget(menuBarWidget,\r
2830                                    "menuOptions.Animate Dragging"),\r
2831                     args, 1);\r
2832     }\r
2833     if (appData.animate) {\r
2834         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),\r
2835                     args, 1);\r
2836     }\r
2837     if (appData.autoComment) {\r
2838         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),\r
2839                     args, 1);\r
2840     }\r
2841     if (appData.autoCallFlag) {\r
2842         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),\r
2843                     args, 1);\r
2844     }\r
2845     if (appData.autoFlipView) {\r
2846         XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),\r
2847                     args, 1);\r
2848     }\r
2849     if (appData.autoObserve) {\r
2850         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),\r
2851                     args, 1);\r
2852     }\r
2853     if (appData.autoRaiseBoard) {\r
2854         XtSetValues(XtNameToWidget(menuBarWidget,\r
2855                                    "menuOptions.Auto Raise Board"), args, 1);\r
2856     }\r
2857     if (appData.autoSaveGames) {\r
2858         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
2859                     args, 1);\r
2860     }\r
2861     if (appData.saveGameFile[0] != NULLCHAR) {\r
2862         /* Can't turn this off from menu */\r
2863         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
2864                     args, 1);\r
2865         XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
2866                        False);\r
2867 \r
2868     }\r
2869     if (appData.blindfold) {\r
2870         XtSetValues(XtNameToWidget(menuBarWidget,\r
2871                                    "menuOptions.Blindfold"), args, 1);\r
2872     }\r
2873     if (appData.flashCount > 0) {\r
2874         XtSetValues(XtNameToWidget(menuBarWidget,\r
2875                                    "menuOptions.Flash Moves"),\r
2876                     args, 1);\r
2877     }\r
2878     if (appData.getMoveList) {\r
2879         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),\r
2880                     args, 1);\r
2881     }\r
2882 #if HIGHDRAG\r
2883     if (appData.highlightDragging) {\r
2884         XtSetValues(XtNameToWidget(menuBarWidget,\r
2885                                    "menuOptions.Highlight Dragging"),\r
2886                     args, 1);\r
2887     }\r
2888 #endif\r
2889     if (appData.highlightLastMove) {\r
2890         XtSetValues(XtNameToWidget(menuBarWidget,\r
2891                                    "menuOptions.Highlight Last Move"),\r
2892                     args, 1);\r
2893     }\r
2894     if (appData.icsAlarm) {\r
2895         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),\r
2896                     args, 1);\r
2897     }\r
2898     if (appData.ringBellAfterMoves) {\r
2899         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),\r
2900                     args, 1);\r
2901     }\r
2902     if (appData.oldSaveStyle) {\r
2903         XtSetValues(XtNameToWidget(menuBarWidget,\r
2904                                    "menuOptions.Old Save Style"), args, 1);\r
2905     }\r
2906     if (appData.periodicUpdates) {\r
2907         XtSetValues(XtNameToWidget(menuBarWidget,\r
2908                                    "menuOptions.Periodic Updates"), args, 1);\r
2909     }   \r
2910     if (appData.ponderNextMove) {\r
2911         XtSetValues(XtNameToWidget(menuBarWidget,\r
2912                                    "menuOptions.Ponder Next Move"), args, 1);\r
2913     }   \r
2914     if (appData.popupExitMessage) {\r
2915         XtSetValues(XtNameToWidget(menuBarWidget,\r
2916                                    "menuOptions.Popup Exit Message"), args, 1);\r
2917     }   \r
2918     if (appData.popupMoveErrors) {\r
2919         XtSetValues(XtNameToWidget(menuBarWidget,\r
2920                                    "menuOptions.Popup Move Errors"), args, 1);\r
2921     }   \r
2922     if (appData.premove) {\r
2923         XtSetValues(XtNameToWidget(menuBarWidget,\r
2924                                    "menuOptions.Premove"), args, 1);\r
2925     }\r
2926     if (appData.quietPlay) {\r
2927         XtSetValues(XtNameToWidget(menuBarWidget,\r
2928                                    "menuOptions.Quiet Play"), args, 1);\r
2929     }\r
2930     if (appData.showCoords) {\r
2931         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),\r
2932                     args, 1);\r
2933     }\r
2934     if (appData.hideThinkingFromHuman) {\r
2935         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),\r
2936                     args, 1);\r
2937     }\r
2938     if (appData.testLegality) {\r
2939         XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),\r
2940                     args, 1);\r
2941     }\r
2942 \r
2943     /*\r
2944      * Create an icon.\r
2945      */\r
2946     ReadBitmap(&wIconPixmap, "icon_white.bm",\r
2947                icon_white_bits, icon_white_width, icon_white_height);\r
2948     ReadBitmap(&bIconPixmap, "icon_black.bm",\r
2949                icon_black_bits, icon_black_width, icon_black_height);\r
2950     iconPixmap = wIconPixmap;\r
2951     i = 0;\r
2952     XtSetArg(args[i], XtNiconPixmap, iconPixmap);  i++;\r
2953     XtSetValues(shellWidget, args, i);\r
2954     \r
2955     /*\r
2956      * Create a cursor for the board widget.\r
2957      */\r
2958     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);\r
2959     XChangeWindowAttributes(xDisplay, xBoardWindow,\r
2960                             CWCursor, &window_attributes);\r
2961     \r
2962     /*\r
2963      * Inhibit shell resizing.\r
2964      */\r
2965     shellArgs[0].value = (XtArgVal) &w;\r
2966     shellArgs[1].value = (XtArgVal) &h;\r
2967     XtGetValues(shellWidget, shellArgs, 2);\r
2968     shellArgs[4].value = shellArgs[2].value = w;\r
2969     shellArgs[5].value = shellArgs[3].value = h;\r
2970     XtSetValues(shellWidget, &shellArgs[2], 4);\r
2971     marginW =  w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board\r
2972     marginH =  h - boardHeight;\r
2973 \r
2974     CatchDeleteWindow(shellWidget, "QuitProc");\r
2975 \r
2976     CreateGCs();\r
2977     CreateGrid();\r
2978 #if HAVE_LIBXPM\r
2979     if (appData.bitmapDirectory[0] != NULLCHAR) {\r
2980       CreatePieces();\r
2981     } else {\r
2982       CreateXPMPieces();\r
2983     }\r
2984 #else\r
2985     CreateXIMPieces();\r
2986     /* Create regular pieces */\r
2987     if (!useImages) CreatePieces();\r
2988 #endif  \r
2989 \r
2990     CreatePieceMenus();\r
2991 \r
2992     if (appData.animate || appData.animateDragging)\r
2993       CreateAnimVars();\r
2994     \r
2995     XtAugmentTranslations(formWidget,\r
2996                           XtParseTranslationTable(globalTranslations));\r
2997     XtAugmentTranslations(boardWidget,\r
2998                           XtParseTranslationTable(boardTranslations));\r
2999     XtAugmentTranslations(whiteTimerWidget,\r
3000                           XtParseTranslationTable(whiteTranslations));\r
3001     XtAugmentTranslations(blackTimerWidget,\r
3002                           XtParseTranslationTable(blackTranslations));\r
3003 \r
3004     /* Why is the following needed on some versions of X instead\r
3005      * of a translation? */\r
3006     XtAddEventHandler(boardWidget, ExposureMask, False,\r
3007                       (XtEventHandler) EventProc, NULL);\r
3008     /* end why */\r
3009 \r
3010     InitBackEnd2();\r
3011     \r
3012     if (errorExitStatus == -1) {\r
3013         if (appData.icsActive) {\r
3014             /* We now wait until we see "login:" from the ICS before\r
3015                sending the logon script (problems with timestamp otherwise) */\r
3016             /*ICSInitScript();*/\r
3017             if (appData.icsInputBox) ICSInputBoxPopUp();\r
3018         }\r
3019 \r
3020         signal(SIGINT, IntSigHandler);\r
3021         signal(SIGTERM, IntSigHandler);\r
3022         if (*appData.cmailGameName != NULLCHAR) {\r
3023             signal(SIGUSR1, CmailSigHandler);\r
3024         }\r
3025     }\r
3026         InitPosition(TRUE);\r
3027 \r
3028     XtAppMainLoop(appContext);\r
3029     if (appData.debugMode) fclose(debugFP); // [DM] debug\r
3030     return 0;\r
3031 }\r
3032 \r
3033 void\r
3034 ShutDownFrontEnd()\r
3035 {\r
3036     if (appData.icsActive && oldICSInteractionTitle != NULL) {\r
3037         DisplayIcsInteractionTitle(oldICSInteractionTitle);\r
3038     }\r
3039     unlink(gameCopyFilename);\r
3040     unlink(gamePasteFilename);\r
3041 }\r
3042 \r
3043 RETSIGTYPE\r
3044 IntSigHandler(sig)\r
3045      int sig;\r
3046 {\r
3047     ExitEvent(sig);\r
3048 }\r
3049 \r
3050 RETSIGTYPE\r
3051 CmailSigHandler(sig)\r
3052      int sig;\r
3053 {\r
3054     int dummy = 0;\r
3055     int error;\r
3056 \r
3057     signal(SIGUSR1, SIG_IGN);   /* suspend handler     */\r
3058 \r
3059     /* Activate call-back function CmailSigHandlerCallBack()             */\r
3060     OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);\r
3061 \r
3062     signal(SIGUSR1, CmailSigHandler); /* re-activate handler */\r
3063 }\r
3064 \r
3065 void\r
3066 CmailSigHandlerCallBack(isr, closure, message, count, error)\r
3067      InputSourceRef isr;\r
3068      VOIDSTAR closure;\r
3069      char *message;\r
3070      int count;\r
3071      int error;\r
3072 {\r
3073     BoardToTop();\r
3074     ReloadCmailMsgEvent(TRUE);  /* Reload cmail msg  */\r
3075 }\r
3076 /**** end signal code ****/\r
3077 \r
3078 \r
3079 void\r
3080 ICSInitScript()\r
3081 {\r
3082     FILE *f;\r
3083     char buf[MSG_SIZ];\r
3084     char *p;\r
3085 \r
3086     f = fopen(appData.icsLogon, "r");\r
3087     if (f == NULL) {\r
3088         p = getenv("HOME");\r
3089         if (p != NULL) {\r
3090             strcpy(buf, p);\r
3091             strcat(buf, "/");\r
3092             strcat(buf, appData.icsLogon);\r
3093             f = fopen(buf, "r");\r
3094         }\r
3095     }\r
3096     if (f != NULL)\r
3097       ProcessICSInitScript(f);\r
3098 }\r
3099 \r
3100 void\r
3101 ResetFrontEnd()\r
3102 {\r
3103     CommentPopDown();\r
3104     EditCommentPopDown();\r
3105     TagsPopDown();\r
3106     return;\r
3107 }\r
3108 \r
3109 typedef struct {\r
3110     char *name;\r
3111     Boolean value;\r
3112 } Enables;\r
3113 \r
3114 void\r
3115 SetMenuEnables(enab)\r
3116      Enables *enab;\r
3117 {\r
3118   Widget w;\r
3119   if (!menuBarWidget) return;\r
3120   while (enab->name != NULL) {\r
3121     w = XtNameToWidget(menuBarWidget, enab->name);\r
3122     if (w == NULL) {\r
3123       DisplayError(enab->name, 0);\r
3124     } else {\r
3125       XtSetSensitive(w, enab->value);\r
3126     }\r
3127     enab++;\r
3128   }\r
3129 }\r
3130 \r
3131 Enables icsEnables[] = {\r
3132     { "menuFile.Mail Move", False },\r
3133     { "menuFile.Reload CMail Message", False },\r
3134     { "menuMode.Machine Black", False },\r
3135     { "menuMode.Machine White", False },\r
3136     { "menuMode.Analysis Mode", False },\r
3137     { "menuMode.Analyze File", False },\r
3138     { "menuMode.Two Machines", False },\r
3139 #ifndef ZIPPY\r
3140     { "menuHelp.Hint", False },\r
3141     { "menuHelp.Book", False },\r
3142     { "menuStep.Move Now", False },\r
3143     { "menuOptions.Periodic Updates", False },  \r
3144     { "menuOptions.Hide Thinking", False },\r
3145     { "menuOptions.Ponder Next Move", False },\r
3146 #endif\r
3147     { NULL, False }\r
3148 };\r
3149 \r
3150 Enables ncpEnables[] = {    \r
3151     { "menuFile.Mail Move", False },\r
3152     { "menuFile.Reload CMail Message", False },\r
3153     { "menuMode.Machine White", False },\r
3154     { "menuMode.Machine Black", False },\r
3155     { "menuMode.Analysis Mode", False },\r
3156     { "menuMode.Analyze File", False },\r
3157     { "menuMode.Two Machines", False },\r
3158     { "menuMode.ICS Client", False },\r
3159     { "menuMode.ICS Input Box", False },\r
3160     { "Action", False },\r
3161     { "menuStep.Revert", False },\r
3162     { "menuStep.Move Now", False },\r
3163     { "menuStep.Retract Move", False },\r
3164     { "menuOptions.Auto Comment", False },\r
3165     { "menuOptions.Auto Flag", False },\r
3166     { "menuOptions.Auto Flip View", False },\r
3167     { "menuOptions.Auto Observe", False },\r
3168     { "menuOptions.Auto Raise Board", False },\r
3169     { "menuOptions.Get Move List", False },\r
3170     { "menuOptions.ICS Alarm", False },\r
3171     { "menuOptions.Move Sound", False },\r
3172     { "menuOptions.Quiet Play", False },\r
3173     { "menuOptions.Hide Thinking", False },\r
3174     { "menuOptions.Periodic Updates", False },  \r
3175     { "menuOptions.Ponder Next Move", False },\r
3176     { "menuHelp.Hint", False },\r
3177     { "menuHelp.Book", False },\r
3178     { NULL, False }\r
3179 };\r
3180 \r
3181 Enables gnuEnables[] = {    \r
3182     { "menuMode.ICS Client", False },\r
3183     { "menuMode.ICS Input Box", False },\r
3184     { "menuAction.Accept", False },\r
3185     { "menuAction.Decline", False },\r
3186     { "menuAction.Rematch", False },\r
3187     { "menuAction.Adjourn", False },\r
3188     { "menuAction.Stop Examining", False },\r
3189     { "menuAction.Stop Observing", False },\r
3190     { "menuStep.Revert", False },\r
3191     { "menuOptions.Auto Comment", False },\r
3192     { "menuOptions.Auto Observe", False },\r
3193     { "menuOptions.Auto Raise Board", False },\r
3194     { "menuOptions.Get Move List", False },\r
3195     { "menuOptions.Premove", False },\r
3196     { "menuOptions.Quiet Play", False },\r
3197 \r
3198     /* The next two options rely on SetCmailMode being called *after*    */\r
3199     /* SetGNUMode so that when GNU is being used to give hints these     */\r
3200     /* menu options are still available                                  */\r
3201 \r
3202     { "menuFile.Mail Move", False },\r
3203     { "menuFile.Reload CMail Message", False },\r
3204     { NULL, False }\r
3205 };\r
3206 \r
3207 Enables cmailEnables[] = {    \r
3208     { "Action", True },\r
3209     { "menuAction.Call Flag", False },\r
3210     { "menuAction.Draw", True },\r
3211     { "menuAction.Adjourn", False },\r
3212     { "menuAction.Abort", False },\r
3213     { "menuAction.Stop Observing", False },\r
3214     { "menuAction.Stop Examining", False },\r
3215     { "menuFile.Mail Move", True },\r
3216     { "menuFile.Reload CMail Message", True },\r
3217     { NULL, False }\r
3218 };\r
3219 \r
3220 Enables trainingOnEnables[] = {    \r
3221   { "menuMode.Edit Comment", False },\r
3222   { "menuMode.Pause", False },\r
3223   { "menuStep.Forward", False },\r
3224   { "menuStep.Backward", False },\r
3225   { "menuStep.Forward to End", False },\r
3226   { "menuStep.Back to Start", False },\r
3227   { "menuStep.Move Now", False },\r
3228   { "menuStep.Truncate Game", False },\r
3229   { NULL, False }\r
3230 };\r
3231 \r
3232 Enables trainingOffEnables[] = {    \r
3233   { "menuMode.Edit Comment", True },\r
3234   { "menuMode.Pause", True },\r
3235   { "menuStep.Forward", True },\r
3236   { "menuStep.Backward", True },\r
3237   { "menuStep.Forward to End", True },\r
3238   { "menuStep.Back to Start", True },\r
3239   { "menuStep.Move Now", True },\r
3240   { "menuStep.Truncate Game", True },\r
3241   { NULL, False }\r
3242 };\r
3243 \r
3244 Enables machineThinkingEnables[] = {\r
3245   { "menuFile.Load Game", False },\r
3246   { "menuFile.Load Next Game", False },\r
3247   { "menuFile.Load Previous Game", False },\r
3248   { "menuFile.Reload Same Game", False },\r
3249   { "menuFile.Paste Game", False },\r
3250   { "menuFile.Load Position", False },\r
3251   { "menuFile.Load Next Position", False },\r
3252   { "menuFile.Load Previous Position", False },\r
3253   { "menuFile.Reload Same Position", False },\r
3254   { "menuFile.Paste Position", False },\r
3255   { "menuMode.Machine White", False },\r
3256   { "menuMode.Machine Black", False },\r
3257   { "menuMode.Two Machines", False },\r
3258   { "menuStep.Retract Move", False },\r
3259   { NULL, False }\r
3260 };\r
3261 \r
3262 Enables userThinkingEnables[] = {\r
3263   { "menuFile.Load Game", True },\r
3264   { "menuFile.Load Next Game", True },\r
3265   { "menuFile.Load Previous Game", True },\r
3266   { "menuFile.Reload Same Game", True },\r
3267   { "menuFile.Paste Game", True },\r
3268   { "menuFile.Load Position", True },\r
3269   { "menuFile.Load Next Position", True },\r
3270   { "menuFile.Load Previous Position", True },\r
3271   { "menuFile.Reload Same Position", True },\r
3272   { "menuFile.Paste Position", True },\r
3273   { "menuMode.Machine White", True },\r
3274   { "menuMode.Machine Black", True },\r
3275   { "menuMode.Two Machines", True },\r
3276   { "menuStep.Retract Move", True },\r
3277   { NULL, False }\r
3278 };\r
3279 \r
3280 void SetICSMode()\r
3281 {\r
3282   SetMenuEnables(icsEnables);\r
3283 \r
3284 #ifdef ZIPPY\r
3285   if (appData.zippyPlay && !appData.noChessProgram)   /* [DM] icsEngineAnalyze */\r
3286      XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);\r
3287 #endif\r
3288 }\r
3289 \r
3290 void\r
3291 SetNCPMode()\r
3292 {\r
3293   SetMenuEnables(ncpEnables);\r
3294 }\r
3295 \r
3296 void\r
3297 SetGNUMode()\r
3298 {\r
3299   SetMenuEnables(gnuEnables);\r
3300 }\r
3301 \r
3302 void\r
3303 SetCmailMode()\r
3304 {\r
3305   SetMenuEnables(cmailEnables);\r
3306 }\r
3307 \r
3308 void\r
3309 SetTrainingModeOn()\r
3310 {\r
3311   SetMenuEnables(trainingOnEnables);\r
3312   if (appData.showButtonBar) {\r
3313     XtSetSensitive(buttonBarWidget, False);\r
3314   }\r
3315   CommentPopDown();\r
3316 }\r
3317 \r
3318 void\r
3319 SetTrainingModeOff()\r
3320 {\r
3321   SetMenuEnables(trainingOffEnables);\r
3322   if (appData.showButtonBar) {\r
3323     XtSetSensitive(buttonBarWidget, True);\r
3324   }\r
3325 }\r
3326 \r
3327 void\r
3328 SetUserThinkingEnables()\r
3329 {\r
3330   if (appData.noChessProgram) return;\r
3331   SetMenuEnables(userThinkingEnables);\r
3332 }\r
3333 \r
3334 void\r
3335 SetMachineThinkingEnables()\r
3336 {\r
3337   if (appData.noChessProgram) return;\r
3338   SetMenuEnables(machineThinkingEnables);\r
3339   switch (gameMode) {\r
3340   case MachinePlaysBlack:\r
3341   case MachinePlaysWhite:\r
3342   case TwoMachinesPlay:\r
3343     XtSetSensitive(XtNameToWidget(menuBarWidget,\r
3344                                   ModeToWidgetName(gameMode)), True);\r
3345     break;\r
3346   default:\r
3347     break;\r
3348   }\r
3349 }\r
3350 \r
3351 #define Abs(n) ((n)<0 ? -(n) : (n))\r
3352 \r
3353 /*\r
3354  * Find a font that matches "pattern" that is as close as\r
3355  * possible to the targetPxlSize.  Prefer fonts that are k\r
3356  * pixels smaller to fonts that are k pixels larger.  The\r
3357  * pattern must be in the X Consortium standard format, \r
3358  * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".\r
3359  * The return value should be freed with XtFree when no\r
3360  * longer needed.\r
3361  */\r
3362 char *FindFont(pattern, targetPxlSize)\r
3363      char *pattern;\r
3364      int targetPxlSize;\r
3365 {\r
3366     char **fonts, *p, *best, *scalable, *scalableTail;\r
3367     int i, j, nfonts, minerr, err, pxlSize;\r
3368 \r
3369 #ifdef ENABLE_NLS\r
3370     char **missing_list;\r
3371     int missing_count;\r
3372     char *def_string, *base_fnt_lst, strInt[3];\r
3373     XFontSet fntSet;\r
3374     XFontStruct **fnt_list;\r
3375 \r
3376     base_fnt_lst = calloc(1, strlen(pattern) + 3);\r
3377     sprintf(strInt, "%d", targetPxlSize);\r
3378     p = strstr(pattern, "--");\r
3379     strncpy(base_fnt_lst, pattern, p - pattern + 2);\r
3380     strcat(base_fnt_lst, strInt);\r
3381     strcat(base_fnt_lst, strchr(p + 2, '-'));\r
3382 \r
3383     if ((fntSet = XCreateFontSet(xDisplay, \r
3384                                  base_fnt_lst, \r
3385                                  &missing_list, \r
3386                                  &missing_count, \r
3387                                  &def_string)) == NULL) {\r
3388 \r
3389        fprintf(stderr, _("Unable to create font set.\n"));\r
3390        exit (2);\r
3391     }\r
3392 \r
3393     nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);\r
3394 #else\r
3395     fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);\r
3396     if (nfonts < 1) {\r
3397         fprintf(stderr, _("%s: no fonts match pattern %s\n"),\r
3398                 programName, pattern);\r
3399         exit(2);\r
3400     }\r
3401 #endif\r
3402 \r
3403     best = fonts[0];\r
3404     scalable = NULL;\r
3405     minerr = 999999;\r
3406     for (i=0; i<nfonts; i++) {\r
3407         j = 0;\r
3408         p = fonts[i];\r
3409         if (*p != '-') continue;\r
3410         while (j < 7) {\r
3411             if (*p == NULLCHAR) break;\r
3412             if (*p++ == '-') j++;\r
3413         }\r
3414         if (j < 7) continue;\r
3415         pxlSize = atoi(p);\r
3416         if (pxlSize == 0) {\r
3417             scalable = fonts[i];\r
3418             scalableTail = p;\r
3419         } else {\r
3420             err = pxlSize - targetPxlSize;\r
3421             if (Abs(err) < Abs(minerr) ||\r
3422                 (minerr > 0 && err < 0 && -err == minerr)) {\r
3423                 best = fonts[i];\r
3424                 minerr = err;\r
3425             }\r
3426         }\r
3427     }\r
3428     if (scalable && Abs(minerr) > appData.fontSizeTolerance) {\r
3429         /* If the error is too big and there is a scalable font,\r
3430            use the scalable font. */\r
3431         int headlen = scalableTail - scalable;\r
3432         p = (char *) XtMalloc(strlen(scalable) + 10);\r
3433         while (isdigit(*scalableTail)) scalableTail++;\r
3434         sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);\r
3435     } else {\r
3436         p = (char *) XtMalloc(strlen(best) + 1);\r
3437         strcpy(p, best);\r
3438     }\r
3439     if (appData.debugMode) {\r
3440         fprintf(debugFP, _("resolved %s at pixel size %d\n  to %s\n"),\r
3441                 pattern, targetPxlSize, p);\r
3442     }\r
3443 #ifdef ENABLE_NLS\r
3444     if (missing_count > 0)\r
3445        XFreeStringList(missing_list);\r
3446     XFreeFontSet(xDisplay, fntSet);\r
3447 #else\r
3448      XFreeFontNames(fonts);\r
3449 #endif\r
3450     return p;\r
3451 }\r
3452 \r
3453 void CreateGCs()\r
3454 {\r
3455     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground\r
3456       | GCBackground | GCFunction | GCPlaneMask;\r
3457     XGCValues gc_values;\r
3458     GC copyInvertedGC;\r
3459     \r
3460     gc_values.plane_mask = AllPlanes;\r
3461     gc_values.line_width = lineGap;\r
3462     gc_values.line_style = LineSolid;\r
3463     gc_values.function = GXcopy;\r
3464     \r
3465     gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
3466     gc_values.background = XBlackPixel(xDisplay, xScreen);\r
3467     lineGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3468     \r
3469     gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
3470     gc_values.background = XWhitePixel(xDisplay, xScreen);\r
3471     coordGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3472     XSetFont(xDisplay, coordGC, coordFontID);\r
3473     \r
3474     // [HGM] make font for holdings counts (white on black0\r
3475     gc_values.foreground = XWhitePixel(xDisplay, xScreen);\r
3476     gc_values.background = XBlackPixel(xDisplay, xScreen);\r
3477     countGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3478     XSetFont(xDisplay, countGC, countFontID);\r
3479     \r
3480     if (appData.monoMode) {\r
3481         gc_values.foreground = XWhitePixel(xDisplay, xScreen);\r
3482         gc_values.background = XWhitePixel(xDisplay, xScreen);\r
3483         highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);      \r
3484 \r
3485         gc_values.foreground = XWhitePixel(xDisplay, xScreen);\r
3486         gc_values.background = XBlackPixel(xDisplay, xScreen);\r
3487         lightSquareGC = wbPieceGC \r
3488           = XtGetGC(shellWidget, value_mask, &gc_values);\r
3489 \r
3490         gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
3491         gc_values.background = XWhitePixel(xDisplay, xScreen);\r
3492         darkSquareGC = bwPieceGC\r
3493           = XtGetGC(shellWidget, value_mask, &gc_values);\r
3494 \r
3495         if (DefaultDepth(xDisplay, xScreen) == 1) {\r
3496             /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */\r
3497             gc_values.function = GXcopyInverted;\r
3498             copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3499             gc_values.function = GXcopy;\r
3500             if (XBlackPixel(xDisplay, xScreen) == 1) {\r
3501                 bwPieceGC = darkSquareGC;\r
3502                 wbPieceGC = copyInvertedGC;\r
3503             } else {\r
3504                 bwPieceGC = copyInvertedGC;\r
3505                 wbPieceGC = lightSquareGC;\r
3506             }\r
3507         }\r
3508     } else {\r
3509         gc_values.foreground = highlightSquareColor;\r
3510         gc_values.background = highlightSquareColor;\r
3511         highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);      \r
3512 \r
3513         gc_values.foreground = premoveHighlightColor;\r
3514         gc_values.background = premoveHighlightColor;\r
3515         prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);       \r
3516 \r
3517         gc_values.foreground = lightSquareColor;\r
3518         gc_values.background = darkSquareColor;\r
3519         lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3520         \r
3521         gc_values.foreground = darkSquareColor;\r
3522         gc_values.background = lightSquareColor;\r
3523         darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3524 \r
3525         gc_values.foreground = jailSquareColor;\r
3526         gc_values.background = jailSquareColor;\r
3527         jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3528 \r
3529         gc_values.foreground = whitePieceColor;\r
3530         gc_values.background = darkSquareColor;\r
3531         wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3532         \r
3533         gc_values.foreground = whitePieceColor;\r
3534         gc_values.background = lightSquareColor;\r
3535         wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3536         \r
3537         gc_values.foreground = whitePieceColor;\r
3538         gc_values.background = jailSquareColor;\r
3539         wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3540         \r
3541         gc_values.foreground = blackPieceColor;\r
3542         gc_values.background = darkSquareColor;\r
3543         bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3544         \r
3545         gc_values.foreground = blackPieceColor;\r
3546         gc_values.background = lightSquareColor;\r
3547         blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3548 \r
3549         gc_values.foreground = blackPieceColor;\r
3550         gc_values.background = jailSquareColor;\r
3551         bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
3552     }\r
3553 }\r
3554 \r
3555 void loadXIM(xim, xmask, filename, dest, mask)\r
3556      XImage *xim;\r
3557      XImage *xmask;\r
3558      char *filename;\r
3559      Pixmap *dest;\r
3560      Pixmap *mask;\r
3561 {\r
3562     int x, y, w, h, p;\r
3563     FILE *fp;\r
3564     Pixmap temp;\r
3565     XGCValues   values;\r
3566     GC maskGC;\r
3567 \r
3568     fp = fopen(filename, "rb");\r
3569     if (!fp) {\r
3570         fprintf(stderr, _("%s: error loading XIM!\n"), programName);\r
3571         exit(1);\r
3572     }\r
3573           \r
3574     w = fgetc(fp);\r
3575     h = fgetc(fp);\r
3576   \r
3577     for (y=0; y<h; ++y) {\r
3578         for (x=0; x<h; ++x) {\r
3579             p = fgetc(fp);\r
3580 \r
3581             switch (p) {\r
3582               case 0:   \r
3583                 XPutPixel(xim, x, y, blackPieceColor); \r
3584                 if (xmask)\r
3585                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));\r
3586                 break;\r
3587               case 1:   \r
3588                 XPutPixel(xim, x, y, darkSquareColor); \r
3589                 if (xmask)\r
3590                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));\r
3591                 break;\r
3592               case 2:   \r
3593                 XPutPixel(xim, x, y, whitePieceColor); \r
3594                 if (xmask)\r
3595                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));\r
3596                 break;\r
3597               case 3:   \r
3598                 XPutPixel(xim, x, y, lightSquareColor);\r
3599                 if (xmask)\r
3600                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));\r
3601                 break;\r
3602             }\r
3603         }\r
3604     }\r
3605 \r
3606     /* create Pixmap of piece */\r
3607     *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
3608                           w, h, xim->depth);\r
3609     XPutImage(xDisplay, *dest, lightSquareGC, xim,\r
3610               0, 0, 0, 0, w, h);  \r
3611 \r
3612     /* create Pixmap of clipmask \r
3613        Note: We assume the white/black pieces have the same\r
3614              outline, so we make only 6 masks. This is okay\r
3615              since the XPM clipmask routines do the same. */\r
3616     if (xmask) {\r
3617       temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
3618                             w, h, xim->depth);\r
3619       XPutImage(xDisplay, temp, lightSquareGC, xmask,\r
3620               0, 0, 0, 0, w, h);  \r
3621 \r
3622       /* now create the 1-bit version */\r
3623       *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
3624                           w, h, 1);\r
3625 \r
3626       values.foreground = 1;\r
3627       values.background = 0;\r
3628 \r
3629       /* Don't use XtGetGC, not read only */\r
3630       maskGC = XCreateGC(xDisplay, *mask, \r
3631                     GCForeground | GCBackground, &values);\r
3632       XCopyPlane(xDisplay, temp, *mask, maskGC, \r
3633                   0, 0, squareSize, squareSize, 0, 0, 1);\r
3634       XFreePixmap(xDisplay, temp);\r
3635     }\r
3636 }\r
3637 \r
3638 void CreateXIMPieces()\r
3639 {\r
3640     int piece, kind;\r
3641     char buf[MSG_SIZ];\r
3642     u_int ss;\r
3643     static char *ximkind[] = { "ll", "ld", "dl", "dd" };\r
3644     XImage *ximtemp;\r
3645 \r
3646     ss = squareSize;\r
3647 \r
3648     /* The XSynchronize calls were copied from CreatePieces.\r
3649        Not sure if needed, but can't hurt */\r
3650     XSynchronize(xDisplay, True); /* Work-around for xlib/xt\r
3651                                      buffering bug */\r
3652   \r
3653     /* temp needed by loadXIM() */\r
3654     ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
3655                  0, 0, ss, ss, AllPlanes, XYPixmap);\r
3656 \r
3657     if (strlen(appData.pixmapDirectory) == 0) {\r
3658       useImages = 0;\r
3659     } else {\r
3660         useImages = 1;\r
3661         if (appData.monoMode) {\r
3662           DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),\r
3663                             0, 2);\r
3664           ExitEvent(2);\r
3665         }\r
3666         fprintf(stderr, _("\nLoading XIMs...\n"));\r
3667         /* Load pieces */\r
3668         for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
3669             fprintf(stderr, "%d", piece+1);\r
3670             for (kind=0; kind<4; kind++) {\r
3671                 fprintf(stderr, ".");\r
3672                 sprintf(buf, "%s/%c%s%u.xim",\r
3673                         ExpandPathName(appData.pixmapDirectory),\r
3674                         ToLower(PieceToChar((ChessSquare)piece)),\r
3675                         ximkind[kind], ss);\r
3676                 ximPieceBitmap[kind][piece] =\r
3677                   XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
3678                             0, 0, ss, ss, AllPlanes, XYPixmap);\r
3679                 if (appData.debugMode)\r
3680                   fprintf(stderr, _("(File:%s:) "), buf);\r
3681                 loadXIM(ximPieceBitmap[kind][piece], \r
3682                         ximtemp, buf,\r
3683                         &(xpmPieceBitmap[kind][piece]),\r
3684                         &(ximMaskPm[piece%(int)BlackPawn]));\r
3685             }\r
3686             fprintf(stderr," ");\r
3687         }\r
3688         /* Load light and dark squares */\r
3689         /* If the LSQ and DSQ pieces don't exist, we will \r
3690            draw them with solid squares. */\r
3691         sprintf(buf, "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);\r
3692         if (access(buf, 0) != 0) {\r
3693             useImageSqs = 0;\r
3694         } else {\r
3695         &nb