2 * xboard.c -- X front end for XBoard
4 * Copyright 1991 by Digital Equipment Corporation, Maynard,
7 * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
8 * 2007, 2008, 2009 Free Software Foundation, Inc.
10 * The following terms apply to Digital Equipment Corporation's copyright
12 * ------------------------------------------------------------------------
15 * Permission to use, copy, modify, and distribute this software and its
16 * documentation for any purpose and without fee is hereby granted,
17 * provided that the above copyright notice appear in all copies and that
18 * both that copyright notice and this permission notice appear in
19 * supporting documentation, and that the name of Digital not be
20 * used in advertising or publicity pertaining to distribution of the
21 * software without specific, written prior permission.
23 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
30 * ------------------------------------------------------------------------
32 * The following terms apply to the enhanced version of XBoard
33 * distributed by the Free Software Foundation:
34 * ------------------------------------------------------------------------
36 * GNU XBoard is free software: you can redistribute it and/or modify
37 * it under the terms of the GNU General Public License as published by
38 * the Free Software Foundation, either version 3 of the License, or (at
39 * your option) any later version.
41 * GNU XBoard is distributed in the hope that it will be useful, but
42 * WITHOUT ANY WARRANTY; without even the implied warranty of
43 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44 * General Public License for more details.
46 * You should have received a copy of the GNU General Public License
47 * along with this program. If not, see http://www.gnu.org/licenses/. *
49 *------------------------------------------------------------------------
50 ** See the file ChangeLog for a revision history. */
58 #include <sys/types.h>
63 # if HAVE_SYS_SOCKET_H
64 # include <sys/socket.h>
65 # include <netinet/in.h>
67 # else /* not HAVE_SYS_SOCKET_H */
68 # if HAVE_LAN_SOCKET_H
69 # include <lan/socket.h>
71 # include <lan/netdb.h>
72 # else /* not HAVE_LAN_SOCKET_H */
73 # define OMIT_SOCKETS 1
74 # endif /* not HAVE_LAN_SOCKET_H */
75 # endif /* not HAVE_SYS_SOCKET_H */
76 #endif /* !OMIT_SOCKETS */
81 #else /* not STDC_HEADERS */
82 extern char *getenv();
85 # else /* not HAVE_STRING_H */
87 # endif /* not HAVE_STRING_H */
88 #endif /* not STDC_HEADERS */
91 # include <sys/fcntl.h>
92 #else /* not HAVE_SYS_FCNTL_H */
95 # endif /* HAVE_FCNTL_H */
96 #endif /* not HAVE_SYS_FCNTL_H */
98 #if HAVE_SYS_SYSTEMINFO_H
99 # include <sys/systeminfo.h>
100 #endif /* HAVE_SYS_SYSTEMINFO_H */
102 #if TIME_WITH_SYS_TIME
103 # include <sys/time.h>
107 # include <sys/time.h>
118 # include <sys/wait.h>
123 # define NAMLEN(dirent) strlen((dirent)->d_name)
124 # define HAVE_DIR_STRUCT
126 # define dirent direct
127 # define NAMLEN(dirent) (dirent)->d_namlen
129 # include <sys/ndir.h>
130 # define HAVE_DIR_STRUCT
133 # include <sys/dir.h>
134 # define HAVE_DIR_STRUCT
138 # define HAVE_DIR_STRUCT
142 #include <X11/Intrinsic.h>
143 #include <X11/StringDefs.h>
144 #include <X11/Shell.h>
145 #include <X11/cursorfont.h>
146 #include <X11/Xatom.h>
148 #include <X11/Xaw3d/Dialog.h>
149 #include <X11/Xaw3d/Form.h>
150 #include <X11/Xaw3d/List.h>
151 #include <X11/Xaw3d/Label.h>
152 #include <X11/Xaw3d/SimpleMenu.h>
153 #include <X11/Xaw3d/SmeBSB.h>
154 #include <X11/Xaw3d/SmeLine.h>
155 #include <X11/Xaw3d/Box.h>
156 #include <X11/Xaw3d/MenuButton.h>
157 #include <X11/Xaw3d/Text.h>
158 #include <X11/Xaw3d/AsciiText.h>
160 #include <X11/Xaw/Dialog.h>
161 #include <X11/Xaw/Form.h>
162 #include <X11/Xaw/List.h>
163 #include <X11/Xaw/Label.h>
164 #include <X11/Xaw/SimpleMenu.h>
165 #include <X11/Xaw/SmeBSB.h>
166 #include <X11/Xaw/SmeLine.h>
167 #include <X11/Xaw/Box.h>
168 #include <X11/Xaw/MenuButton.h>
169 #include <X11/Xaw/Text.h>
170 #include <X11/Xaw/AsciiText.h>
173 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
178 #include "pixmaps/pixmaps.h"
179 #define IMAGE_EXT "xpm"
181 #define IMAGE_EXT "xim"
182 #include "bitmaps/bitmaps.h"
185 #include "bitmaps/icon_white.bm"
186 #include "bitmaps/icon_black.bm"
187 #include "bitmaps/checkmark.bm"
189 #include "frontend.h"
194 #include "xgamelist.h"
195 #include "xhistory.h"
196 #include "xedittags.h"
199 // must be moved to xengineoutput.h
201 void EngineOutputProc P((Widget w, XEvent *event,
202 String *prms, Cardinal *nprms));
204 void EngineOutputPopDown();
211 #define usleep(t) _sleep2(((t)+500)/1000)
215 # define _(s) gettext (s)
216 # define N_(s) gettext_noop (s)
232 int main P((int argc, char **argv));
233 RETSIGTYPE CmailSigHandler P((int sig));
234 RETSIGTYPE IntSigHandler P((int sig));
235 RETSIGTYPE TermSizeSigHandler P((int sig));
236 void CreateGCs P((void));
237 void CreateXIMPieces P((void));
238 void CreateXPMPieces P((void));
239 void CreatePieces P((void));
240 void CreatePieceMenus P((void));
241 Widget CreateMenuBar P((Menu *mb));
242 Widget CreateButtonBar P ((MenuItem *mi));
243 char *FindFont P((char *pattern, int targetPxlSize));
244 void PieceMenuPopup P((Widget w, XEvent *event,
245 String *params, Cardinal *num_params));
246 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
247 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
248 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
249 u_int wreq, u_int hreq));
250 void CreateGrid P((void));
251 int EventToSquare P((int x, int limit));
252 void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
253 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
254 void HandleUserMove P((Widget w, XEvent *event,
255 String *prms, Cardinal *nprms));
256 void AnimateUserMove P((Widget w, XEvent * event,
257 String * params, Cardinal * nParams));
258 void WhiteClock P((Widget w, XEvent *event,
259 String *prms, Cardinal *nprms));
260 void BlackClock P((Widget w, XEvent *event,
261 String *prms, Cardinal *nprms));
262 void DrawPositionProc P((Widget w, XEvent *event,
263 String *prms, Cardinal *nprms));
264 void XDrawPosition P((Widget w, /*Boolean*/int repaint,
266 void CommentPopUp P((char *title, char *label));
267 void CommentPopDown P((void));
268 void CommentCallback P((Widget w, XtPointer client_data,
269 XtPointer call_data));
270 void ICSInputBoxPopUp P((void));
271 void ICSInputBoxPopDown P((void));
272 void FileNamePopUp P((char *label, char *def,
273 FileProc proc, char *openMode));
274 void FileNamePopDown P((void));
275 void FileNameCallback P((Widget w, XtPointer client_data,
276 XtPointer call_data));
277 void FileNameAction P((Widget w, XEvent *event,
278 String *prms, Cardinal *nprms));
279 void AskQuestionReplyAction P((Widget w, XEvent *event,
280 String *prms, Cardinal *nprms));
281 void AskQuestionProc P((Widget w, XEvent *event,
282 String *prms, Cardinal *nprms));
283 void AskQuestionPopDown P((void));
284 void PromotionPopUp P((void));
285 void PromotionPopDown P((void));
286 void PromotionCallback P((Widget w, XtPointer client_data,
287 XtPointer call_data));
288 void EditCommentPopDown P((void));
289 void EditCommentCallback P((Widget w, XtPointer client_data,
290 XtPointer call_data));
291 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
292 void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
293 void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
294 void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
296 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
298 void ReloadGameProc P((Widget w, XEvent *event, String *prms,
300 void LoadPositionProc P((Widget w, XEvent *event,
301 String *prms, Cardinal *nprms));
302 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
304 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
306 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
308 void CopyPositionProc P((Widget w, XEvent *event, String *prms,
310 void PastePositionProc P((Widget w, XEvent *event, String *prms,
312 void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
313 void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
314 void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
315 void SavePositionProc P((Widget w, XEvent *event,
316 String *prms, Cardinal *nprms));
317 void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
318 void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
320 void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
321 void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
322 void MachineBlackProc P((Widget w, XEvent *event, String *prms,
324 void MachineWhiteProc P((Widget w, XEvent *event,
325 String *prms, Cardinal *nprms));
326 void AnalyzeModeProc P((Widget w, XEvent *event,
327 String *prms, Cardinal *nprms));
328 void AnalyzeFileProc P((Widget w, XEvent *event,
329 String *prms, Cardinal *nprms));
330 void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
332 void IcsClientProc P((Widget w, XEvent *event, String *prms,
334 void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
335 void EditPositionProc P((Widget w, XEvent *event,
336 String *prms, Cardinal *nprms));
337 void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
338 void EditCommentProc P((Widget w, XEvent *event,
339 String *prms, Cardinal *nprms));
340 void IcsInputBoxProc P((Widget w, XEvent *event,
341 String *prms, Cardinal *nprms));
342 void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
343 void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
344 void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
345 void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
346 void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
347 void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
348 void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
349 void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
350 void AdjuWhiteProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
351 void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
352 void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
353 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
354 void StopObservingProc P((Widget w, XEvent *event, String *prms,
356 void StopExaminingProc P((Widget w, XEvent *event, String *prms,
358 void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
359 void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
360 void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
361 void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
362 void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
363 void TruncateGameProc P((Widget w, XEvent *event, String *prms,
365 void RetractMoveProc P((Widget w, XEvent *event, String *prms,
367 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
368 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
370 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
372 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
374 void AutocommProc P((Widget w, XEvent *event, String *prms,
376 void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
377 void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
378 void AutobsProc P((Widget w, XEvent *event, String *prms,
380 void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
381 void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
382 void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
383 void FlashMovesProc P((Widget w, XEvent *event, String *prms,
385 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
386 void GetMoveListProc P((Widget w, XEvent *event, String *prms,
388 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
390 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
392 void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
393 void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
394 void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
396 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
398 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
400 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
402 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
404 void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
405 void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
406 void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
408 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
410 void HideThinkingProc P((Widget w, XEvent *event, String *prms,
412 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
414 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
415 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
416 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
417 void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
418 void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
419 void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
420 void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
421 void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
422 void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
423 void DisplayMove P((int moveNumber));
424 void DisplayTitle P((char *title));
425 void ICSInitScript P((void));
426 int LoadGamePopUp P((FILE *f, int gameNumber, char *title));
427 void ErrorPopUp P((char *title, char *text, int modal));
428 void ErrorPopDown P((void));
429 static char *ExpandPathName P((char *path));
430 static void CreateAnimVars P((void));
431 static void DragPieceBegin P((int x, int y));
432 static void DragPieceMove P((int x, int y));
433 static void DragPieceEnd P((int x, int y));
434 static void DrawDragPiece P((void));
435 char *ModeToWidgetName P((GameMode mode));
436 void EngineOutputUpdate( FrontEndProgramStats * stats );
437 void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
438 void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
439 void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
440 void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
441 void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
442 void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
443 void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
444 void ShufflePopDown P(());
445 void EnginePopDown P(());
446 void UciPopDown P(());
447 void TimeControlPopDown P(());
448 void NewVariantPopDown P(());
449 void SettingsPopDown P(());
450 void update_ics_width P(());
451 int get_term_width P(());
453 * XBoard depends on Xt R4 or higher
455 int xtVersion = XtSpecificationRelease;
460 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
461 jailSquareColor, highlightSquareColor, premoveHighlightColor;
462 Pixel lowTimeWarningColor;
463 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
464 bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
465 wjPieceGC, bjPieceGC, prelineGC, countGC;
466 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
467 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
468 whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
469 commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
470 menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
471 ICSInputShell, fileNameShell, askQuestionShell;
472 XSegment gridSegments[(BOARD_SIZE + 1) * 2];
473 XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
474 Font clockFontID, coordFontID, countFontID;
475 XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
476 XtAppContext appContext;
478 char *oldICSInteractionTitle;
482 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
484 Position commentX = -1, commentY = -1;
485 Dimension commentW, commentH;
487 int squareSize, smallLayout = 0, tinyLayout = 0,
488 marginW, marginH, // [HGM] for run-time resizing
489 fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
490 ICSInputBoxUp = False, askQuestionUp = False,
491 filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
492 editUp = False, errorUp = False, errorExitStatus = -1, lineGap;
493 Pixel timerForegroundPixel, timerBackgroundPixel;
494 Pixel buttonForegroundPixel, buttonBackgroundPixel;
495 char *chessDir, *programName, *programVersion,
496 *gameCopyFilename, *gamePasteFilename;
500 Pixmap pieceBitmap[2][(int)BlackPawn];
501 Pixmap pieceBitmap2[2][(int)BlackPawn+4]; /* [HGM] pieces */
502 Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
503 Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
504 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
505 int useImages, useImageSqs;
506 XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
507 Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
508 Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
509 XImage *ximLightSquare, *ximDarkSquare;
512 #define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
513 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
515 #define White(piece) ((int)(piece) < (int)BlackPawn)
517 /* Variables for doing smooth animation. This whole thing
518 would be much easier if the board was double-buffered,
519 but that would require a fairly major rewrite. */
524 GC blitGC, pieceGC, outlineGC;
525 XPoint startSquare, prevFrame, mouseDelta;
529 int startBoardX, startBoardY;
532 /* There can be two pieces being animated at once: a player
533 can begin dragging a piece before the remote opponent has moved. */
535 static AnimState game, player;
537 /* Bitmaps for use as masks when drawing XPM pieces.
538 Need one for each black and white piece. */
539 static Pixmap xpmMask[BlackKing + 1];
541 /* This magic number is the number of intermediate frames used
542 in each half of the animation. For short moves it's reduced
543 by 1. The total number of frames will be factor * 2 + 1. */
546 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
548 MenuItem fileMenu[] = {
549 {N_("New Game"), ResetProc},
550 {N_("New Shuffle Game ..."), ShuffleMenuProc},
551 {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
552 {"----", NothingProc},
553 {N_("Load Game"), LoadGameProc},
554 {N_("Load Next Game"), LoadNextGameProc},
555 {N_("Load Previous Game"), LoadPrevGameProc},
556 {N_("Reload Same Game"), ReloadGameProc},
557 {N_("Save Game"), SaveGameProc},
558 {"----", NothingProc},
559 {N_("Copy Game"), CopyGameProc},
560 {N_("Paste Game"), PasteGameProc},
561 {"----", NothingProc},
562 {N_("Load Position"), LoadPositionProc},
563 {N_("Load Next Position"), LoadNextPositionProc},
564 {N_("Load Previous Position"), LoadPrevPositionProc},
565 {N_("Reload Same Position"), ReloadPositionProc},
566 {N_("Save Position"), SavePositionProc},
567 {"----", NothingProc},
568 {N_("Copy Position"), CopyPositionProc},
569 {N_("Paste Position"), PastePositionProc},
570 {"----", NothingProc},
571 {N_("Mail Move"), MailMoveProc},
572 {N_("Reload CMail Message"), ReloadCmailMsgProc},
573 {"----", NothingProc},
574 {N_("Exit"), QuitProc},
578 MenuItem modeMenu[] = {
579 {N_("Machine White"), MachineWhiteProc},
580 {N_("Machine Black"), MachineBlackProc},
581 {N_("Two Machines"), TwoMachinesProc},
582 {N_("Analysis Mode"), AnalyzeModeProc},
583 {N_("Analyze File"), AnalyzeFileProc },
584 {N_("ICS Client"), IcsClientProc},
585 {N_("Edit Game"), EditGameProc},
586 {N_("Edit Position"), EditPositionProc},
587 {N_("Training"), TrainingProc},
588 {"----", NothingProc},
589 {N_("Show Engine Output"), EngineOutputProc},
590 {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
591 {N_("Show Game List"), ShowGameListProc},
592 {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
593 {"----", NothingProc},
594 {N_("Edit Tags"), EditTagsProc},
595 {N_("Edit Comment"), EditCommentProc},
596 {N_("ICS Input Box"), IcsInputBoxProc},
597 {N_("Pause"), PauseProc},
601 MenuItem actionMenu[] = {
602 {N_("Accept"), AcceptProc},
603 {N_("Decline"), DeclineProc},
604 {N_("Rematch"), RematchProc},
605 {"----", NothingProc},
606 {N_("Call Flag"), CallFlagProc},
607 {N_("Draw"), DrawProc},
608 {N_("Adjourn"), AdjournProc},
609 {N_("Abort"), AbortProc},
610 {N_("Resign"), ResignProc},
611 {"----", NothingProc},
612 {N_("Stop Observing"), StopObservingProc},
613 {N_("Stop Examining"), StopExaminingProc},
614 {"----", NothingProc},
615 {N_("Adjudicate to White"), AdjuWhiteProc},
616 {N_("Adjudicate to Black"), AdjuBlackProc},
617 {N_("Adjudicate Draw"), AdjuDrawProc},
621 MenuItem stepMenu[] = {
622 {N_("Backward"), BackwardProc},
623 {N_("Forward"), ForwardProc},
624 {N_("Back to Start"), ToStartProc},
625 {N_("Forward to End"), ToEndProc},
626 {N_("Revert"), RevertProc},
627 {N_("Truncate Game"), TruncateGameProc},
628 {"----", NothingProc},
629 {N_("Move Now"), MoveNowProc},
630 {N_("Retract Move"), RetractMoveProc},
634 MenuItem optionsMenu[] = {
635 {N_("Flip View"), FlipViewProc},
636 {"----", NothingProc},
637 {N_("Adjudications ..."), EngineMenuProc},
638 {N_("General Settings ..."), UciMenuProc},
639 {N_("Engine #1 Settings ..."), FirstSettingsProc},
640 {N_("Engine #2 Settings ..."), SecondSettingsProc},
641 {N_("Time Control ..."), TimeControlProc},
642 {"----", NothingProc},
643 {N_("Always Queen"), AlwaysQueenProc},
644 {N_("Animate Dragging"), AnimateDraggingProc},
645 {N_("Animate Moving"), AnimateMovingProc},
646 {N_("Auto Comment"), AutocommProc},
647 {N_("Auto Flag"), AutoflagProc},
648 {N_("Auto Flip View"), AutoflipProc},
649 {N_("Auto Observe"), AutobsProc},
650 {N_("Auto Raise Board"), AutoraiseProc},
651 {N_("Auto Save"), AutosaveProc},
652 {N_("Blindfold"), BlindfoldProc},
653 {N_("Flash Moves"), FlashMovesProc},
654 {N_("Get Move List"), GetMoveListProc},
656 {N_("Highlight Dragging"), HighlightDraggingProc},
658 {N_("Highlight Last Move"), HighlightLastMoveProc},
659 {N_("Move Sound"), MoveSoundProc},
660 {N_("ICS Alarm"), IcsAlarmProc},
661 {N_("Old Save Style"), OldSaveStyleProc},
662 {N_("Periodic Updates"), PeriodicUpdatesProc},
663 {N_("Ponder Next Move"), PonderNextMoveProc},
664 {N_("Popup Exit Message"), PopupExitMessageProc},
665 {N_("Popup Move Errors"), PopupMoveErrorsProc},
666 {N_("Premove"), PremoveProc},
667 {N_("Quiet Play"), QuietPlayProc},
668 {N_("Show Coords"), ShowCoordsProc},
669 {N_("Hide Thinking"), HideThinkingProc},
670 {N_("Test Legality"), TestLegalityProc},
674 MenuItem helpMenu[] = {
675 {N_("Info XBoard"), InfoProc},
676 {N_("Man XBoard"), ManProc},
677 {"----", NothingProc},
678 {N_("Hint"), HintProc},
679 {N_("Book"), BookProc},
680 {"----", NothingProc},
681 {N_("About XBoard"), AboutProc},
686 {N_("File"), fileMenu},
687 {N_("Mode"), modeMenu},
688 {N_("Action"), actionMenu},
689 {N_("Step"), stepMenu},
690 {N_("Options"), optionsMenu},
691 {N_("Help"), helpMenu},
695 #define PAUSE_BUTTON N_("P")
696 MenuItem buttonBar[] = {
699 {PAUSE_BUTTON, PauseProc},
705 #define PIECE_MENU_SIZE 18
706 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
707 { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
708 N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
709 N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
710 N_("Empty square"), N_("Clear board") },
711 { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
712 N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
713 N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
714 N_("Empty square"), N_("Clear board") }
716 /* must be in same order as PieceMenuStrings! */
717 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
718 { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
719 WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
720 WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
721 PromotePiece, DemotePiece, EmptySquare, ClearBoard },
722 { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
723 BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
724 BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
725 PromotePiece, DemotePiece, EmptySquare, ClearBoard },
728 #define DROP_MENU_SIZE 6
729 String dropMenuStrings[DROP_MENU_SIZE] = {
730 "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
732 /* must be in same order as PieceMenuStrings! */
733 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
734 (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
735 WhiteRook, WhiteQueen
743 DropMenuEnables dmEnables[] = {
761 { XtNborderWidth, 0 },
762 { XtNdefaultDistance, 0 },
766 { XtNborderWidth, 0 },
767 { XtNresizable, (XtArgVal) True },
771 { XtNborderWidth, 0 },
777 { XtNjustify, (XtArgVal) XtJustifyRight },
778 { XtNlabel, (XtArgVal) "..." },
779 { XtNresizable, (XtArgVal) True },
780 { XtNresize, (XtArgVal) False }
783 Arg messageArgs[] = {
784 { XtNjustify, (XtArgVal) XtJustifyLeft },
785 { XtNlabel, (XtArgVal) "..." },
786 { XtNresizable, (XtArgVal) True },
787 { XtNresize, (XtArgVal) False }
791 { XtNborderWidth, 0 },
792 { XtNjustify, (XtArgVal) XtJustifyLeft }
795 XtResource clientResources[] = {
796 { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
797 XtOffset(AppDataPtr, whitePieceColor), XtRString,
799 { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
800 XtOffset(AppDataPtr, blackPieceColor), XtRString,
802 { "lightSquareColor", "lightSquareColor", XtRString,
803 sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
804 XtRString, LIGHT_SQUARE_COLOR },
805 { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
806 XtOffset(AppDataPtr, darkSquareColor), XtRString,
808 { "highlightSquareColor", "highlightSquareColor", XtRString,
809 sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
810 XtRString, HIGHLIGHT_SQUARE_COLOR },
811 { "premoveHighlightColor", "premoveHighlightColor", XtRString,
812 sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
813 XtRString, PREMOVE_HIGHLIGHT_COLOR },
814 { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
815 XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
816 (XtPointer) MOVES_PER_SESSION },
817 { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
818 XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
819 (XtPointer) TIME_INCREMENT },
820 { "initString", "initString", XtRString, sizeof(String),
821 XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
822 { "secondInitString", "secondInitString", XtRString, sizeof(String),
823 XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
824 { "firstComputerString", "firstComputerString", XtRString,
825 sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
827 { "secondComputerString", "secondComputerString", XtRString,
828 sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
830 { "firstChessProgram", "firstChessProgram", XtRString,
831 sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
832 XtRString, FIRST_CHESS_PROGRAM },
833 { "secondChessProgram", "secondChessProgram", XtRString,
834 sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
835 XtRString, SECOND_CHESS_PROGRAM },
836 { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
837 sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
838 XtRImmediate, (XtPointer) False },
839 { "noChessProgram", "noChessProgram", XtRBoolean,
840 sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
841 XtRImmediate, (XtPointer) False },
842 { "firstHost", "firstHost", XtRString, sizeof(String),
843 XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
844 { "secondHost", "secondHost", XtRString, sizeof(String),
845 XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
846 { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
847 XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
848 { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
849 XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
850 { "bitmapDirectory", "bitmapDirectory", XtRString,
851 sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
853 { "remoteShell", "remoteShell", XtRString, sizeof(String),
854 XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
855 { "remoteUser", "remoteUser", XtRString, sizeof(String),
856 XtOffset(AppDataPtr, remoteUser), XtRString, "" },
857 { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
858 XtOffset(AppDataPtr, timeDelay), XtRString,
859 (XtPointer) TIME_DELAY_QUOTE },
860 { "timeControl", "timeControl", XtRString, sizeof(String),
861 XtOffset(AppDataPtr, timeControl), XtRString,
862 (XtPointer) TIME_CONTROL },
863 { "internetChessServerMode", "internetChessServerMode",
864 XtRBoolean, sizeof(Boolean),
865 XtOffset(AppDataPtr, icsActive), XtRImmediate,
867 { "internetChessServerHost", "internetChessServerHost",
868 XtRString, sizeof(String),
869 XtOffset(AppDataPtr, icsHost),
870 XtRString, (XtPointer) ICS_HOST },
871 { "internetChessServerPort", "internetChessServerPort",
872 XtRString, sizeof(String),
873 XtOffset(AppDataPtr, icsPort), XtRString,
874 (XtPointer) ICS_PORT },
875 { "internetChessServerCommPort", "internetChessServerCommPort",
876 XtRString, sizeof(String),
877 XtOffset(AppDataPtr, icsCommPort), XtRString,
879 { "internetChessServerLogonScript", "internetChessServerLogonScript",
880 XtRString, sizeof(String),
881 XtOffset(AppDataPtr, icsLogon), XtRString,
883 { "internetChessServerHelper", "internetChessServerHelper",
884 XtRString, sizeof(String),
885 XtOffset(AppDataPtr, icsHelper), XtRString, "" },
886 { "internetChessServerInputBox", "internetChessServerInputBox",
887 XtRBoolean, sizeof(Boolean),
888 XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
890 { "icsAlarm", "icsAlarm",
891 XtRBoolean, sizeof(Boolean),
892 XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
894 { "icsAlarmTime", "icsAlarmTime",
896 XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
898 { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
899 XtOffset(AppDataPtr, useTelnet), XtRImmediate,
901 { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
902 XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
903 { "gateway", "gateway", XtRString, sizeof(String),
904 XtOffset(AppDataPtr, gateway), XtRString, "" },
905 { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
906 XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
907 { "loadGameIndex", "loadGameIndex",
909 XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
911 { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
912 XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
913 { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
914 sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
915 XtRImmediate, (XtPointer) True },
916 { "autoSaveGames", "autoSaveGames", XtRBoolean,
917 sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
918 XtRImmediate, (XtPointer) False },
919 { "blindfold", "blindfold", XtRBoolean,
920 sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
921 XtRImmediate, (XtPointer) False },
922 { "loadPositionFile", "loadPositionFile", XtRString,
923 sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
925 { "loadPositionIndex", "loadPositionIndex",
927 XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
929 { "savePositionFile", "savePositionFile", XtRString,
930 sizeof(String), XtOffset(AppDataPtr, savePositionFile),
932 { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
933 XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
934 { "matchGames", "matchGames", XtRInt, sizeof(int),
935 XtOffset(AppDataPtr, matchGames), XtRImmediate,
937 { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
938 XtOffset(AppDataPtr, monoMode), XtRImmediate,
940 { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
941 XtOffset(AppDataPtr, debugMode), XtRImmediate,
943 { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
944 XtOffset(AppDataPtr, clockMode), XtRImmediate,
946 { "boardSize", "boardSize", XtRString, sizeof(String),
947 XtOffset(AppDataPtr, boardSize), XtRString, "" },
948 { "searchTime", "searchTime", XtRString, sizeof(String),
949 XtOffset(AppDataPtr, searchTime), XtRString,
951 { "searchDepth", "searchDepth", XtRInt, sizeof(int),
952 XtOffset(AppDataPtr, searchDepth), XtRImmediate,
954 { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
955 XtOffset(AppDataPtr, showCoords), XtRImmediate,
957 { "showJail", "showJail", XtRInt, sizeof(int),
958 XtOffset(AppDataPtr, showJail), XtRImmediate,
960 { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
961 XtOffset(AppDataPtr, showThinking), XtRImmediate,
963 { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
964 XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
966 { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
967 XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
969 { "clockFont", "clockFont", XtRString, sizeof(String),
970 XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
971 { "coordFont", "coordFont", XtRString, sizeof(String),
972 XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
973 { "font", "font", XtRString, sizeof(String),
974 XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
975 { "ringBellAfterMoves", "ringBellAfterMoves",
976 XtRBoolean, sizeof(Boolean),
977 XtOffset(AppDataPtr, ringBellAfterMoves),
978 XtRImmediate, (XtPointer) False },
979 { "autoCallFlag", "autoCallFlag", XtRBoolean,
980 sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
981 XtRImmediate, (XtPointer) False },
982 { "autoFlipView", "autoFlipView", XtRBoolean,
983 sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
984 XtRImmediate, (XtPointer) True },
985 { "autoObserve", "autoObserve", XtRBoolean,
986 sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
987 XtRImmediate, (XtPointer) False },
988 { "autoComment", "autoComment", XtRBoolean,
989 sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
990 XtRImmediate, (XtPointer) False },
991 { "getMoveList", "getMoveList", XtRBoolean,
992 sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
993 XtRImmediate, (XtPointer) True },
995 { "highlightDragging", "highlightDragging", XtRBoolean,
996 sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
997 XtRImmediate, (XtPointer) False },
999 { "highlightLastMove", "highlightLastMove", XtRBoolean,
1000 sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
1001 XtRImmediate, (XtPointer) False },
1002 { "premove", "premove", XtRBoolean,
1003 sizeof(Boolean), XtOffset(AppDataPtr, premove),
1004 XtRImmediate, (XtPointer) True },
1005 { "testLegality", "testLegality", XtRBoolean,
1006 sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
1007 XtRImmediate, (XtPointer) True },
1008 { "flipView", "flipView", XtRBoolean,
1009 sizeof(Boolean), XtOffset(AppDataPtr, flipView),
1010 XtRImmediate, (XtPointer) False },
1011 { "cmail", "cmailGameName", XtRString, sizeof(String),
1012 XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
1013 { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
1014 sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
1015 XtRImmediate, (XtPointer) False },
1016 { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
1017 sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
1018 XtRImmediate, (XtPointer) False },
1019 { "quietPlay", "quietPlay", XtRBoolean,
1020 sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
1021 XtRImmediate, (XtPointer) False },
1022 { "titleInWindow", "titleInWindow", XtRBoolean,
1023 sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
1024 XtRImmediate, (XtPointer) False },
1025 { "localLineEditing", "localLineEditing", XtRBoolean,
1026 sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
1027 XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
1029 { "zippyTalk", "zippyTalk", XtRBoolean,
1030 sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
1031 XtRImmediate, (XtPointer) ZIPPY_TALK },
1032 { "zippyPlay", "zippyPlay", XtRBoolean,
1033 sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
1034 XtRImmediate, (XtPointer) ZIPPY_PLAY },
1035 { "zippyLines", "zippyLines", XtRString, sizeof(String),
1036 XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
1037 { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
1038 XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
1039 { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
1040 XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
1041 { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
1042 XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
1043 { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
1044 XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
1045 ZIPPY_WRONG_PASSWORD },
1046 { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
1047 XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
1048 { "zippyUseI", "zippyUseI", XtRBoolean,
1049 sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
1050 XtRImmediate, (XtPointer) ZIPPY_USE_I },
1051 { "zippyBughouse", "zippyBughouse", XtRInt,
1052 sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
1053 XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
1054 { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
1055 sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
1056 XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
1057 { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
1058 XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
1059 { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
1060 XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
1061 { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
1062 sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
1063 XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
1064 { "zippyAbort", "zippyAbort", XtRBoolean,
1065 sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
1066 XtRImmediate, (XtPointer) ZIPPY_ABORT },
1067 { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
1068 XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
1069 { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
1070 XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
1071 (XtPointer) ZIPPY_MAX_GAMES },
1072 { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
1073 XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
1074 (XtPointer) ZIPPY_REPLAY_TIMEOUT },
1075 { "zippyShortGame", "zippyShortGame", XtRInt, sizeof(int),
1076 XtOffset(AppDataPtr, zippyShortGame), XtRImmediate,
1079 { "flashCount", "flashCount", XtRInt, sizeof(int),
1080 XtOffset(AppDataPtr, flashCount), XtRImmediate,
1081 (XtPointer) FLASH_COUNT },
1082 { "flashRate", "flashRate", XtRInt, sizeof(int),
1083 XtOffset(AppDataPtr, flashRate), XtRImmediate,
1084 (XtPointer) FLASH_RATE },
1085 { "pixmapDirectory", "pixmapDirectory", XtRString,
1086 sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
1088 { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
1089 XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
1090 (XtPointer) MS_LOGIN_DELAY },
1091 { "colorizeMessages", "colorizeMessages", XtRBoolean,
1092 sizeof(Boolean), XtOffset(AppDataPtr, colorize),
1093 XtRImmediate, (XtPointer) False },
1094 { "colorShout", "colorShout", XtRString,
1095 sizeof(String), XtOffset(AppDataPtr, colorShout),
1096 XtRString, COLOR_SHOUT },
1097 { "colorSShout", "colorSShout", XtRString,
1098 sizeof(String), XtOffset(AppDataPtr, colorSShout),
1099 XtRString, COLOR_SSHOUT },
1100 { "colorChannel1", "colorChannel1", XtRString,
1101 sizeof(String), XtOffset(AppDataPtr, colorChannel1),
1102 XtRString, COLOR_CHANNEL1 },
1103 { "colorChannel", "colorChannel", XtRString,
1104 sizeof(String), XtOffset(AppDataPtr, colorChannel),
1105 XtRString, COLOR_CHANNEL },
1106 { "colorKibitz", "colorKibitz", XtRString,
1107 sizeof(String), XtOffset(AppDataPtr, colorKibitz),
1108 XtRString, COLOR_KIBITZ },
1109 { "colorTell", "colorTell", XtRString,
1110 sizeof(String), XtOffset(AppDataPtr, colorTell),
1111 XtRString, COLOR_TELL },
1112 { "colorChallenge", "colorChallenge", XtRString,
1113 sizeof(String), XtOffset(AppDataPtr, colorChallenge),
1114 XtRString, COLOR_CHALLENGE },
1115 { "colorRequest", "colorRequest", XtRString,
1116 sizeof(String), XtOffset(AppDataPtr, colorRequest),
1117 XtRString, COLOR_REQUEST },
1118 { "colorSeek", "colorSeek", XtRString,
1119 sizeof(String), XtOffset(AppDataPtr, colorSeek),
1120 XtRString, COLOR_SEEK },
1121 { "colorNormal", "colorNormal", XtRString,
1122 sizeof(String), XtOffset(AppDataPtr, colorNormal),
1123 XtRString, COLOR_NORMAL },
1124 { "soundProgram", "soundProgram", XtRString,
1125 sizeof(String), XtOffset(AppDataPtr, soundProgram),
1126 XtRString, "play" },
1127 { "soundShout", "soundShout", XtRString,
1128 sizeof(String), XtOffset(AppDataPtr, soundShout),
1130 { "soundSShout", "soundSShout", XtRString,
1131 sizeof(String), XtOffset(AppDataPtr, soundSShout),
1133 { "soundChannel1", "soundChannel1", XtRString,
1134 sizeof(String), XtOffset(AppDataPtr, soundChannel1),
1136 { "soundChannel", "soundChannel", XtRString,
1137 sizeof(String), XtOffset(AppDataPtr, soundChannel),
1139 { "soundKibitz", "soundKibitz", XtRString,
1140 sizeof(String), XtOffset(AppDataPtr, soundKibitz),
1142 { "soundTell", "soundTell", XtRString,
1143 sizeof(String), XtOffset(AppDataPtr, soundTell),
1145 { "soundChallenge", "soundChallenge", XtRString,
1146 sizeof(String), XtOffset(AppDataPtr, soundChallenge),
1148 { "soundRequest", "soundRequest", XtRString,
1149 sizeof(String), XtOffset(AppDataPtr, soundRequest),
1151 { "soundSeek", "soundSeek", XtRString,
1152 sizeof(String), XtOffset(AppDataPtr, soundSeek),
1154 { "soundMove", "soundMove", XtRString,
1155 sizeof(String), XtOffset(AppDataPtr, soundMove),
1157 { "soundIcsWin", "soundIcsWin", XtRString,
1158 sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
1160 { "soundIcsLoss", "soundIcsLoss", XtRString,
1161 sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
1163 { "soundIcsDraw", "soundIcsDraw", XtRString,
1164 sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
1166 { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
1167 sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
1169 { "soundIcsAlarm", "soundIcsAlarm", XtRString,
1170 sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
1172 { "reuseFirst", "reuseFirst", XtRBoolean,
1173 sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
1174 XtRImmediate, (XtPointer) True },
1175 { "reuseSecond", "reuseSecond", XtRBoolean,
1176 sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
1177 XtRImmediate, (XtPointer) True },
1178 { "animateDragging", "animateDragging", XtRBoolean,
1179 sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
1180 XtRImmediate, (XtPointer) True },
1181 { "animateMoving", "animateMoving", XtRBoolean,
1182 sizeof(Boolean), XtOffset(AppDataPtr, animate),
1183 XtRImmediate, (XtPointer) True },
1184 { "animateSpeed", "animateSpeed", XtRInt,
1185 sizeof(int), XtOffset(AppDataPtr, animSpeed),
1186 XtRImmediate, (XtPointer)10 },
1187 { "popupExitMessage", "popupExitMessage", XtRBoolean,
1188 sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
1189 XtRImmediate, (XtPointer) True },
1190 { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
1191 sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
1192 XtRImmediate, (XtPointer) False },
1193 { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
1194 sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
1195 XtRImmediate, (XtPointer)4 },
1196 { "initialMode", "initialMode", XtRString,
1197 sizeof(String), XtOffset(AppDataPtr, initialMode),
1198 XtRImmediate, (XtPointer) "" },
1199 { "variant", "variant", XtRString,
1200 sizeof(String), XtOffset(AppDataPtr, variant),
1201 XtRImmediate, (XtPointer) "normal" },
1202 { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
1203 sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
1204 XtRImmediate, (XtPointer)PROTOVER },
1205 { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
1206 sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
1207 XtRImmediate, (XtPointer)PROTOVER },
1208 { "showButtonBar", "showButtonBar", XtRBoolean,
1209 sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
1210 XtRImmediate, (XtPointer) True },
1211 { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
1212 sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
1213 XtRString, COLOR_LOWTIMEWARNING },
1214 { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
1215 sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
1216 XtRImmediate, (XtPointer) False },
1217 {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean, /* [DM] icsEngineAnalyze */
1218 sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
1219 XtRImmediate, (XtPointer) False },
1220 { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
1221 sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
1222 XtRImmediate, (XtPointer) False },
1223 { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
1224 sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
1225 XtRImmediate, (XtPointer) False },
1226 { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
1227 sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
1228 XtRImmediate, (XtPointer) False },
1229 { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
1230 sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
1231 XtRImmediate, (XtPointer) True },
1232 { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
1233 sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
1234 XtRImmediate, (XtPointer) 0},
1235 { "adjudicateDrawMoves", "adjudicateDrawMoves", XtRInt,
1236 sizeof(int), XtOffset(AppDataPtr, adjudicateDrawMoves),
1237 XtRImmediate, (XtPointer) 0},
1238 { "pgnEventHeader", "pgnEventHeader", XtRString,
1239 sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
1240 XtRImmediate, (XtPointer) "Computer Chess Game" },
1241 { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
1242 sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
1243 XtRImmediate, (XtPointer) -1},
1244 { "gameListTags", "gameListTags", XtRString,
1245 sizeof(String), XtOffset(AppDataPtr, gameListTags),
1246 XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
1248 // [HGM] 4.3.xx options
1249 { "boardWidth", "boardWidth", XtRInt,
1250 sizeof(int), XtOffset(AppDataPtr, NrFiles),
1251 XtRImmediate, (XtPointer) -1},
1252 { "boardHeight", "boardHeight", XtRInt,
1253 sizeof(int), XtOffset(AppDataPtr, NrRanks),
1254 XtRImmediate, (XtPointer) -1},
1255 { "matchPause", "matchPause", XtRInt,
1256 sizeof(int), XtOffset(AppDataPtr, matchPause),
1257 XtRImmediate, (XtPointer) 10000},
1258 { "holdingsSize", "holdingsSize", XtRInt,
1259 sizeof(int), XtOffset(AppDataPtr, holdingsSize),
1260 XtRImmediate, (XtPointer) -1},
1261 { "flipBlack", "flipBlack", XtRBoolean,
1262 sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
1263 XtRImmediate, (XtPointer) False},
1264 { "allWhite", "allWhite", XtRBoolean,
1265 sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
1266 XtRImmediate, (XtPointer) False},
1267 { "pieceToCharTable", "pieceToCharTable", XtRString,
1268 sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
1269 XtRImmediate, (XtPointer) 0},
1270 { "alphaRank", "alphaRank", XtRBoolean,
1271 sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
1272 XtRImmediate, (XtPointer) False},
1273 { "testClaims", "testClaims", XtRBoolean,
1274 sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
1275 XtRImmediate, (XtPointer) True},
1276 { "checkMates", "checkMates", XtRBoolean,
1277 sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
1278 XtRImmediate, (XtPointer) True},
1279 { "materialDraws", "materialDraws", XtRBoolean,
1280 sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
1281 XtRImmediate, (XtPointer) True},
1282 { "trivialDraws", "trivialDraws", XtRBoolean,
1283 sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
1284 XtRImmediate, (XtPointer) False},
1285 { "ruleMoves", "ruleMoves", XtRInt,
1286 sizeof(int), XtOffset(AppDataPtr, ruleMoves),
1287 XtRImmediate, (XtPointer) 51},
1288 { "repeatsToDraw", "repeatsToDraw", XtRInt,
1289 sizeof(int), XtOffset(AppDataPtr, drawRepeats),
1290 XtRImmediate, (XtPointer) 6},
1291 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1292 sizeof(int), XtOffset(AppDataPtr, engineComments),
1293 XtRImmediate, (XtPointer) 1},
1294 { "userName", "userName", XtRString,
1295 sizeof(int), XtOffset(AppDataPtr, userName),
1296 XtRImmediate, (XtPointer) 0},
1297 { "autoKibitz", "autoKibitz", XtRBoolean,
1298 sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
1299 XtRImmediate, (XtPointer) False},
1300 { "firstTimeOdds", "firstTimeOdds", XtRInt,
1301 sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
1302 XtRImmediate, (XtPointer) 1},
1303 { "secondTimeOdds", "secondTimeOdds", XtRInt,
1304 sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
1305 XtRImmediate, (XtPointer) 1},
1306 { "timeOddsMode", "timeOddsMode", XtRInt,
1307 sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
1308 XtRImmediate, (XtPointer) 0},
1309 { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
1310 sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
1311 XtRImmediate, (XtPointer) 1},
1312 { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
1313 sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
1314 XtRImmediate, (XtPointer) 1},
1315 { "firstNPS", "firstNPS", XtRInt,
1316 sizeof(int), XtOffset(AppDataPtr, firstNPS),
1317 XtRImmediate, (XtPointer) -1},
1318 { "secondNPS", "secondNPS", XtRInt,
1319 sizeof(int), XtOffset(AppDataPtr, secondNPS),
1320 XtRImmediate, (XtPointer) -1},
1321 { "serverMoves", "serverMoves", XtRString,
1322 sizeof(String), XtOffset(AppDataPtr, serverMovesName),
1323 XtRImmediate, (XtPointer) 0},
1324 { "serverPause", "serverPause", XtRInt,
1325 sizeof(int), XtOffset(AppDataPtr, serverPause),
1326 XtRImmediate, (XtPointer) 0},
1327 { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
1328 sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
1329 XtRImmediate, (XtPointer) False},
1330 { "userName", "userName", XtRString,
1331 sizeof(String), XtOffset(AppDataPtr, userName),
1332 XtRImmediate, (XtPointer) 0},
1333 { "egtFormats", "egtFormats", XtRString,
1334 sizeof(String), XtOffset(AppDataPtr, egtFormats),
1335 XtRImmediate, (XtPointer) 0},
1336 { "rewindIndex", "rewindIndex", XtRInt,
1337 sizeof(int), XtOffset(AppDataPtr, rewindIndex),
1338 XtRImmediate, (XtPointer) 0},
1339 { "sameColorGames", "sameColorGames", XtRInt,
1340 sizeof(int), XtOffset(AppDataPtr, sameColorGames),
1341 XtRImmediate, (XtPointer) 0},
1342 { "smpCores", "smpCores", XtRInt,
1343 sizeof(int), XtOffset(AppDataPtr, smpCores),
1344 XtRImmediate, (XtPointer) 1},
1345 { "niceEngines", "niceEngines", XtRInt,
1346 sizeof(int), XtOffset(AppDataPtr, niceEngines),
1347 XtRImmediate, (XtPointer) 0},
1348 { "nameOfDebugFile", "nameOfDebugFile", XtRString,
1349 sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
1350 XtRImmediate, (XtPointer) "xboard.debug"},
1351 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1352 sizeof(int), XtOffset(AppDataPtr, engineComments),
1353 XtRImmediate, (XtPointer) 1},
1354 { "noGUI", "noGUI", XtRBoolean,
1355 sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
1356 XtRImmediate, (XtPointer) 0},
1357 { "firstOptions", "firstOptions", XtRString,
1358 sizeof(String), XtOffset(AppDataPtr, firstOptions),
1359 XtRImmediate, (XtPointer) "" },
1360 { "secondOptions", "secondOptions", XtRString,
1361 sizeof(String), XtOffset(AppDataPtr, secondOptions),
1362 XtRImmediate, (XtPointer) "" },
1363 { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
1364 sizeof(String), XtOffset(AppDataPtr, fenOverride1),
1365 XtRImmediate, (XtPointer) 0 },
1366 { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
1367 sizeof(String), XtOffset(AppDataPtr, fenOverride2),
1368 XtRImmediate, (XtPointer) 0 },
1370 // [HGM] Winboard_x UCI options
1371 { "firstIsUCI", "firstIsUCI", XtRBoolean,
1372 sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
1373 XtRImmediate, (XtPointer) False},
1374 { "secondIsUCI", "secondIsUCI", XtRBoolean,
1375 sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
1376 XtRImmediate, (XtPointer) False},
1377 { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
1378 sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
1379 XtRImmediate, (XtPointer) True},
1380 { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
1381 sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
1382 XtRImmediate, (XtPointer) True},
1383 { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
1384 sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
1385 XtRImmediate, (XtPointer) False},
1386 { "defaultHashSize", "defaultHashSize", XtRInt,
1387 sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
1388 XtRImmediate, (XtPointer) 64},
1389 { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
1390 sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
1391 XtRImmediate, (XtPointer) 4},
1392 { "polyglotDir", "polyglotDir", XtRString,
1393 sizeof(String), XtOffset(AppDataPtr, polyglotDir),
1394 XtRImmediate, (XtPointer) "." },
1395 { "polyglotBook", "polyglotBook", XtRString,
1396 sizeof(String), XtOffset(AppDataPtr, polyglotBook),
1397 XtRImmediate, (XtPointer) "" },
1398 { "defaultPathEGTB", "defaultPathEGTB", XtRString,
1399 sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
1400 XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
1401 { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
1402 sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
1403 XtRImmediate, (XtPointer) 0},
1404 { "delayAfterQuit", "delayAfterQuit", XtRInt,
1405 sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
1406 XtRImmediate, (XtPointer) 0},
1407 { "keepAlive", "keepAlive", XtRInt,
1408 sizeof(int), XtOffset(AppDataPtr, keepAlive),
1409 XtRImmediate, (XtPointer) 0},
1410 { "forceIllegalMoves", "forceIllegalMoves", XtRBoolean,
1411 sizeof(Boolean), XtOffset(AppDataPtr, forceIllegal),
1412 XtRImmediate, (XtPointer) False},
1413 { "keepLineBreaksICS", "keepLineBreaksICS", XtRBoolean,
1414 sizeof(Boolean), XtOffset(AppDataPtr, noJoin),
1415 XtRImmediate, (XtPointer) True},
1418 XrmOptionDescRec shellOptions[] = {
1419 { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
1420 { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
1421 { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
1422 { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
1423 { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
1424 { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
1425 { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
1426 { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
1427 { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
1428 { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
1429 { "-initString", "initString", XrmoptionSepArg, NULL },
1430 { "-firstInitString", "initString", XrmoptionSepArg, NULL },
1431 { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
1432 { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
1433 { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
1434 { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
1435 { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
1436 { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
1437 { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
1438 { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
1439 { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
1440 { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
1441 { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
1442 { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
1443 { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
1444 { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
1445 { "-fh", "firstHost", XrmoptionSepArg, NULL },
1446 { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
1447 { "-sh", "secondHost", XrmoptionSepArg, NULL },
1448 { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
1449 { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
1450 { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
1451 { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
1452 { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
1453 { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
1454 { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
1455 { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
1456 { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
1457 { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
1458 { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
1459 { "-td", "timeDelay", XrmoptionSepArg, NULL },
1460 { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
1461 { "-tc", "timeControl", XrmoptionSepArg, NULL },
1462 { "-internetChessServerMode", "internetChessServerMode",
1463 XrmoptionSepArg, NULL },
1464 { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
1465 { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
1466 { "-internetChessServerHost", "internetChessServerHost",
1467 XrmoptionSepArg, NULL },
1468 { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
1469 { "-internetChessServerPort", "internetChessServerPort",
1470 XrmoptionSepArg, NULL },
1471 { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
1472 { "-internetChessServerCommPort", "internetChessServerCommPort",
1473 XrmoptionSepArg, NULL },
1474 { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
1475 { "-internetChessServerLogonScript", "internetChessServerLogonScript",
1476 XrmoptionSepArg, NULL },
1477 { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
1478 { "-internetChessServerHelper", "internetChessServerHelper",
1479 XrmoptionSepArg, NULL },
1480 { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
1481 { "-internetChessServerInputBox", "internetChessServerInputBox",
1482 XrmoptionSepArg, NULL },
1483 { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
1484 { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
1485 { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
1486 { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
1487 { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
1488 { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
1489 { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
1490 { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
1491 { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
1492 { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
1493 { "-gateway", "gateway", XrmoptionSepArg, NULL },
1494 { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
1495 { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
1496 { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
1497 { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
1498 { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
1499 { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
1500 { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
1501 { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
1502 { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
1503 { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
1504 { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
1505 { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
1506 { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
1507 { "-blind", "blindfold", XrmoptionNoArg, "True" },
1508 { "-xblind", "blindfold", XrmoptionNoArg, "False" },
1509 { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
1510 { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
1511 { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
1512 { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
1513 { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
1514 { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
1515 { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
1516 { "-mm", "matchMode", XrmoptionNoArg, "True" },
1517 { "-xmm", "matchMode", XrmoptionNoArg, "False" },
1518 { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
1519 { "-mg", "matchGames", XrmoptionSepArg, NULL },
1520 { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
1521 { "-mono", "monoMode", XrmoptionNoArg, "True" },
1522 { "-xmono", "monoMode", XrmoptionNoArg, "False" },
1523 { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
1524 { "-debug", "debugMode", XrmoptionNoArg, "True" },
1525 { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
1526 { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
1527 { "-clock", "clockMode", XrmoptionNoArg, "True" },
1528 { "-xclock", "clockMode", XrmoptionNoArg, "False" },
1529 { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
1530 { "-size", "boardSize", XrmoptionSepArg, NULL },
1531 { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
1532 { "-st", "searchTime", XrmoptionSepArg, NULL },
1533 { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
1534 { "-depth", "searchDepth", XrmoptionSepArg, NULL },
1535 { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
1536 { "-coords", "showCoords", XrmoptionNoArg, "True" },
1537 { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
1539 { "-showJail", "showJail", XrmoptionSepArg, NULL },
1540 { "-jail", "showJail", XrmoptionNoArg, "1" },
1541 { "-sidejail", "showJail", XrmoptionNoArg, "2" },
1542 { "-xjail", "showJail", XrmoptionNoArg, "0" },
1544 { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
1545 { "-thinking", "showThinking", XrmoptionNoArg, "True" },
1546 { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
1547 { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
1548 { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
1549 { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
1550 { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
1551 { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
1552 { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
1553 { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
1554 { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
1555 { "-font", "font", XrmoptionSepArg, NULL },
1556 { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
1557 { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1558 { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1559 { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1560 { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1561 { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
1562 { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
1563 { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
1564 { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
1565 { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
1566 { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
1567 { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
1568 { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
1569 { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
1570 { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
1571 { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
1572 { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
1573 { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
1574 { "-moves", "getMoveList", XrmoptionNoArg, "True" },
1575 { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
1577 { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
1578 { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
1579 { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
1581 { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
1582 { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
1583 { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
1584 { "-premove", "premove", XrmoptionSepArg, NULL },
1585 { "-pre", "premove", XrmoptionNoArg, "True" },
1586 { "-xpre", "premove", XrmoptionNoArg, "False" },
1587 { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
1588 { "-legal", "testLegality", XrmoptionNoArg, "True" },
1589 { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
1590 { "-flipView", "flipView", XrmoptionSepArg, NULL },
1591 { "-flip", "flipView", XrmoptionNoArg, "True" },
1592 { "-xflip", "flipView", XrmoptionNoArg, "False" },
1593 { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
1594 { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
1595 XrmoptionSepArg, NULL },
1596 { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
1597 { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
1598 { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
1599 { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
1600 { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
1601 { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
1602 { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
1603 { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
1604 { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
1605 { "-title", "titleInWindow", XrmoptionNoArg, "True" },
1606 { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
1608 { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
1609 { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
1610 { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
1611 { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
1612 { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
1613 { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
1614 { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
1615 { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
1616 { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
1617 { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
1618 { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
1619 { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
1620 { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
1621 { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
1622 { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
1623 { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
1624 { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
1625 { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
1626 { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
1627 { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
1628 { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
1629 { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
1630 { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
1631 { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
1632 { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
1633 { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
1634 { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
1635 { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
1636 { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
1637 { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
1638 { "-zippyShortGame", "zippyShortGame", XrmoptionSepArg, NULL },
1640 { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
1641 { "-flash", "flashCount", XrmoptionNoArg, "3" },
1642 { "-xflash", "flashCount", XrmoptionNoArg, "0" },
1643 { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
1644 { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
1645 { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
1646 { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
1647 { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
1648 { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
1649 { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
1650 { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
1651 { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
1652 { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1653 { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
1654 { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
1655 { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
1656 { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
1657 { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
1658 { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
1659 { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
1660 { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
1661 { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
1662 { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
1663 { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
1664 { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1665 { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
1666 { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
1667 { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
1668 { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
1669 { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
1670 { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
1671 { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
1672 { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
1673 { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
1674 { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
1675 { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
1676 { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
1677 { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
1678 { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
1679 { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
1680 { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
1681 { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
1682 { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
1683 { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
1684 { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
1685 { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
1686 { "-animate", "animateMoving", XrmoptionNoArg, "True" },
1687 { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
1688 { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
1689 { "-drag", "animateDragging", XrmoptionNoArg, "True" },
1690 { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
1691 { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
1692 { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
1693 { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
1694 { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
1695 { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
1696 { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
1697 { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
1698 { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
1699 { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
1700 { "-mode", "initialMode", XrmoptionSepArg, NULL },
1701 { "-variant", "variant", XrmoptionSepArg, NULL },
1702 { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
1703 { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
1704 { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
1705 { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
1706 { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
1707 { "-lowTimeWarningColor", "lowTimeWarningColor", XrmoptionSepArg, NULL },
1708 { "-lowTimeWarning", "lowTimeWarning", XrmoptionSepArg, NULL },
1709 /* [AS,HR] New features */
1710 { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
1711 { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
1712 { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
1713 { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
1714 { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
1715 { "-adjudicateDrawMoves", "adjudicateDrawMoves", XrmoptionSepArg, NULL },
1716 { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },
1717 { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },
1718 { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },
1719 { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },
1720 { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },
1721 { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },
1722 { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },
1723 { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1724 { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1725 { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1726 { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1727 { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },
1728 { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },
1729 { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },
1730 { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },
1731 { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },
1732 { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },
1733 { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },
1734 { "-gameListTags", "gameListTags", XrmoptionSepArg, NULL },
1735 // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c
1737 /* [HGM,HR] User-selectable board size */
1738 { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
1739 { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
1740 { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
1742 /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */
1743 { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work
1744 { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL }, // requires front-end changes to work
1745 { "-allWhite", "allWhite", XrmoptionSepArg, NULL }, // requires front-end changes to work
1746 { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL },
1747 { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL },
1748 { "-testClaims", "testClaims", XrmoptionSepArg, NULL },
1749 { "-checkMates", "checkMates", XrmoptionSepArg, NULL },
1750 { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL },
1751 { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL },
1752 { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL },
1753 { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },
1754 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1755 { "-userName", "userName", XrmoptionSepArg, NULL },
1756 { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" },
1757 { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL },
1758 { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL },
1759 { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL },
1760 { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL },
1761 { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL },
1762 { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL },
1763 { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL },
1764 { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL },
1765 { "-serverPause", "serverPause", XrmoptionSepArg, NULL },
1766 { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL },
1767 { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL },
1768 { "-userName", "userName", XrmoptionSepArg, NULL },
1769 { "-smpCores", "smpCores", XrmoptionSepArg, NULL },
1770 { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL },
1771 { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL },
1772 { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL },
1773 { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL },
1774 { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL },
1775 { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1776 { "-debugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1777 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1778 { "-noGUI", "noGUI", XrmoptionNoArg, "True" },
1779 { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL },
1780 { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL },
1781 { "-firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1782 { "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1783 { "-keepAlive", "keepAlive", XrmoptionSepArg, NULL },
1784 { "-forceIllegalMoves", "forceIllegalMoves", XrmoptionNoArg, "True" },
1785 { "-keepLineBreaksICS", "keepLineBreaksICS", XrmoptionSepArg, NULL },
1789 XtActionsRec boardActions[] = {
1790 { "DrawPosition", DrawPositionProc },
1791 { "HandleUserMove", HandleUserMove },
1792 { "AnimateUserMove", AnimateUserMove },
1793 { "FileNameAction", FileNameAction },
1794 { "AskQuestionProc", AskQuestionProc },
1795 { "AskQuestionReplyAction", AskQuestionReplyAction },
1796 { "PieceMenuPopup", PieceMenuPopup },
1797 { "WhiteClock", WhiteClock },
1798 { "BlackClock", BlackClock },
1799 { "Iconify", Iconify },
1800 { "ResetProc", ResetProc },
1801 { "LoadGameProc", LoadGameProc },
1802 { "LoadNextGameProc", LoadNextGameProc },
1803 { "LoadPrevGameProc", LoadPrevGameProc },
1804 { "LoadSelectedProc", LoadSelectedProc },
1805 { "ReloadGameProc", ReloadGameProc },
1806 { "LoadPositionProc", LoadPositionProc },
1807 { "LoadNextPositionProc", LoadNextPositionProc },
1808 { "LoadPrevPositionProc", LoadPrevPositionProc },
1809 { "ReloadPositionProc", ReloadPositionProc },
1810 { "CopyPositionProc", CopyPositionProc },
1811 { "PastePositionProc", PastePositionProc },
1812 { "CopyGameProc", CopyGameProc },
1813 { "PasteGameProc", PasteGameProc },
1814 { "SaveGameProc", SaveGameProc },
1815 { "SavePositionProc", SavePositionProc },
1816 { "MailMoveProc", MailMoveProc },
1817 { "ReloadCmailMsgProc", ReloadCmailMsgProc },
1818 { "QuitProc", QuitProc },
1819 { "MachineWhiteProc", MachineWhiteProc },
1820 { "MachineBlackProc", MachineBlackProc },
1821 { "AnalysisModeProc", AnalyzeModeProc },
1822 { "AnalyzeFileProc", AnalyzeFileProc },
1823 { "TwoMachinesProc", TwoMachinesProc },
1824 { "IcsClientProc", IcsClientProc },
1825 { "EditGameProc", EditGameProc },
1826 { "EditPositionProc", EditPositionProc },
1827 { "TrainingProc", EditPositionProc },
1828 { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
1829 { "ShowGameListProc", ShowGameListProc },
1830 { "ShowMoveListProc", HistoryShowProc},
1831 { "EditTagsProc", EditCommentProc },
1832 { "EditCommentProc", EditCommentProc },
1833 { "IcsAlarmProc", IcsAlarmProc },
1834 { "IcsInputBoxProc", IcsInputBoxProc },
1835 { "PauseProc", PauseProc },
1836 { "AcceptProc", AcceptProc },
1837 { "DeclineProc", DeclineProc },
1838 { "RematchProc", RematchProc },
1839 { "CallFlagProc", CallFlagProc },
1840 { "DrawProc", DrawProc },
1841 { "AdjournProc", AdjournProc },
1842 { "AbortProc", AbortProc },
1843 { "ResignProc", ResignProc },
1844 { "AdjuWhiteProc", AdjuWhiteProc },
1845 { "AdjuBlackProc", AdjuBlackProc },
1846 { "AdjuDrawProc", AdjuDrawProc },
1847 { "EnterKeyProc", EnterKeyProc },
1848 { "StopObservingProc", StopObservingProc },
1849 { "StopExaminingProc", StopExaminingProc },
1850 { "BackwardProc", BackwardProc },
1851 { "ForwardProc", ForwardProc },
1852 { "ToStartProc", ToStartProc },
1853 { "ToEndProc", ToEndProc },
1854 { "RevertProc", RevertProc },
1855 { "TruncateGameProc", TruncateGameProc },
1856 { "MoveNowProc", MoveNowProc },
1857 { "RetractMoveProc", RetractMoveProc },
1858 { "AlwaysQueenProc", AlwaysQueenProc },
1859 { "AnimateDraggingProc", AnimateDraggingProc },
1860 { "AnimateMovingProc", AnimateMovingProc },
1861 { "AutoflagProc", AutoflagProc },
1862 { "AutoflipProc", AutoflipProc },
1863 { "AutobsProc", AutobsProc },
1864 { "AutoraiseProc", AutoraiseProc },
1865 { "AutosaveProc", AutosaveProc },
1866 { "BlindfoldProc", BlindfoldProc },
1867 { "FlashMovesProc", FlashMovesProc },
1868 { "FlipViewProc", FlipViewProc },
1869 { "GetMoveListProc", GetMoveListProc },
1871 { "HighlightDraggingProc", HighlightDraggingProc },
1873 { "HighlightLastMoveProc", HighlightLastMoveProc },
1874 { "IcsAlarmProc", IcsAlarmProc },
1875 { "MoveSoundProc", MoveSoundProc },
1876 { "OldSaveStyleProc", OldSaveStyleProc },
1877 { "PeriodicUpdatesProc", PeriodicUpdatesProc },
1878 { "PonderNextMoveProc", PonderNextMoveProc },
1879 { "PopupExitMessageProc", PopupExitMessageProc },
1880 { "PopupMoveErrorsProc", PopupMoveErrorsProc },
1881 { "PremoveProc", PremoveProc },
1882 { "QuietPlayProc", QuietPlayProc },
1883 { "ShowCoordsProc", ShowCoordsProc },
1884 { "ShowThinkingProc", ShowThinkingProc },
1885 { "HideThinkingProc", HideThinkingProc },
1886 { "TestLegalityProc", TestLegalityProc },
1887 { "InfoProc", InfoProc },
1888 { "ManProc", ManProc },
1889 { "HintProc", HintProc },
1890 { "BookProc", BookProc },
1891 { "AboutGameProc", AboutGameProc },
1892 { "AboutProc", AboutProc },
1893 { "DebugProc", DebugProc },
1894 { "NothingProc", NothingProc },
1895 { "CommentPopDown", (XtActionProc) CommentPopDown },
1896 { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
1897 { "TagsPopDown", (XtActionProc) TagsPopDown },
1898 { "ErrorPopDown", (XtActionProc) ErrorPopDown },
1899 { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
1900 { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
1901 { "FileNamePopDown", (XtActionProc) FileNamePopDown },
1902 { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
1903 { "GameListPopDown", (XtActionProc) GameListPopDown },
1904 { "PromotionPopDown", (XtActionProc) PromotionPopDown },
1905 { "HistoryPopDown", (XtActionProc) HistoryPopDown },
1906 { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
1907 { "ShufflePopDown", (XtActionProc) ShufflePopDown },
1908 { "EnginePopDown", (XtActionProc) EnginePopDown },
1909 { "UciPopDown", (XtActionProc) UciPopDown },
1910 { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
1911 { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
1912 { "SettingsPopDown", (XtActionProc) SettingsPopDown },
1915 char globalTranslations[] =
1916 ":<Key>R: ResignProc() \n \
1917 :<Key>r: ResetProc() \n \
1918 :<Key>g: LoadGameProc() \n \
1919 :<Key>N: LoadNextGameProc() \n \
1920 :<Key>P: LoadPrevGameProc() \n \
1921 :<Key>Q: QuitProc() \n \
1922 :<Key>F: ToEndProc() \n \
1923 :<Key>f: ForwardProc() \n \
1924 :<Key>B: ToStartProc() \n \
1925 :<Key>b: BackwardProc() \n \
1926 :<Key>p: PauseProc() \n \
1927 :<Key>d: DrawProc() \n \
1928 :<Key>t: CallFlagProc() \n \
1929 :<Key>i: Iconify() \n \
1930 :<Key>c: Iconify() \n \
1931 :<Key>v: FlipViewProc() \n \
1932 <KeyDown>Control_L: BackwardProc() \n \
1933 <KeyUp>Control_L: ForwardProc() \n \
1934 <KeyDown>Control_R: BackwardProc() \n \
1935 <KeyUp>Control_R: ForwardProc() \n \
1936 Shift<Key>1: AskQuestionProc(\"Direct command\",\
1937 \"Send to chess program:\",,1) \n \
1938 Shift<Key>2: AskQuestionProc(\"Direct command\",\
1939 \"Send to second chess program:\",,2) \n";
1941 char boardTranslations[] =
1942 "<Btn1Down>: HandleUserMove() \n \
1943 <Btn1Up>: HandleUserMove() \n \
1944 <Btn1Motion>: AnimateUserMove() \n \
1945 Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
1946 PieceMenuPopup(menuB) \n \
1947 Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
1948 PieceMenuPopup(menuW) \n \
1949 Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
1950 PieceMenuPopup(menuW) \n \
1951 Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
1952 PieceMenuPopup(menuB) \n";
1954 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
1955 char blackTranslations[] = "<BtnDown>: BlackClock()\n";
1957 char ICSInputTranslations[] =
1958 "<Key>Return: EnterKeyProc() \n";
1960 String xboardResources[] = {
1961 "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
1962 "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
1963 "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
1968 /* Max possible square size */
1969 #define MAXSQSIZE 256
1971 static int xpm_avail[MAXSQSIZE];
1973 #ifdef HAVE_DIR_STRUCT
1975 /* Extract piece size from filename */
1977 xpm_getsize(name, len, ext)
1988 if ((p=strchr(name, '.')) == NULL ||
1989 StrCaseCmp(p+1, ext) != 0)
1995 while (*p && isdigit(*p))
2002 /* Setup xpm_avail */
2004 xpm_getavail(dirname, ext)
2012 for (i=0; i<MAXSQSIZE; ++i)
2015 if (appData.debugMode)
2016 fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
2018 dir = opendir(dirname);
2021 fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
2022 programName, dirname);
2026 while ((ent=readdir(dir)) != NULL) {
2027 i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
2028 if (i > 0 && i < MAXSQSIZE)
2038 xpm_print_avail(fp, ext)
2044 fprintf(fp, _("Available `%s' sizes:\n"), ext);
2045 for (i=1; i<MAXSQSIZE; ++i) {
2051 /* Return XPM piecesize closest to size */
2053 xpm_closest_to(dirname, size, ext)
2059 int sm_diff = MAXSQSIZE;
2063 xpm_getavail(dirname, ext);
2065 if (appData.debugMode)
2066 xpm_print_avail(stderr, ext);
2068 for (i=1; i<MAXSQSIZE; ++i) {
2071 diff = (diff<0) ? -diff : diff;
2072 if (diff < sm_diff) {
2080 fprintf(stderr, _("Error: No `%s' files!\n"), ext);
2086 #else /* !HAVE_DIR_STRUCT */
2087 /* If we are on a system without a DIR struct, we can't
2088 read the directory, so we can't collect a list of
2089 filenames, etc., so we can't do any size-fitting. */
2091 xpm_closest_to(dirname, size, ext)
2096 fprintf(stderr, _("\
2097 Warning: No DIR structure found on this system --\n\
2098 Unable to autosize for XPM/XIM pieces.\n\
2099 Please report this error to frankm@hiwaay.net.\n\
2100 Include system type & operating system in message.\n"));
2103 #endif /* HAVE_DIR_STRUCT */
2105 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
2106 "magenta", "cyan", "white" };
2110 TextColors textColors[(int)NColorClasses];
2112 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
2114 parse_color(str, which)
2118 char *p, buf[100], *d;
2121 if (strlen(str) > 99) /* watch bounds on buf */
2126 for (i=0; i<which; ++i) {
2133 /* Could be looking at something like:
2135 .. in which case we want to stop on a comma also */
2136 while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
2140 return -1; /* Use default for empty field */
2143 if (which == 2 || isdigit(*p))
2146 while (*p && isalpha(*p))
2151 for (i=0; i<8; ++i) {
2152 if (!StrCaseCmp(buf, cnames[i]))
2153 return which? (i+40) : (i+30);
2155 if (!StrCaseCmp(buf, "default")) return -1;
2157 fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
2162 parse_cpair(cc, str)
2166 if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
2167 fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
2172 /* bg and attr are optional */
2173 textColors[(int)cc].bg = parse_color(str, 1);
2174 if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {
2175 textColors[(int)cc].attr = 0;
2181 /* Arrange to catch delete-window events */
2182 Atom wm_delete_window;
2184 CatchDeleteWindow(Widget w, String procname)
2187 XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
2188 snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
2189 XtAugmentTranslations(w, XtParseTranslationTable(buf));
2196 XtSetArg(args[0], XtNiconic, False);
2197 XtSetValues(shellWidget, args, 1);
2199 XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
2203 // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
2205 #define BoardSize int
2206 void InitDrawingSizes(BoardSize boardSize, int flags)
2207 { // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
2208 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2210 XtGeometryResult gres;
2213 if(!formWidget) return;
2216 * Enable shell resizing.
2218 shellArgs[0].value = (XtArgVal) &w;
2219 shellArgs[1].value = (XtArgVal) &h;
2220 XtGetValues(shellWidget, shellArgs, 2);
2222 shellArgs[4].value = 2*w; shellArgs[2].value = 10;
2223 shellArgs[5].value = 2*h; shellArgs[3].value = 10;
2224 XtSetValues(shellWidget, &shellArgs[2], 4);
2226 XtSetArg(args[0], XtNdefaultDistance, &sep);
2227 XtGetValues(formWidget, args, 1);
2229 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2230 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2233 XtSetArg(args[0], XtNwidth, boardWidth);
2234 XtSetArg(args[1], XtNheight, boardHeight);
2235 XtSetValues(boardWidget, args, 2);
2237 timerWidth = (boardWidth - sep) / 2;
2238 XtSetArg(args[0], XtNwidth, timerWidth);
2239 XtSetValues(whiteTimerWidget, args, 1);
2240 XtSetValues(blackTimerWidget, args, 1);
2242 XawFormDoLayout(formWidget, False);
2244 if (appData.titleInWindow) {
2246 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2247 XtSetArg(args[i], XtNheight, &h); i++;
2248 XtGetValues(titleWidget, args, i);
2250 w = boardWidth - 2*bor;
2252 XtSetArg(args[0], XtNwidth, &w);
2253 XtGetValues(menuBarWidget, args, 1);
2254 w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
2257 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2258 if (gres != XtGeometryYes && appData.debugMode) {
2260 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2261 programName, gres, w, h, wr, hr);
2265 XawFormDoLayout(formWidget, True);
2268 * Inhibit shell resizing.
2270 shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
2271 shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
2272 shellArgs[4].value = shellArgs[2].value = w;
2273 shellArgs[5].value = shellArgs[3].value = h;
2274 XtSetValues(shellWidget, &shellArgs[0], 6);
2276 // [HGM] pieces: tailor piece bitmaps to needs of specific variant
2279 for(i=0; i<4; i++) {
2281 for(p=0; p<=(int)WhiteKing; p++)
2282 xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
2283 if(gameInfo.variant == VariantShogi) {
2284 xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
2285 xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
2286 xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
2287 xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
2288 xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
2291 if(gameInfo.variant == VariantGothic) {
2292 xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
2296 // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
2297 for(p=0; p<=(int)WhiteKing; p++)
2298 ximMaskPm[p] = ximMaskPm2[p]; // defaults
2299 if(gameInfo.variant == VariantShogi) {
2300 ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
2301 ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
2302 ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
2303 ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
2304 ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
2307 if(gameInfo.variant == VariantGothic) {
2308 ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
2314 for(i=0; i<2; i++) {
2316 for(p=0; p<=(int)WhiteKing; p++)
2317 pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
2318 if(gameInfo.variant == VariantShogi) {
2319 pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
2320 pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
2321 pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
2322 pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
2323 pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
2326 if(gameInfo.variant == VariantGothic) {
2327 pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
2338 void EscapeExpand(char *p, char *q)
2339 { // [HGM] initstring: routine to shape up string arguments
2340 while(*p++ = *q++) if(p[-1] == '\\')
2342 case 'n': p[-1] = '\n'; break;
2343 case 'r': p[-1] = '\r'; break;
2344 case 't': p[-1] = '\t'; break;
2345 case '\\': p[-1] = '\\'; break;
2346 case 0: *p = 0; return;
2347 default: p[-1] = q[-1]; break;
2356 int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
2357 XSetWindowAttributes window_attributes;
2359 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2360 XrmValue vFrom, vTo;
2361 XtGeometryResult gres;
2364 int forceMono = False;
2367 // [HGM] before anything else, expand any indirection files amongst options
2368 char *argvCopy[1000]; // 1000 seems enough
2369 char newArgs[10000]; // holds actual characters
2372 srandom(time(0)); // [HGM] book: make random truly random
2375 for(i=0; i<argc; i++) {
2376 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2377 //fprintf(stderr, "arg %s\n", argv[i]);
2378 if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
2380 FILE *f = fopen(argv[i]+1, "rb");
2381 if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
2382 argvCopy[j++] = newArgs + k; // get ready for first argument from file
2383 while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
2385 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2386 newArgs[k++] = 0; // terminate current arg
2387 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2388 argvCopy[j++] = newArgs + k; // get ready for next
2390 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2404 setbuf(stdout, NULL);
2405 setbuf(stderr, NULL);
2408 programName = strrchr(argv[0], '/');
2409 if (programName == NULL)
2410 programName = argv[0];
2415 XtSetLanguageProc(NULL, NULL, NULL);
2416 bindtextdomain(PACKAGE, LOCALEDIR);
2417 textdomain(PACKAGE);
2421 XtAppInitialize(&appContext, "XBoard", shellOptions,
2422 XtNumber(shellOptions),
2423 &argc, argv, xboardResources, NULL, 0);
2425 { /* left over command line arguments, print out help and exit.
2426 * Use two columns to print help
2428 fprintf(stderr, _("%s: unrecognized argument %s\n"),
2429 programName, argv[1]);
2431 fprintf(stderr, "Recognized options:\n");
2432 for(i = 0; i < XtNumber(shellOptions); i++)
2434 /* print first column */
2435 j = fprintf(stderr, " %s%s", shellOptions[i].option,
2436 (shellOptions[i].argKind == XrmoptionSepArg
2438 /* print second column and end line */
2439 if (++i < XtNumber(shellOptions))
2441 fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
2442 shellOptions[i].option,
2443 (shellOptions[i].argKind == XrmoptionSepArg
2448 fprintf(stderr, "\n");
2455 if (p == NULL) p = "/tmp";
2456 i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
2457 gameCopyFilename = (char*) malloc(i);
2458 gamePasteFilename = (char*) malloc(i);
2459 snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
2460 snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
2462 XtGetApplicationResources(shellWidget, (XtPointer) &appData,
2463 clientResources, XtNumber(clientResources),
2466 { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
2467 static char buf[MSG_SIZ];
2468 EscapeExpand(buf, appData.initString);
2469 appData.initString = strdup(buf);
2470 EscapeExpand(buf, appData.secondInitString);
2471 appData.secondInitString = strdup(buf);
2472 EscapeExpand(buf, appData.firstComputerString);
2473 appData.firstComputerString = strdup(buf);
2474 EscapeExpand(buf, appData.secondComputerString);
2475 appData.secondComputerString = strdup(buf);
2478 if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
2481 if (chdir(chessDir) != 0) {
2482 fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
2488 if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
2489 /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
2490 if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL) {
2491 printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
2494 setbuf(debugFP, NULL);
2497 /* [HGM,HR] make sure board size is acceptable */
2498 if(appData.NrFiles > BOARD_SIZE ||
2499 appData.NrRanks > BOARD_SIZE )
2500 DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
2503 /* This feature does not work; animation needs a rewrite */
2504 appData.highlightDragging = FALSE;
2508 xDisplay = XtDisplay(shellWidget);
2509 xScreen = DefaultScreen(xDisplay);
2510 wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
2512 gameInfo.variant = StringToVariant(appData.variant);
2513 InitPosition(FALSE);
2516 InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
2518 if (isdigit(appData.boardSize[0])) {
2519 i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
2520 &lineGap, &clockFontPxlSize, &coordFontPxlSize,
2521 &fontPxlSize, &smallLayout, &tinyLayout);
2523 fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
2524 programName, appData.boardSize);
2528 /* Find some defaults; use the nearest known size */
2529 SizeDefaults *szd, *nearest;
2530 int distance = 99999;
2531 nearest = szd = sizeDefaults;
2532 while (szd->name != NULL) {
2533 if (abs(szd->squareSize - squareSize) < distance) {
2535 distance = abs(szd->squareSize - squareSize);
2536 if (distance == 0) break;
2540 if (i < 2) lineGap = nearest->lineGap;
2541 if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
2542 if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
2543 if (i < 5) fontPxlSize = nearest->fontPxlSize;
2544 if (i < 6) smallLayout = nearest->smallLayout;
2545 if (i < 7) tinyLayout = nearest->tinyLayout;
2548 SizeDefaults *szd = sizeDefaults;
2549 if (*appData.boardSize == NULLCHAR) {
2550 while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
2551 DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
2554 if (szd->name == NULL) szd--;
2556 while (szd->name != NULL &&
2557 StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
2558 if (szd->name == NULL) {
2559 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
2560 programName, appData.boardSize);
2564 squareSize = szd->squareSize;
2565 lineGap = szd->lineGap;
2566 clockFontPxlSize = szd->clockFontPxlSize;
2567 coordFontPxlSize = szd->coordFontPxlSize;
2568 fontPxlSize = szd->fontPxlSize;
2569 smallLayout = szd->smallLayout;
2570 tinyLayout = szd->tinyLayout;
2573 /* Now, using squareSize as a hint, find a good XPM/XIM set size */
2574 if (strlen(appData.pixmapDirectory) > 0) {
2575 p = ExpandPathName(appData.pixmapDirectory);
2577 fprintf(stderr, _("Error expanding path name \"%s\"\n"),
2578 appData.pixmapDirectory);
2581 if (appData.debugMode) {
2582 fprintf(stderr, _("\
2583 XBoard square size (hint): %d\n\
2584 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
2586 squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
2587 if (appData.debugMode) {
2588 fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
2592 /* [HR] height treated separately (hacked) */
2593 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2594 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2595 if (appData.showJail == 1) {
2596 /* Jail on top and bottom */
2597 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2598 XtSetArg(boardArgs[2], XtNheight,
2599 boardHeight + 2*(lineGap + squareSize));
2600 } else if (appData.showJail == 2) {
2602 XtSetArg(boardArgs[1], XtNwidth,
2603 boardWidth + 2*(lineGap + squareSize));
2604 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2607 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2608 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2612 * Determine what fonts to use.
2614 appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
2615 clockFontID = XLoadFont(xDisplay, appData.clockFont);
2616 clockFontStruct = XQueryFont(xDisplay, clockFontID);
2617 appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
2618 coordFontID = XLoadFont(xDisplay, appData.coordFont);
2619 coordFontStruct = XQueryFont(xDisplay, coordFontID);
2620 appData.font = FindFont(appData.font, fontPxlSize);
2621 countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
2622 countFontStruct = XQueryFont(xDisplay, countFontID);
2623 // appData.font = FindFont(appData.font, fontPxlSize);
2625 xdb = XtDatabase(xDisplay);
2626 XrmPutStringResource(&xdb, "*font", appData.font);
2629 * Detect if there are not enough colors available and adapt.
2631 if (DefaultDepth(xDisplay, xScreen) <= 2) {
2632 appData.monoMode = True;
2635 if (!appData.monoMode) {
2636 vFrom.addr = (caddr_t) appData.lightSquareColor;
2637 vFrom.size = strlen(appData.lightSquareColor);
2638 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2639 if (vTo.addr == NULL) {
2640 appData.monoMode = True;
2643 lightSquareColor = *(Pixel *) vTo.addr;
2646 if (!appData.monoMode) {
2647 vFrom.addr = (caddr_t) appData.darkSquareColor;
2648 vFrom.size = strlen(appData.darkSquareColor);
2649 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2650 if (vTo.addr == NULL) {
2651 appData.monoMode = True;
2654 darkSquareColor = *(Pixel *) vTo.addr;
2657 if (!appData.monoMode) {
2658 vFrom.addr = (caddr_t) appData.whitePieceColor;
2659 vFrom.size = strlen(appData.whitePieceColor);
2660 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2661 if (vTo.addr == NULL) {
2662 appData.monoMode = True;
2665 whitePieceColor = *(Pixel *) vTo.addr;
2668 if (!appData.monoMode) {
2669 vFrom.addr = (caddr_t) appData.blackPieceColor;
2670 vFrom.size = strlen(appData.blackPieceColor);
2671 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2672 if (vTo.addr == NULL) {
2673 appData.monoMode = True;
2676 blackPieceColor = *(Pixel *) vTo.addr;
2680 if (!appData.monoMode) {
2681 vFrom.addr = (caddr_t) appData.highlightSquareColor;
2682 vFrom.size = strlen(appData.highlightSquareColor);
2683 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2684 if (vTo.addr == NULL) {
2685 appData.monoMode = True;
2688 highlightSquareColor = *(Pixel *) vTo.addr;
2692 if (!appData.monoMode) {
2693 vFrom.addr = (caddr_t) appData.premoveHighlightColor;
2694 vFrom.size = strlen(appData.premoveHighlightColor);
2695 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2696 if (vTo.addr == NULL) {
2697 appData.monoMode = True;
2700 premoveHighlightColor = *(Pixel *) vTo.addr;
2705 fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
2708 if (appData.bitmapDirectory == NULL ||
2709 appData.bitmapDirectory[0] == NULLCHAR)
2710 appData.bitmapDirectory = DEF_BITMAP_DIR;
2713 if (appData.lowTimeWarning && !appData.monoMode) {
2714 vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
2715 vFrom.size = strlen(appData.lowTimeWarningColor);
2716 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2717 if (vTo.addr == NULL)
2718 appData.monoMode = True;
2720 lowTimeWarningColor = *(Pixel *) vTo.addr;
2723 if (appData.monoMode && appData.debugMode) {
2724 fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
2725 (unsigned long) XWhitePixel(xDisplay, xScreen),
2726 (unsigned long) XBlackPixel(xDisplay, xScreen));
2729 if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
2730 parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
2731 parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
2732 parse_cpair(ColorChannel, appData.colorChannel) < 0 ||
2733 parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||
2734 parse_cpair(ColorTell, appData.colorTell) < 0 ||
2735 parse_cpair(ColorChallenge, appData.colorChallenge) < 0 ||
2736 parse_cpair(ColorRequest, appData.colorRequest) < 0 ||
2737 parse_cpair(ColorSeek, appData.colorSeek) < 0 ||
2738 parse_cpair(ColorNormal, appData.colorNormal) < 0)
2740 if (appData.colorize) {
2742 _("%s: can't parse color names; disabling colorization\n"),
2745 appData.colorize = FALSE;
2747 textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
2748 textColors[ColorNone].attr = 0;
2750 XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
2756 layoutName = "tinyLayout";
2757 } else if (smallLayout) {
2758 layoutName = "smallLayout";
2760 layoutName = "normalLayout";
2762 /* Outer layoutWidget is there only to provide a name for use in
2763 resources that depend on the layout style */
2765 XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
2766 layoutArgs, XtNumber(layoutArgs));
2768 XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
2769 formArgs, XtNumber(formArgs));
2770 XtSetArg(args[0], XtNdefaultDistance, &sep);
2771 XtGetValues(formWidget, args, 1);
2774 widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
2775 XtSetArg(args[0], XtNtop, XtChainTop);
2776 XtSetArg(args[1], XtNbottom, XtChainTop);
2777 XtSetValues(menuBarWidget, args, 2);
2779 widgetList[j++] = whiteTimerWidget =
2780 XtCreateWidget("whiteTime", labelWidgetClass,
2781 formWidget, timerArgs, XtNumber(timerArgs));
2782 XtSetArg(args[0], XtNfont, clockFontStruct);
2783 XtSetArg(args[1], XtNtop, XtChainTop);
2784 XtSetArg(args[2], XtNbottom, XtChainTop);
2785 XtSetValues(whiteTimerWidget, args, 3);
2787 widgetList[j++] = blackTimerWidget =
2788 XtCreateWidget("blackTime", labelWidgetClass,
2789 formWidget, timerArgs, XtNumber(timerArgs));
2790 XtSetArg(args[0], XtNfont, clockFontStruct);
2791 XtSetArg(args[1], XtNtop, XtChainTop);
2792 XtSetArg(args[2], XtNbottom, XtChainTop);
2793 XtSetValues(blackTimerWidget, args, 3);
2795 if (appData.titleInWindow) {
2796 widgetList[j++] = titleWidget =
2797 XtCreateWidget("title", labelWidgetClass, formWidget,
2798 titleArgs, XtNumber(titleArgs));
2799 XtSetArg(args[0], XtNtop, XtChainTop);
2800 XtSetArg(args[1], XtNbottom, XtChainTop);
2801 XtSetValues(titleWidget, args, 2);
2804 if (appData.showButtonBar) {
2805 widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
2806 XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
2807 XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
2808 XtSetArg(args[2], XtNtop, XtChainTop);
2809 XtSetArg(args[3], XtNbottom, XtChainTop);
2810 XtSetValues(buttonBarWidget, args, 4);
2813 widgetList[j++] = messageWidget =
2814 XtCreateWidget("message", labelWidgetClass, formWidget,
2815 messageArgs, XtNumber(messageArgs));
2816 XtSetArg(args[0], XtNtop, XtChainTop);
2817 XtSetArg(args[1], XtNbottom, XtChainTop);
2818 XtSetValues(messageWidget, args, 2);
2820 widgetList[j++] = boardWidget =
2821 XtCreateWidget("board", widgetClass, formWidget, boardArgs,
2822 XtNumber(boardArgs));
2824 XtManageChildren(widgetList, j);
2826 timerWidth = (boardWidth - sep) / 2;
2827 XtSetArg(args[0], XtNwidth, timerWidth);
2828 XtSetValues(whiteTimerWidget, args, 1);
2829 XtSetValues(blackTimerWidget, args, 1);
2831 XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
2832 XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
2833 XtGetValues(whiteTimerWidget, args, 2);
2835 if (appData.showButtonBar) {
2836 XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
2837 XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
2838 XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
2842 * formWidget uses these constraints but they are stored
2846 XtSetArg(args[i], XtNfromHoriz, 0); i++;
2847 XtSetValues(menuBarWidget, args, i);
2848 if (appData.titleInWindow) {
2851 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2852 XtSetValues(whiteTimerWidget, args, i);
2854 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2855 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2856 XtSetValues(blackTimerWidget, args, i);
2858 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2859 XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
2860 XtSetValues(titleWidget, args, i);
2862 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2863 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2864 XtSetValues(messageWidget, args, i);
2865 if (appData.showButtonBar) {
2867 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2868 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2869 XtSetValues(buttonBarWidget, args, i);
2873 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2874 XtSetValues(whiteTimerWidget, args, i);
2876 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2877 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2878 XtSetValues(blackTimerWidget, args, i);
2880 XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
2881 XtSetValues(titleWidget, args, i);
2883 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2884 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2885 XtSetValues(messageWidget, args, i);
2886 if (appData.showButtonBar) {
2888 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2889 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2890 XtSetValues(buttonBarWidget, args, i);
2895 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2896 XtSetValues(whiteTimerWidget, args, i);
2898 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2899 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2900 XtSetValues(blackTimerWidget, args, i);
2902 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2903 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2904 XtSetValues(messageWidget, args, i);
2905 if (appData.showButtonBar) {
2907 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2908 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2909 XtSetValues(buttonBarWidget, args, i);
2913 XtSetArg(args[0], XtNfromVert, messageWidget);
2914 XtSetArg(args[1], XtNtop, XtChainTop);
2915 XtSetArg(args[2], XtNbottom, XtChainBottom);
2916 XtSetArg(args[3], XtNleft, XtChainLeft);
2917 XtSetArg(args[4], XtNright, XtChainRight);
2918 XtSetValues(boardWidget, args, 5);
2920 XtRealizeWidget(shellWidget);
2923 * Correct the width of the message and title widgets.
2924 * It is not known why some systems need the extra fudge term.
2925 * The value "2" is probably larger than needed.
2927 XawFormDoLayout(formWidget, False);
2929 #define WIDTH_FUDGE 2
2931 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2932 XtSetArg(args[i], XtNheight, &h); i++;
2933 XtGetValues(messageWidget, args, i);
2934 if (appData.showButtonBar) {
2936 XtSetArg(args[i], XtNwidth, &w); i++;
2937 XtGetValues(buttonBarWidget, args, i);
2938 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2940 w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
2943 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2944 if (gres != XtGeometryYes && appData.debugMode) {
2945 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2946 programName, gres, w, h, wr, hr);
2949 /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
2950 /* The size used for the child widget in layout lags one resize behind
2951 its true size, so we resize a second time, 1 pixel smaller. Yeech! */
2953 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2954 if (gres != XtGeometryYes && appData.debugMode) {
2955 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2956 programName, gres, w, h, wr, hr);
2959 XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
2960 XtSetArg(args[1], XtNright, XtChainRight);
2961 XtSetValues(messageWidget, args, 2);
2963 if (appData.titleInWindow) {
2965 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2966 XtSetArg(args[i], XtNheight, &h); i++;
2967 XtGetValues(titleWidget, args, i);
2969 w = boardWidth - 2*bor;
2971 XtSetArg(args[0], XtNwidth, &w);
2972 XtGetValues(menuBarWidget, args, 1);
2973 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2976 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2977 if (gres != XtGeometryYes && appData.debugMode) {
2979 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2980 programName, gres, w, h, wr, hr);
2983 XawFormDoLayout(formWidget, True);
2985 xBoardWindow = XtWindow(boardWidget);
2987 // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
2988 // not need to go into InitDrawingSizes().
2992 * Create X checkmark bitmap and initialize option menu checks.
2994 ReadBitmap(&xMarkPixmap, "checkmark.bm",
2995 checkmark_bits, checkmark_width, checkmark_height);
2996 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
2997 if (appData.alwaysPromoteToQueen) {
2998 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
3001 if (appData.animateDragging) {
3002 XtSetValues(XtNameToWidget(menuBarWidget,
3003 "menuOptions.Animate Dragging"),
3006 if (appData.animate) {
3007 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
3010 if (appData.autoComment) {
3011 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
3014 if (appData.autoCallFlag) {
3015 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
3018 if (appData.autoFlipView) {
3019 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
3022 if (appData.autoObserve) {
3023 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
3026 if (appData.autoRaiseBoard) {
3027 XtSetValues(XtNameToWidget(menuBarWidget,
3028 "menuOptions.Auto Raise Board"), args, 1);
3030 if (appData.autoSaveGames) {
3031 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3034 if (appData.saveGameFile[0] != NULLCHAR) {
3035 /* Can't turn this off from menu */
3036 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3038 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3042 if (appData.blindfold) {
3043 XtSetValues(XtNameToWidget(menuBarWidget,
3044 "menuOptions.Blindfold"), args, 1);
3046 if (appData.flashCount > 0) {
3047 XtSetValues(XtNameToWidget(menuBarWidget,
3048 "menuOptions.Flash Moves"),
3051 if (appData.getMoveList) {
3052 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
3056 if (appData.highlightDragging) {
3057 XtSetValues(XtNameToWidget(menuBarWidget,
3058 "menuOptions.Highlight Dragging"),
3062 if (appData.highlightLastMove) {
3063 XtSetValues(XtNameToWidget(menuBarWidget,
3064 "menuOptions.Highlight Last Move"),
3067 if (appData.icsAlarm) {
3068 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
3071 if (appData.ringBellAfterMoves) {
3072 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
3075 if (appData.oldSaveStyle) {
3076 XtSetValues(XtNameToWidget(menuBarWidget,
3077 "menuOptions.Old Save Style"), args, 1);
3079 if (appData.periodicUpdates) {
3080 XtSetValues(XtNameToWidget(menuBarWidget,
3081 "menuOptions.Periodic Updates"), args, 1);
3083 if (appData.ponderNextMove) {
3084 XtSetValues(XtNameToWidget(menuBarWidget,
3085 "menuOptions.Ponder Next Move"), args, 1);
3087 if (appData.popupExitMessage) {
3088 XtSetValues(XtNameToWidget(menuBarWidget,
3089 "menuOptions.Popup Exit Message"), args, 1);
3091 if (appData.popupMoveErrors) {
3092 XtSetValues(XtNameToWidget(menuBarWidget,
3093 "menuOptions.Popup Move Errors"), args, 1);
3095 if (appData.premove) {
3096 XtSetValues(XtNameToWidget(menuBarWidget,
3097 "menuOptions.Premove"), args, 1);
3099 if (appData.quietPlay) {
3100 XtSetValues(XtNameToWidget(menuBarWidget,
3101 "menuOptions.Quiet Play"), args, 1);
3103 if (appData.showCoords) {
3104 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
3107 if (appData.hideThinkingFromHuman) {
3108 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
3111 if (appData.testLegality) {
3112 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
3119 ReadBitmap(&wIconPixmap, "icon_white.bm",
3120 icon_white_bits, icon_white_width, icon_white_height);
3121 ReadBitmap(&bIconPixmap, "icon_black.bm",
3122 icon_black_bits, icon_black_width, icon_black_height);
3123 iconPixmap = wIconPixmap;
3125 XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
3126 XtSetValues(shellWidget, args, i);
3129 * Create a cursor for the board widget.
3131 window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
3132 XChangeWindowAttributes(xDisplay, xBoardWindow,
3133 CWCursor, &window_attributes);
3136 * Inhibit shell resizing.
3138 shellArgs[0].value = (XtArgVal) &w;
3139 shellArgs[1].value = (XtArgVal) &h;
3140 XtGetValues(shellWidget, shellArgs, 2);
3141 shellArgs[4].value = shellArgs[2].value = w;
3142 shellArgs[5].value = shellArgs[3].value = h;
3143 XtSetValues(shellWidget, &shellArgs[2], 4);
3144 marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
3145 marginH = h - boardHeight;
3147 CatchDeleteWindow(shellWidget, "QuitProc");
3152 if (appData.bitmapDirectory[0] != NULLCHAR) {
3159 /* Create regular pieces */
3160 if (!useImages) CreatePieces();
3165 if (appData.animate || appData.animateDragging)
3168 XtAugmentTranslations(formWidget,
3169 XtParseTranslationTable(globalTranslations));
3170 XtAugmentTranslations(boardWidget,
3171 XtParseTranslationTable(boardTranslations));
3172 XtAugmentTranslations(whiteTimerWidget,
3173 XtParseTranslationTable(whiteTranslations));
3174 XtAugmentTranslations(blackTimerWidget,
3175 XtParseTranslationTable(blackTranslations));
3177 /* Why is the following needed on some versions of X instead
3178 * of a translation? */
3179 XtAddEventHandler(boardWidget, ExposureMask, False,
3180 (XtEventHandler) EventProc, NULL);
3185 if (errorExitStatus == -1) {
3186 if (appData.icsActive) {
3187 /* We now wait until we see "login:" from the ICS before
3188 sending the logon script (problems with timestamp otherwise) */
3189 /*ICSInitScript();*/
3190 if (appData.icsInputBox) ICSInputBoxPopUp();
3193 signal(SIGINT, IntSigHandler);
3194 signal(SIGTERM, IntSigHandler);
3195 if (*appData.cmailGameName != NULLCHAR) {
3196 signal(SIGUSR1, CmailSigHandler);
3199 gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
3202 XtAppMainLoop(appContext);
3203 if (appData.debugMode) fclose(debugFP); // [DM] debug
3210 if (appData.icsActive && oldICSInteractionTitle != NULL) {
3211 DisplayIcsInteractionTitle(oldICSInteractionTitle);
3213 unlink(gameCopyFilename);
3214 unlink(gamePasteFilename);
3217 RETSIGTYPE TermSizeSigHandler(int sig)
3230 CmailSigHandler(sig)
3236 signal(SIGUSR1, SIG_IGN); /* suspend handler */
3238 /* Activate call-back function CmailSigHandlerCallBack() */
3239 OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
3241 signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
3245 CmailSigHandlerCallBack(isr, closure, message, count, error)
3253 ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */
3255 /**** end signal code ****/
3265 f = fopen(appData.icsLogon, "r");
3271 strcat(buf, appData.icsLogon);
3272 f = fopen(buf, "r");
3276 ProcessICSInitScript(f);
3283 EditCommentPopDown();
3294 SetMenuEnables(enab)
3298 if (!menuBarWidget) return;
3299 while (enab->name != NULL) {
3300 w = XtNameToWidget(menuBarWidget, enab->name);
3302 DisplayError(enab->name, 0);
3304 XtSetSensitive(w, enab->value);
3310 Enables icsEnables[] = {
3311 { "menuFile.Mail Move", False },
3312 { "menuFile.Reload CMail Message", False },
3313 { "menuMode.Machine Black", False },
3314 { "menuMode.Machine White", False },
3315 { "menuMode.Analysis Mode", False },
3316 { "menuMode.Analyze File", False },
3317 { "menuMode.Two Machines", False },
3319 { "menuHelp.Hint", False },
3320 { "menuHelp.Book", False },
3321 { "menuStep.Move Now", False },
3322 { "menuOptions.Periodic Updates", False },
3323 { "menuOptions.Hide Thinking", False },
3324 { "menuOptions.Ponder Next Move", False },
3329 Enables ncpEnables[] = {
3330 { "menuFile.Mail Move", False },
3331 { "menuFile.Reload CMail Message", False },
3332 { "menuMode.Machine White", False },
3333 { "menuMode.Machine Black", False },
3334 { "menuMode.Analysis Mode", False },
3335 { "menuMode.Analyze File", False },
3336 { "menuMode.Two Machines", False },
3337 { "menuMode.ICS Client", False },
3338 { "menuMode.ICS Input Box", False },
3339 { "Action", False },
3340 { "menuStep.Revert", False },
3341 { "menuStep.Move Now", False },
3342 { "menuStep.Retract Move", False },
3343 { "menuOptions.Auto Comment", False },
3344 { "menuOptions.Auto Flag", False },
3345 { "menuOptions.Auto Flip View", False },
3346 { "menuOptions.Auto Observe", False },
3347 { "menuOptions.Auto Raise Board", False },
3348 { "menuOptions.Get Move List", False },
3349 { "menuOptions.ICS Alarm", False },
3350 { "menuOptions.Move Sound", False },
3351 { "menuOptions.Quiet Play", False },
3352 { "menuOptions.Hide Thinking", False },
3353 { "menuOptions.Periodic Updates", False },
3354 { "menuOptions.Ponder Next Move", False },
3355 { "menuHelp.Hint", False },
3356 { "menuHelp.Book", False },
3360 Enables gnuEnables[] = {
3361 { "menuMode.ICS Client", False },
3362 { "menuMode.ICS Input Box", False },
3363 { "menuAction.Accept", False },
3364 { "menuAction.Decline", False },
3365 { "menuAction.Rematch", False },
3366 { "menuAction.Adjourn", False },
3367 { "menuAction.Stop Examining", False },
3368 { "menuAction.Stop Observing", False },
3369 { "menuStep.Revert", False },
3370 { "menuOptions.Auto Comment", False },
3371 { "menuOptions.Auto Observe", False },
3372 { "menuOptions.Auto Raise Board", False },
3373 { "menuOptions.Get Move List", False },
3374 { "menuOptions.Premove", False },
3375 { "menuOptions.Quiet Play", False },
3377 /* The next two options rely on SetCmailMode being called *after* */
3378 /* SetGNUMode so that when GNU is being used to give hints these */
3379 /* menu options are still available */
3381 { "menuFile.Mail Move", False },
3382 { "menuFile.Reload CMail Message", False },
3386 Enables cmailEnables[] = {
3388 { "menuAction.Call Flag", False },
3389 { "menuAction.Draw", True },
3390 { "menuAction.Adjourn", False },
3391 { "menuAction.Abort", False },
3392 { "menuAction.Stop Observing", False },
3393 { "menuAction.Stop Examining", False },
3394 { "menuFile.Mail Move", True },
3395 { "menuFile.Reload CMail Message", True },
3399 Enables trainingOnEnables[] = {
3400 { "menuMode.Edit Comment", False },
3401 { "menuMode.Pause", False },
3402 { "menuStep.Forward", False },
3403 { "menuStep.Backward", False },
3404 { "menuStep.Forward to End", False },
3405 { "menuStep.Back to Start", False },
3406 { "menuStep.Move Now", False },
3407 { "menuStep.Truncate Game", False },
3411 Enables trainingOffEnables[] = {
3412 { "menuMode.Edit Comment", True },
3413 { "menuMode.Pause", True },
3414 { "menuStep.Forward", True },
3415 { "menuStep.Backward", True },
3416 { "menuStep.Forward to End", True },
3417 { "menuStep.Back to Start", True },
3418 { "menuStep.Move Now", True },
3419 { "menuStep.Truncate Game", True },
3423 Enables machineThinkingEnables[] = {
3424 { "menuFile.Load Game", False },
3425 { "menuFile.Load Next Game", False },
3426 { "menuFile.Load Previous Game", False },
3427 { "menuFile.Reload Same Game", False },
3428 { "menuFile.Paste Game", False },
3429 { "menuFile.Load Position", False },
3430 { "menuFile.Load Next Position", False },
3431 { "menuFile.Load Previous Position", False },
3432 { "menuFile.Reload Same Position", False },
3433 { "menuFile.Paste Position", False },
3434 { "menuMode.Machine White", False },
3435 { "menuMode.Machine Black", False },
3436 { "menuMode.Two Machines", False },
3437 { "menuStep.Retract Move", False },
3441 Enables userThinkingEnables[] = {
3442 { "menuFile.Load Game", True },
3443 { "menuFile.Load Next Game", True },
3444 { "menuFile.Load Previous Game", True },
3445 { "menuFile.Reload Same Game", True },
3446 { "menuFile.Paste Game", True },
3447 { "menuFile.Load Position", True },
3448 { "menuFile.Load Next Position", True },
3449 { "menuFile.Load Previous Position", True },
3450 { "menuFile.Reload Same Position", True },
3451 { "menuFile.Paste Position", True },
3452 { "menuMode.Machine White", True },
3453 { "menuMode.Machine Black", True },
3454 { "menuMode.Two Machines", True },
3455 { "menuStep.Retract Move", True },
3461 SetMenuEnables(icsEnables);
3464 if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
3465 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
3472 SetMenuEnables(ncpEnables);
3478 SetMenuEnables(gnuEnables);
3484 SetMenuEnables(cmailEnables);
3490 SetMenuEnables(trainingOnEnables);
3491 if (appData.showButtonBar) {
3492 XtSetSensitive(buttonBarWidget, False);
3498 SetTrainingModeOff()
3500 SetMenuEnables(trainingOffEnables);
3501 if (appData.showButtonBar) {
3502 XtSetSensitive(buttonBarWidget, True);
3507 SetUserThinkingEnables()
3509 if (appData.noChessProgram) return;
3510 SetMenuEnables(userThinkingEnables);
3514 SetMachineThinkingEnables()
3516 if (appData.noChessProgram) return;