2 * xboard.c -- X front end for XBoard
3 * $Id: xboard.c,v 2.2 2003/11/06 07:22:14 mann Exp $
5 * Copyright 1991 by Digital Equipment Corporation, Maynard,
6 * Massachusetts. Enhancements Copyright
7 * 1992-2001,2002,2003,2004,2005,2006,2007,2008,2009 Free Software
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 void CreateGCs P((void));
236 void CreateXIMPieces P((void));
237 void CreateXPMPieces P((void));
238 void CreatePieces P((void));
239 void CreatePieceMenus P((void));
240 Widget CreateMenuBar P((Menu *mb));
241 Widget CreateButtonBar P ((MenuItem *mi));
242 char *FindFont P((char *pattern, int targetPxlSize));
243 void PieceMenuPopup P((Widget w, XEvent *event,
244 String *params, Cardinal *num_params));
245 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
246 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
247 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
248 u_int wreq, u_int hreq));
249 void CreateGrid P((void));
250 int EventToSquare P((int x, int limit));
251 void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
252 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
253 void HandleUserMove P((Widget w, XEvent *event,
254 String *prms, Cardinal *nprms));
255 void AnimateUserMove P((Widget w, XEvent * event,
256 String * params, Cardinal * nParams));
257 void WhiteClock P((Widget w, XEvent *event,
258 String *prms, Cardinal *nprms));
259 void BlackClock P((Widget w, XEvent *event,
260 String *prms, Cardinal *nprms));
261 void DrawPositionProc P((Widget w, XEvent *event,
262 String *prms, Cardinal *nprms));
263 void XDrawPosition P((Widget w, /*Boolean*/int repaint,
265 void CommentPopUp P((char *title, char *label));
266 void CommentPopDown P((void));
267 void CommentCallback P((Widget w, XtPointer client_data,
268 XtPointer call_data));
269 void ICSInputBoxPopUp P((void));
270 void ICSInputBoxPopDown P((void));
271 void FileNamePopUp P((char *label, char *def,
272 FileProc proc, char *openMode));
273 void FileNamePopDown P((void));
274 void FileNameCallback P((Widget w, XtPointer client_data,
275 XtPointer call_data));
276 void FileNameAction P((Widget w, XEvent *event,
277 String *prms, Cardinal *nprms));
278 void AskQuestionReplyAction P((Widget w, XEvent *event,
279 String *prms, Cardinal *nprms));
280 void AskQuestionProc P((Widget w, XEvent *event,
281 String *prms, Cardinal *nprms));
282 void AskQuestionPopDown P((void));
283 void PromotionPopUp P((void));
284 void PromotionPopDown P((void));
285 void PromotionCallback P((Widget w, XtPointer client_data,
286 XtPointer call_data));
287 void EditCommentPopDown P((void));
288 void EditCommentCallback P((Widget w, XtPointer client_data,
289 XtPointer call_data));
290 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
291 void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
292 void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
293 void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
295 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
297 void ReloadGameProc P((Widget w, XEvent *event, String *prms,
299 void LoadPositionProc P((Widget w, XEvent *event,
300 String *prms, Cardinal *nprms));
301 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
303 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
305 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
307 void CopyPositionProc P((Widget w, XEvent *event, String *prms,
309 void PastePositionProc P((Widget w, XEvent *event, String *prms,
311 void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
312 void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
313 void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
314 void SavePositionProc P((Widget w, XEvent *event,
315 String *prms, Cardinal *nprms));
316 void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
317 void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
319 void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
320 void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
321 void MachineBlackProc P((Widget w, XEvent *event, String *prms,
323 void MachineWhiteProc P((Widget w, XEvent *event,
324 String *prms, Cardinal *nprms));
325 void AnalyzeModeProc P((Widget w, XEvent *event,
326 String *prms, Cardinal *nprms));
327 void AnalyzeFileProc P((Widget w, XEvent *event,
328 String *prms, Cardinal *nprms));
329 void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
331 void IcsClientProc P((Widget w, XEvent *event, String *prms,
333 void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
334 void EditPositionProc P((Widget w, XEvent *event,
335 String *prms, Cardinal *nprms));
336 void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
337 void EditCommentProc P((Widget w, XEvent *event,
338 String *prms, Cardinal *nprms));
339 void IcsInputBoxProc P((Widget w, XEvent *event,
340 String *prms, Cardinal *nprms));
341 void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
342 void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
343 void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
344 void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
345 void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
346 void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
347 void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
348 void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
349 void AdjuWhiteProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
350 void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
351 void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
352 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
353 void StopObservingProc P((Widget w, XEvent *event, String *prms,
355 void StopExaminingProc P((Widget w, XEvent *event, String *prms,
357 void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
358 void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
359 void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
360 void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
361 void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
362 void TruncateGameProc P((Widget w, XEvent *event, String *prms,
364 void RetractMoveProc P((Widget w, XEvent *event, String *prms,
366 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
367 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
369 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
371 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
373 void AutocommProc P((Widget w, XEvent *event, String *prms,
375 void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
376 void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
377 void AutobsProc P((Widget w, XEvent *event, String *prms,
379 void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
380 void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
381 void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
382 void FlashMovesProc P((Widget w, XEvent *event, String *prms,
384 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
385 void GetMoveListProc P((Widget w, XEvent *event, String *prms,
387 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
389 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
391 void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
392 void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
393 void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
395 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
397 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
399 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
401 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
403 void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
404 void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
405 void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
407 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
409 void HideThinkingProc P((Widget w, XEvent *event, String *prms,
411 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
413 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
414 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
415 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
416 void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
417 void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
418 void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
419 void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
420 void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
421 void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
422 void DisplayMove P((int moveNumber));
423 void DisplayTitle P((char *title));
424 void ICSInitScript P((void));
425 int LoadGamePopUp P((FILE *f, int gameNumber, char *title));
426 void ErrorPopUp P((char *title, char *text, int modal));
427 void ErrorPopDown P((void));
428 static char *ExpandPathName P((char *path));
429 static void CreateAnimVars P((void));
430 static void DragPieceBegin P((int x, int y));
431 static void DragPieceMove P((int x, int y));
432 static void DragPieceEnd P((int x, int y));
433 static void DrawDragPiece P((void));
434 char *ModeToWidgetName P((GameMode mode));
435 void EngineOutputUpdate( FrontEndProgramStats * stats );
436 void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
437 void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
438 void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
439 void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
440 void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
441 void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
442 void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
443 void ShufflePopDown P(());
444 void EnginePopDown P(());
445 void UciPopDown P(());
446 void TimeControlPopDown P(());
447 void NewVariantPopDown P(());
448 void SettingsPopDown P(());
450 * XBoard depends on Xt R4 or higher
452 int xtVersion = XtSpecificationRelease;
457 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
458 jailSquareColor, highlightSquareColor, premoveHighlightColor;
459 Pixel lowTimeWarningColor;
460 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
461 bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
462 wjPieceGC, bjPieceGC, prelineGC, countGC;
463 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
464 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
465 whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
466 commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
467 menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
468 ICSInputShell, fileNameShell, askQuestionShell;
469 XSegment gridSegments[(BOARD_SIZE + 1) * 2];
470 XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
471 Font clockFontID, coordFontID, countFontID;
472 XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
473 XtAppContext appContext;
475 char *oldICSInteractionTitle;
479 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
481 Position commentX = -1, commentY = -1;
482 Dimension commentW, commentH;
484 int squareSize, smallLayout = 0, tinyLayout = 0,
485 marginW, marginH, // [HGM] for run-time resizing
486 fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
487 ICSInputBoxUp = False, askQuestionUp = False,
488 filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
489 editUp = False, errorUp = False, errorExitStatus = -1, lineGap;
490 Pixel timerForegroundPixel, timerBackgroundPixel;
491 Pixel buttonForegroundPixel, buttonBackgroundPixel;
492 char *chessDir, *programName, *programVersion,
493 *gameCopyFilename, *gamePasteFilename;
497 Pixmap pieceBitmap[2][(int)BlackPawn];
498 Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD */
499 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
500 int useImages, useImageSqs;
501 XImage *ximPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD */
502 Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
503 XImage *ximLightSquare, *ximDarkSquare;
506 #define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % (int)BlackPawn]
507 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % (int)BlackPawn]
509 #define White(piece) ((int)(piece) < (int)BlackPawn)
511 /* Variables for doing smooth animation. This whole thing
512 would be much easier if the board was double-buffered,
513 but that would require a fairly major rewrite. */
518 GC blitGC, pieceGC, outlineGC;
519 XPoint startSquare, prevFrame, mouseDelta;
523 int startBoardX, startBoardY;
526 /* There can be two pieces being animated at once: a player
527 can begin dragging a piece before the remote opponent has moved. */
529 static AnimState game, player;
531 /* Bitmaps for use as masks when drawing XPM pieces.
532 Need one for each black and white piece. */
533 static Pixmap xpmMask[BlackKing + 1];
535 /* This magic number is the number of intermediate frames used
536 in each half of the animation. For short moves it's reduced
537 by 1. The total number of frames will be factor * 2 + 1. */
540 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
542 MenuItem fileMenu[] = {
543 {N_("New Game"), ResetProc},
544 {N_("New Shuffle Game ..."), ShuffleMenuProc},
545 {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
546 {"----", NothingProc},
547 {N_("Load Game"), LoadGameProc},
548 {N_("Load Next Game"), LoadNextGameProc},
549 {N_("Load Previous Game"), LoadPrevGameProc},
550 {N_("Reload Same Game"), ReloadGameProc},
551 {N_("Save Game"), SaveGameProc},
552 {"----", NothingProc},
553 {N_("Copy Game"), CopyGameProc},
554 {N_("Paste Game"), PasteGameProc},
555 {"----", NothingProc},
556 {N_("Load Position"), LoadPositionProc},
557 {N_("Load Next Position"), LoadNextPositionProc},
558 {N_("Load Previous Position"), LoadPrevPositionProc},
559 {N_("Reload Same Position"), ReloadPositionProc},
560 {N_("Save Position"), SavePositionProc},
561 {"----", NothingProc},
562 {N_("Copy Position"), CopyPositionProc},
563 {N_("Paste Position"), PastePositionProc},
564 {"----", NothingProc},
565 {N_("Mail Move"), MailMoveProc},
566 {N_("Reload CMail Message"), ReloadCmailMsgProc},
567 {"----", NothingProc},
568 {N_("Exit"), QuitProc},
572 MenuItem modeMenu[] = {
573 {N_("Machine White"), MachineWhiteProc},
574 {N_("Machine Black"), MachineBlackProc},
575 {N_("Two Machines"), TwoMachinesProc},
576 {N_("Analysis Mode"), AnalyzeModeProc},
577 {N_("Analyze File"), AnalyzeFileProc },
578 {N_("ICS Client"), IcsClientProc},
579 {N_("Edit Game"), EditGameProc},
580 {N_("Edit Position"), EditPositionProc},
581 {N_("Training"), TrainingProc},
582 {"----", NothingProc},
583 {N_("Show Engine Output"), EngineOutputProc},
584 {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
585 {N_("Show Game List"), ShowGameListProc},
586 {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
587 {"----", NothingProc},
588 {N_("Edit Tags"), EditTagsProc},
589 {N_("Edit Comment"), EditCommentProc},
590 {N_("ICS Input Box"), IcsInputBoxProc},
591 {N_("Pause"), PauseProc},
595 MenuItem actionMenu[] = {
596 {N_("Accept"), AcceptProc},
597 {N_("Decline"), DeclineProc},
598 {N_("Rematch"), RematchProc},
599 {"----", NothingProc},
600 {N_("Call Flag"), CallFlagProc},
601 {N_("Draw"), DrawProc},
602 {N_("Adjourn"), AdjournProc},
603 {N_("Abort"), AbortProc},
604 {N_("Resign"), ResignProc},
605 {"----", NothingProc},
606 {N_("Stop Observing"), StopObservingProc},
607 {N_("Stop Examining"), StopExaminingProc},
608 {"----", NothingProc},
609 {N_("Adjudicate to White"), AdjuWhiteProc},
610 {N_("Adjudicate to Black"), AdjuBlackProc},
611 {N_("Adjudicate Draw"), AdjuDrawProc},
615 MenuItem stepMenu[] = {
616 {N_("Backward"), BackwardProc},
617 {N_("Forward"), ForwardProc},
618 {N_("Back to Start"), ToStartProc},
619 {N_("Forward to End"), ToEndProc},
620 {N_("Revert"), RevertProc},
621 {N_("Truncate Game"), TruncateGameProc},
622 {"----", NothingProc},
623 {N_("Move Now"), MoveNowProc},
624 {N_("Retract Move"), RetractMoveProc},
628 MenuItem optionsMenu[] = {
629 {N_("Flip View"), FlipViewProc},
630 {"----", NothingProc},
631 {N_("Adjudications ..."), EngineMenuProc},
632 {N_("General Settings ..."), UciMenuProc},
633 {N_("Engine #1 Settings ..."), FirstSettingsProc},
634 {N_("Engine #2 Settings ..."), SecondSettingsProc},
635 {N_("Time Control ..."), TimeControlProc},
636 {"----", NothingProc},
637 {N_("Always Queen"), AlwaysQueenProc},
638 {N_("Animate Dragging"), AnimateDraggingProc},
639 {N_("Animate Moving"), AnimateMovingProc},
640 {N_("Auto Comment"), AutocommProc},
641 {N_("Auto Flag"), AutoflagProc},
642 {N_("Auto Flip View"), AutoflipProc},
643 {N_("Auto Observe"), AutobsProc},
644 {N_("Auto Raise Board"), AutoraiseProc},
645 {N_("Auto Save"), AutosaveProc},
646 {N_("Blindfold"), BlindfoldProc},
647 {N_("Flash Moves"), FlashMovesProc},
648 {N_("Get Move List"), GetMoveListProc},
650 {N_("Highlight Dragging"), HighlightDraggingProc},
652 {N_("Highlight Last Move"), HighlightLastMoveProc},
653 {N_("Move Sound"), MoveSoundProc},
654 {N_("ICS Alarm"), IcsAlarmProc},
655 {N_("Old Save Style"), OldSaveStyleProc},
656 {N_("Periodic Updates"), PeriodicUpdatesProc},
657 {N_("Ponder Next Move"), PonderNextMoveProc},
658 {N_("Popup Exit Message"), PopupExitMessageProc},
659 {N_("Popup Move Errors"), PopupMoveErrorsProc},
660 {N_("Premove"), PremoveProc},
661 {N_("Quiet Play"), QuietPlayProc},
662 {N_("Show Coords"), ShowCoordsProc},
663 {N_("Hide Thinking"), HideThinkingProc},
664 {N_("Test Legality"), TestLegalityProc},
668 MenuItem helpMenu[] = {
669 {N_("Info XBoard"), InfoProc},
670 {N_("Man XBoard"), ManProc},
671 {"----", NothingProc},
672 {N_("Hint"), HintProc},
673 {N_("Book"), BookProc},
674 {"----", NothingProc},
675 {N_("About XBoard"), AboutProc},
680 {N_("File"), fileMenu},
681 {N_("Mode"), modeMenu},
682 {N_("Action"), actionMenu},
683 {N_("Step"), stepMenu},
684 {N_("Options"), optionsMenu},
685 {N_("Help"), helpMenu},
689 #define PAUSE_BUTTON N_("P")
690 MenuItem buttonBar[] = {
693 {PAUSE_BUTTON, PauseProc},
699 #define PIECE_MENU_SIZE 11
700 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
701 { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
702 N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
703 { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
704 N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
706 /* must be in same order as PieceMenuStrings! */
707 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
708 { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
709 WhiteRook, WhiteQueen, WhiteKing,
710 (ChessSquare) 0, EmptySquare, ClearBoard },
711 { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
712 BlackRook, BlackQueen, BlackKing,
713 (ChessSquare) 0, EmptySquare, ClearBoard },
716 #define DROP_MENU_SIZE 6
717 String dropMenuStrings[DROP_MENU_SIZE] = {
718 "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
720 /* must be in same order as PieceMenuStrings! */
721 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
722 (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
723 WhiteRook, WhiteQueen
731 DropMenuEnables dmEnables[] = {
749 { XtNborderWidth, 0 },
750 { XtNdefaultDistance, 0 },
754 { XtNborderWidth, 0 },
755 { XtNresizable, (XtArgVal) True },
759 { XtNborderWidth, 0 },
765 { XtNjustify, (XtArgVal) XtJustifyRight },
766 { XtNlabel, (XtArgVal) "..." },
767 { XtNresizable, (XtArgVal) True },
768 { XtNresize, (XtArgVal) False }
771 Arg messageArgs[] = {
772 { XtNjustify, (XtArgVal) XtJustifyLeft },
773 { XtNlabel, (XtArgVal) "..." },
774 { XtNresizable, (XtArgVal) True },
775 { XtNresize, (XtArgVal) False }
779 { XtNborderWidth, 0 },
780 { XtNjustify, (XtArgVal) XtJustifyLeft }
783 XtResource clientResources[] = {
784 { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
785 XtOffset(AppDataPtr, whitePieceColor), XtRString,
787 { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
788 XtOffset(AppDataPtr, blackPieceColor), XtRString,
790 { "lightSquareColor", "lightSquareColor", XtRString,
791 sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
792 XtRString, LIGHT_SQUARE_COLOR },
793 { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
794 XtOffset(AppDataPtr, darkSquareColor), XtRString,
796 { "highlightSquareColor", "highlightSquareColor", XtRString,
797 sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
798 XtRString, HIGHLIGHT_SQUARE_COLOR },
799 { "premoveHighlightColor", "premoveHighlightColor", XtRString,
800 sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
801 XtRString, PREMOVE_HIGHLIGHT_COLOR },
802 { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
803 XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
804 (XtPointer) MOVES_PER_SESSION },
805 { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
806 XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
807 (XtPointer) TIME_INCREMENT },
808 { "initString", "initString", XtRString, sizeof(String),
809 XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
810 { "secondInitString", "secondInitString", XtRString, sizeof(String),
811 XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
812 { "firstComputerString", "firstComputerString", XtRString,
813 sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
815 { "secondComputerString", "secondComputerString", XtRString,
816 sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
818 { "firstChessProgram", "firstChessProgram", XtRString,
819 sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
820 XtRString, FIRST_CHESS_PROGRAM },
821 { "secondChessProgram", "secondChessProgram", XtRString,
822 sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
823 XtRString, SECOND_CHESS_PROGRAM },
824 { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
825 sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
826 XtRImmediate, (XtPointer) False },
827 { "noChessProgram", "noChessProgram", XtRBoolean,
828 sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
829 XtRImmediate, (XtPointer) False },
830 { "firstHost", "firstHost", XtRString, sizeof(String),
831 XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
832 { "secondHost", "secondHost", XtRString, sizeof(String),
833 XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
834 { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
835 XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
836 { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
837 XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
838 { "bitmapDirectory", "bitmapDirectory", XtRString,
839 sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
841 { "remoteShell", "remoteShell", XtRString, sizeof(String),
842 XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
843 { "remoteUser", "remoteUser", XtRString, sizeof(String),
844 XtOffset(AppDataPtr, remoteUser), XtRString, "" },
845 { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
846 XtOffset(AppDataPtr, timeDelay), XtRString,
847 (XtPointer) TIME_DELAY_QUOTE },
848 { "timeControl", "timeControl", XtRString, sizeof(String),
849 XtOffset(AppDataPtr, timeControl), XtRString,
850 (XtPointer) TIME_CONTROL },
851 { "internetChessServerMode", "internetChessServerMode",
852 XtRBoolean, sizeof(Boolean),
853 XtOffset(AppDataPtr, icsActive), XtRImmediate,
855 { "internetChessServerHost", "internetChessServerHost",
856 XtRString, sizeof(String),
857 XtOffset(AppDataPtr, icsHost),
858 XtRString, (XtPointer) ICS_HOST },
859 { "internetChessServerPort", "internetChessServerPort",
860 XtRString, sizeof(String),
861 XtOffset(AppDataPtr, icsPort), XtRString,
862 (XtPointer) ICS_PORT },
863 { "internetChessServerCommPort", "internetChessServerCommPort",
864 XtRString, sizeof(String),
865 XtOffset(AppDataPtr, icsCommPort), XtRString,
867 { "internetChessServerLogonScript", "internetChessServerLogonScript",
868 XtRString, sizeof(String),
869 XtOffset(AppDataPtr, icsLogon), XtRString,
871 { "internetChessServerHelper", "internetChessServerHelper",
872 XtRString, sizeof(String),
873 XtOffset(AppDataPtr, icsHelper), XtRString, "" },
874 { "internetChessServerInputBox", "internetChessServerInputBox",
875 XtRBoolean, sizeof(Boolean),
876 XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
878 { "icsAlarm", "icsAlarm",
879 XtRBoolean, sizeof(Boolean),
880 XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
882 { "icsAlarmTime", "icsAlarmTime",
884 XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
886 { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
887 XtOffset(AppDataPtr, useTelnet), XtRImmediate,
889 { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
890 XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
891 { "gateway", "gateway", XtRString, sizeof(String),
892 XtOffset(AppDataPtr, gateway), XtRString, "" },
893 { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
894 XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
895 { "loadGameIndex", "loadGameIndex",
897 XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
899 { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
900 XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
901 { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
902 sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
903 XtRImmediate, (XtPointer) True },
904 { "autoSaveGames", "autoSaveGames", XtRBoolean,
905 sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
906 XtRImmediate, (XtPointer) False },
907 { "blindfold", "blindfold", XtRBoolean,
908 sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
909 XtRImmediate, (XtPointer) False },
910 { "loadPositionFile", "loadPositionFile", XtRString,
911 sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
913 { "loadPositionIndex", "loadPositionIndex",
915 XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
917 { "savePositionFile", "savePositionFile", XtRString,
918 sizeof(String), XtOffset(AppDataPtr, savePositionFile),
920 { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
921 XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
922 { "matchGames", "matchGames", XtRInt, sizeof(int),
923 XtOffset(AppDataPtr, matchGames), XtRImmediate,
925 { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
926 XtOffset(AppDataPtr, monoMode), XtRImmediate,
928 { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
929 XtOffset(AppDataPtr, debugMode), XtRImmediate,
931 { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
932 XtOffset(AppDataPtr, clockMode), XtRImmediate,
934 { "boardSize", "boardSize", XtRString, sizeof(String),
935 XtOffset(AppDataPtr, boardSize), XtRString, "" },
936 { "searchTime", "searchTime", XtRString, sizeof(String),
937 XtOffset(AppDataPtr, searchTime), XtRString,
939 { "searchDepth", "searchDepth", XtRInt, sizeof(int),
940 XtOffset(AppDataPtr, searchDepth), XtRImmediate,
942 { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
943 XtOffset(AppDataPtr, showCoords), XtRImmediate,
945 { "showJail", "showJail", XtRInt, sizeof(int),
946 XtOffset(AppDataPtr, showJail), XtRImmediate,
948 { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
949 XtOffset(AppDataPtr, showThinking), XtRImmediate,
951 { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
952 XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
954 { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
955 XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
957 { "clockFont", "clockFont", XtRString, sizeof(String),
958 XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
959 { "coordFont", "coordFont", XtRString, sizeof(String),
960 XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
961 { "font", "font", XtRString, sizeof(String),
962 XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
963 { "ringBellAfterMoves", "ringBellAfterMoves",
964 XtRBoolean, sizeof(Boolean),
965 XtOffset(AppDataPtr, ringBellAfterMoves),
966 XtRImmediate, (XtPointer) False },
967 { "autoCallFlag", "autoCallFlag", XtRBoolean,
968 sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
969 XtRImmediate, (XtPointer) False },
970 { "autoFlipView", "autoFlipView", XtRBoolean,
971 sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
972 XtRImmediate, (XtPointer) True },
973 { "autoObserve", "autoObserve", XtRBoolean,
974 sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
975 XtRImmediate, (XtPointer) False },
976 { "autoComment", "autoComment", XtRBoolean,
977 sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
978 XtRImmediate, (XtPointer) False },
979 { "getMoveList", "getMoveList", XtRBoolean,
980 sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
981 XtRImmediate, (XtPointer) True },
983 { "highlightDragging", "highlightDragging", XtRBoolean,
984 sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
985 XtRImmediate, (XtPointer) False },
987 { "highlightLastMove", "highlightLastMove", XtRBoolean,
988 sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
989 XtRImmediate, (XtPointer) False },
990 { "premove", "premove", XtRBoolean,
991 sizeof(Boolean), XtOffset(AppDataPtr, premove),
992 XtRImmediate, (XtPointer) True },
993 { "testLegality", "testLegality", XtRBoolean,
994 sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
995 XtRImmediate, (XtPointer) True },
996 { "flipView", "flipView", XtRBoolean,
997 sizeof(Boolean), XtOffset(AppDataPtr, flipView),
998 XtRImmediate, (XtPointer) False },
999 { "cmail", "cmailGameName", XtRString, sizeof(String),
1000 XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
1001 { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
1002 sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
1003 XtRImmediate, (XtPointer) False },
1004 { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
1005 sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
1006 XtRImmediate, (XtPointer) False },
1007 { "quietPlay", "quietPlay", XtRBoolean,
1008 sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
1009 XtRImmediate, (XtPointer) False },
1010 { "titleInWindow", "titleInWindow", XtRBoolean,
1011 sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
1012 XtRImmediate, (XtPointer) False },
1013 { "localLineEditing", "localLineEditing", XtRBoolean,
1014 sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
1015 XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
1017 { "zippyTalk", "zippyTalk", XtRBoolean,
1018 sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
1019 XtRImmediate, (XtPointer) ZIPPY_TALK },
1020 { "zippyPlay", "zippyPlay", XtRBoolean,
1021 sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
1022 XtRImmediate, (XtPointer) ZIPPY_PLAY },
1023 { "zippyLines", "zippyLines", XtRString, sizeof(String),
1024 XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
1025 { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
1026 XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
1027 { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
1028 XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
1029 { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
1030 XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
1031 { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
1032 XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
1033 ZIPPY_WRONG_PASSWORD },
1034 { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
1035 XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
1036 { "zippyUseI", "zippyUseI", XtRBoolean,
1037 sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
1038 XtRImmediate, (XtPointer) ZIPPY_USE_I },
1039 { "zippyBughouse", "zippyBughouse", XtRInt,
1040 sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
1041 XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
1042 { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
1043 sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
1044 XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
1045 { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
1046 XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
1047 { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
1048 XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
1049 { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
1050 sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
1051 XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
1052 { "zippyAbort", "zippyAbort", XtRBoolean,
1053 sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
1054 XtRImmediate, (XtPointer) ZIPPY_ABORT },
1055 { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
1056 XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
1057 { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
1058 XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
1059 (XtPointer) ZIPPY_MAX_GAMES },
1060 { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
1061 XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
1062 (XtPointer) ZIPPY_REPLAY_TIMEOUT },
1063 { "zippyShortGame", "zippyShortGame", XtRInt, sizeof(int),
1064 XtOffset(AppDataPtr, zippyShortGame), XtRImmediate,
1067 { "flashCount", "flashCount", XtRInt, sizeof(int),
1068 XtOffset(AppDataPtr, flashCount), XtRImmediate,
1069 (XtPointer) FLASH_COUNT },
1070 { "flashRate", "flashRate", XtRInt, sizeof(int),
1071 XtOffset(AppDataPtr, flashRate), XtRImmediate,
1072 (XtPointer) FLASH_RATE },
1073 { "pixmapDirectory", "pixmapDirectory", XtRString,
1074 sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
1076 { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
1077 XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
1078 (XtPointer) MS_LOGIN_DELAY },
1079 { "colorizeMessages", "colorizeMessages", XtRBoolean,
1080 sizeof(Boolean), XtOffset(AppDataPtr, colorize),
1081 XtRImmediate, (XtPointer) False },
1082 { "colorShout", "colorShout", XtRString,
1083 sizeof(String), XtOffset(AppDataPtr, colorShout),
1084 XtRString, COLOR_SHOUT },
1085 { "colorSShout", "colorSShout", XtRString,
1086 sizeof(String), XtOffset(AppDataPtr, colorSShout),
1087 XtRString, COLOR_SSHOUT },
1088 { "colorChannel1", "colorChannel1", XtRString,
1089 sizeof(String), XtOffset(AppDataPtr, colorChannel1),
1090 XtRString, COLOR_CHANNEL1 },
1091 { "colorChannel", "colorChannel", XtRString,
1092 sizeof(String), XtOffset(AppDataPtr, colorChannel),
1093 XtRString, COLOR_CHANNEL },
1094 { "colorKibitz", "colorKibitz", XtRString,
1095 sizeof(String), XtOffset(AppDataPtr, colorKibitz),
1096 XtRString, COLOR_KIBITZ },
1097 { "colorTell", "colorTell", XtRString,
1098 sizeof(String), XtOffset(AppDataPtr, colorTell),
1099 XtRString, COLOR_TELL },
1100 { "colorChallenge", "colorChallenge", XtRString,
1101 sizeof(String), XtOffset(AppDataPtr, colorChallenge),
1102 XtRString, COLOR_CHALLENGE },
1103 { "colorRequest", "colorRequest", XtRString,
1104 sizeof(String), XtOffset(AppDataPtr, colorRequest),
1105 XtRString, COLOR_REQUEST },
1106 { "colorSeek", "colorSeek", XtRString,
1107 sizeof(String), XtOffset(AppDataPtr, colorSeek),
1108 XtRString, COLOR_SEEK },
1109 { "colorNormal", "colorNormal", XtRString,
1110 sizeof(String), XtOffset(AppDataPtr, colorNormal),
1111 XtRString, COLOR_NORMAL },
1112 { "soundProgram", "soundProgram", XtRString,
1113 sizeof(String), XtOffset(AppDataPtr, soundProgram),
1114 XtRString, "play" },
1115 { "soundShout", "soundShout", XtRString,
1116 sizeof(String), XtOffset(AppDataPtr, soundShout),
1118 { "soundSShout", "soundSShout", XtRString,
1119 sizeof(String), XtOffset(AppDataPtr, soundSShout),
1121 { "soundChannel1", "soundChannel1", XtRString,
1122 sizeof(String), XtOffset(AppDataPtr, soundChannel1),
1124 { "soundChannel", "soundChannel", XtRString,
1125 sizeof(String), XtOffset(AppDataPtr, soundChannel),
1127 { "soundKibitz", "soundKibitz", XtRString,
1128 sizeof(String), XtOffset(AppDataPtr, soundKibitz),
1130 { "soundTell", "soundTell", XtRString,
1131 sizeof(String), XtOffset(AppDataPtr, soundTell),
1133 { "soundChallenge", "soundChallenge", XtRString,
1134 sizeof(String), XtOffset(AppDataPtr, soundChallenge),
1136 { "soundRequest", "soundRequest", XtRString,
1137 sizeof(String), XtOffset(AppDataPtr, soundRequest),
1139 { "soundSeek", "soundSeek", XtRString,
1140 sizeof(String), XtOffset(AppDataPtr, soundSeek),
1142 { "soundMove", "soundMove", XtRString,
1143 sizeof(String), XtOffset(AppDataPtr, soundMove),
1145 { "soundIcsWin", "soundIcsWin", XtRString,
1146 sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
1148 { "soundIcsLoss", "soundIcsLoss", XtRString,
1149 sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
1151 { "soundIcsDraw", "soundIcsDraw", XtRString,
1152 sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
1154 { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
1155 sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
1157 { "soundIcsAlarm", "soundIcsAlarm", XtRString,
1158 sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
1160 { "reuseFirst", "reuseFirst", XtRBoolean,
1161 sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
1162 XtRImmediate, (XtPointer) True },
1163 { "reuseSecond", "reuseSecond", XtRBoolean,
1164 sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
1165 XtRImmediate, (XtPointer) True },
1166 { "animateDragging", "animateDragging", XtRBoolean,
1167 sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
1168 XtRImmediate, (XtPointer) True },
1169 { "animateMoving", "animateMoving", XtRBoolean,
1170 sizeof(Boolean), XtOffset(AppDataPtr, animate),
1171 XtRImmediate, (XtPointer) True },
1172 { "animateSpeed", "animateSpeed", XtRInt,
1173 sizeof(int), XtOffset(AppDataPtr, animSpeed),
1174 XtRImmediate, (XtPointer)10 },
1175 { "popupExitMessage", "popupExitMessage", XtRBoolean,
1176 sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
1177 XtRImmediate, (XtPointer) True },
1178 { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
1179 sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
1180 XtRImmediate, (XtPointer) False },
1181 { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
1182 sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
1183 XtRImmediate, (XtPointer)4 },
1184 { "initialMode", "initialMode", XtRString,
1185 sizeof(String), XtOffset(AppDataPtr, initialMode),
1186 XtRImmediate, (XtPointer) "" },
1187 { "variant", "variant", XtRString,
1188 sizeof(String), XtOffset(AppDataPtr, variant),
1189 XtRImmediate, (XtPointer) "normal" },
1190 { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
1191 sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
1192 XtRImmediate, (XtPointer)PROTOVER },
1193 { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
1194 sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
1195 XtRImmediate, (XtPointer)PROTOVER },
1196 { "showButtonBar", "showButtonBar", XtRBoolean,
1197 sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
1198 XtRImmediate, (XtPointer) True },
1199 { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
1200 sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
1201 XtRString, COLOR_LOWTIMEWARNING },
1202 { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
1203 sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
1204 XtRImmediate, (XtPointer) False },
1205 {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean, /* [DM] icsEngineAnalyze */
1206 sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
1207 XtRImmediate, (XtPointer) False },
1208 { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
1209 sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
1210 XtRImmediate, (XtPointer) False },
1211 { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
1212 sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
1213 XtRImmediate, (XtPointer) False },
1214 { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
1215 sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
1216 XtRImmediate, (XtPointer) False },
1217 { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
1218 sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
1219 XtRImmediate, (XtPointer) True },
1220 { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
1221 sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
1222 XtRImmediate, (XtPointer) 0},
1223 { "pgnEventHeader", "pgnEventHeader", XtRString,
1224 sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
1225 XtRImmediate, (XtPointer) "Computer Chess Game" },
1226 { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
1227 sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
1228 XtRImmediate, (XtPointer) -1},
1229 { "gameListTags", "gameListTags", XtRString,
1230 sizeof(String), XtOffset(AppDataPtr, gameListTags),
1231 XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
1233 // [HGM] 4.3.xx options
1234 { "boardWidth", "boardWidth", XtRInt,
1235 sizeof(int), XtOffset(AppDataPtr, NrFiles),
1236 XtRImmediate, (XtPointer) -1},
1237 { "boardHeight", "boardHeight", XtRInt,
1238 sizeof(int), XtOffset(AppDataPtr, NrRanks),
1239 XtRImmediate, (XtPointer) -1},
1240 { "matchPause", "matchPause", XtRInt,
1241 sizeof(int), XtOffset(AppDataPtr, matchPause),
1242 XtRImmediate, (XtPointer) 10000},
1243 { "holdingsSize", "holdingsSize", XtRInt,
1244 sizeof(int), XtOffset(AppDataPtr, holdingsSize),
1245 XtRImmediate, (XtPointer) -1},
1246 { "flipBlack", "flipBlack", XtRBoolean,
1247 sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
1248 XtRImmediate, (XtPointer) False},
1249 { "allWhite", "allWhite", XtRBoolean,
1250 sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
1251 XtRImmediate, (XtPointer) False},
1252 { "pieceToCharTable", "pieceToCharTable", XtRString,
1253 sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
1254 XtRImmediate, (XtPointer) 0},
1255 { "alphaRank", "alphaRank", XtRBoolean,
1256 sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
1257 XtRImmediate, (XtPointer) False},
1258 { "testClaims", "testClaims", XtRBoolean,
1259 sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
1260 XtRImmediate, (XtPointer) True},
1261 { "checkMates", "checkMates", XtRBoolean,
1262 sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
1263 XtRImmediate, (XtPointer) True},
1264 { "materialDraws", "materialDraws", XtRBoolean,
1265 sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
1266 XtRImmediate, (XtPointer) True},
1267 { "trivialDraws", "trivialDraws", XtRBoolean,
1268 sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
1269 XtRImmediate, (XtPointer) False},
1270 { "ruleMoves", "ruleMoves", XtRInt,
1271 sizeof(int), XtOffset(AppDataPtr, ruleMoves),
1272 XtRImmediate, (XtPointer) 51},
1273 { "repeatsToDraw", "repeatsToDraw", XtRInt,
1274 sizeof(int), XtOffset(AppDataPtr, drawRepeats),
1275 XtRImmediate, (XtPointer) 6},
1276 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1277 sizeof(int), XtOffset(AppDataPtr, engineComments),
1278 XtRImmediate, (XtPointer) 1},
1279 { "userName", "userName", XtRString,
1280 sizeof(int), XtOffset(AppDataPtr, userName),
1281 XtRImmediate, (XtPointer) 0},
1282 { "autoKibitz", "autoKibitz", XtRBoolean,
1283 sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
1284 XtRImmediate, (XtPointer) False},
1285 { "firstTimeOdds", "firstTimeOdds", XtRInt,
1286 sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
1287 XtRImmediate, (XtPointer) 1},
1288 { "secondTimeOdds", "secondTimeOdds", XtRInt,
1289 sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
1290 XtRImmediate, (XtPointer) 1},
1291 { "timeOddsMode", "timeOddsMode", XtRInt,
1292 sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
1293 XtRImmediate, (XtPointer) 0},
1294 { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
1295 sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
1296 XtRImmediate, (XtPointer) 1},
1297 { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
1298 sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
1299 XtRImmediate, (XtPointer) 1},
1300 { "firstNPS", "firstNPS", XtRInt,
1301 sizeof(int), XtOffset(AppDataPtr, firstNPS),
1302 XtRImmediate, (XtPointer) -1},
1303 { "secondNPS", "secondNPS", XtRInt,
1304 sizeof(int), XtOffset(AppDataPtr, secondNPS),
1305 XtRImmediate, (XtPointer) -1},
1306 { "serverMoves", "serverMoves", XtRString,
1307 sizeof(String), XtOffset(AppDataPtr, serverMovesName),
1308 XtRImmediate, (XtPointer) 0},
1309 { "serverPause", "serverPause", XtRInt,
1310 sizeof(int), XtOffset(AppDataPtr, serverPause),
1311 XtRImmediate, (XtPointer) 0},
1312 { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
1313 sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
1314 XtRImmediate, (XtPointer) False},
1315 { "userName", "userName", XtRString,
1316 sizeof(String), XtOffset(AppDataPtr, userName),
1317 XtRImmediate, (XtPointer) 0},
1318 { "egtFormats", "egtFormats", XtRString,
1319 sizeof(String), XtOffset(AppDataPtr, egtFormats),
1320 XtRImmediate, (XtPointer) 0},
1321 { "rewindIndex", "rewindIndex", XtRInt,
1322 sizeof(int), XtOffset(AppDataPtr, rewindIndex),
1323 XtRImmediate, (XtPointer) 0},
1324 { "sameColorGames", "sameColorGames", XtRInt,
1325 sizeof(int), XtOffset(AppDataPtr, sameColorGames),
1326 XtRImmediate, (XtPointer) 0},
1327 { "smpCores", "smpCores", XtRInt,
1328 sizeof(int), XtOffset(AppDataPtr, smpCores),
1329 XtRImmediate, (XtPointer) 1},
1330 { "niceEngines", "niceEngines", XtRInt,
1331 sizeof(int), XtOffset(AppDataPtr, niceEngines),
1332 XtRImmediate, (XtPointer) 0},
1333 { "nameOfDebugFile", "nameOfDebugFile", XtRString,
1334 sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
1335 XtRImmediate, (XtPointer) "xboard.debug"},
1336 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1337 sizeof(int), XtOffset(AppDataPtr, engineComments),
1338 XtRImmediate, (XtPointer) 0},
1339 { "noGUI", "noGUI", XtRBoolean,
1340 sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
1341 XtRImmediate, (XtPointer) 0},
1342 { "firstOptions", "firstOptions", XtRString,
1343 sizeof(String), XtOffset(AppDataPtr, firstOptions),
1344 XtRImmediate, (XtPointer) "" },
1345 { "secondOptions", "secondOptions", XtRString,
1346 sizeof(String), XtOffset(AppDataPtr, secondOptions),
1347 XtRImmediate, (XtPointer) "" },
1348 { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
1349 sizeof(String), XtOffset(AppDataPtr, fenOverride1),
1350 XtRImmediate, (XtPointer) 0 },
1351 { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
1352 sizeof(String), XtOffset(AppDataPtr, fenOverride2),
1353 XtRImmediate, (XtPointer) 0 },
1355 // [HGM] Winboard_x UCI options
1356 { "firstIsUCI", "firstIsUCI", XtRBoolean,
1357 sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
1358 XtRImmediate, (XtPointer) False},
1359 { "secondIsUCI", "secondIsUCI", XtRBoolean,
1360 sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
1361 XtRImmediate, (XtPointer) False},
1362 { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
1363 sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
1364 XtRImmediate, (XtPointer) True},
1365 { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
1366 sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
1367 XtRImmediate, (XtPointer) True},
1368 { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
1369 sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
1370 XtRImmediate, (XtPointer) False},
1371 { "defaultHashSize", "defaultHashSize", XtRInt,
1372 sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
1373 XtRImmediate, (XtPointer) 64},
1374 { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
1375 sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
1376 XtRImmediate, (XtPointer) 4},
1377 { "polyglotDir", "polyglotDir", XtRString,
1378 sizeof(String), XtOffset(AppDataPtr, polyglotDir),
1379 XtRImmediate, (XtPointer) "." },
1380 { "polyglotBook", "polyglotBook", XtRString,
1381 sizeof(String), XtOffset(AppDataPtr, polyglotBook),
1382 XtRImmediate, (XtPointer) "" },
1383 { "defaultPathEGTB", "defaultPathEGTB", XtRString,
1384 sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
1385 XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
1386 { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
1387 sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
1388 XtRImmediate, (XtPointer) 0},
1389 { "delayAfterQuit", "delayAfterQuit", XtRInt,
1390 sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
1391 XtRImmediate, (XtPointer) 0},
1394 XrmOptionDescRec shellOptions[] = {
1395 { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
1396 { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
1397 { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
1398 { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
1399 { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
1400 { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
1401 { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
1402 { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
1403 { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
1404 { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
1405 { "-initString", "initString", XrmoptionSepArg, NULL },
1406 { "-firstInitString", "initString", XrmoptionSepArg, NULL },
1407 { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
1408 { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
1409 { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
1410 { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
1411 { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
1412 { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
1413 { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
1414 { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
1415 { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
1416 { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
1417 { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
1418 { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
1419 { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
1420 { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
1421 { "-fh", "firstHost", XrmoptionSepArg, NULL },
1422 { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
1423 { "-sh", "secondHost", XrmoptionSepArg, NULL },
1424 { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
1425 { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
1426 { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
1427 { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
1428 { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
1429 { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
1430 { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
1431 { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
1432 { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
1433 { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
1434 { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
1435 { "-td", "timeDelay", XrmoptionSepArg, NULL },
1436 { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
1437 { "-tc", "timeControl", XrmoptionSepArg, NULL },
1438 { "-internetChessServerMode", "internetChessServerMode",
1439 XrmoptionSepArg, NULL },
1440 { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
1441 { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
1442 { "-internetChessServerHost", "internetChessServerHost",
1443 XrmoptionSepArg, NULL },
1444 { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
1445 { "-internetChessServerPort", "internetChessServerPort",
1446 XrmoptionSepArg, NULL },
1447 { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
1448 { "-internetChessServerCommPort", "internetChessServerCommPort",
1449 XrmoptionSepArg, NULL },
1450 { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
1451 { "-internetChessServerLogonScript", "internetChessServerLogonScript",
1452 XrmoptionSepArg, NULL },
1453 { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
1454 { "-internetChessServerHelper", "internetChessServerHelper",
1455 XrmoptionSepArg, NULL },
1456 { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
1457 { "-internetChessServerInputBox", "internetChessServerInputBox",
1458 XrmoptionSepArg, NULL },
1459 { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
1460 { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
1461 { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
1462 { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
1463 { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
1464 { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
1465 { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
1466 { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
1467 { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
1468 { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
1469 { "-gateway", "gateway", XrmoptionSepArg, NULL },
1470 { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
1471 { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
1472 { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
1473 { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
1474 { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
1475 { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
1476 { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
1477 { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
1478 { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
1479 { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
1480 { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
1481 { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
1482 { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
1483 { "-blind", "blindfold", XrmoptionNoArg, "True" },
1484 { "-xblind", "blindfold", XrmoptionNoArg, "False" },
1485 { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
1486 { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
1487 { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
1488 { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
1489 { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
1490 { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
1491 { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
1492 { "-mm", "matchMode", XrmoptionNoArg, "True" },
1493 { "-xmm", "matchMode", XrmoptionNoArg, "False" },
1494 { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
1495 { "-mg", "matchGames", XrmoptionSepArg, NULL },
1496 { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
1497 { "-mono", "monoMode", XrmoptionNoArg, "True" },
1498 { "-xmono", "monoMode", XrmoptionNoArg, "False" },
1499 { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
1500 { "-debug", "debugMode", XrmoptionNoArg, "True" },
1501 { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
1502 { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
1503 { "-clock", "clockMode", XrmoptionNoArg, "True" },
1504 { "-xclock", "clockMode", XrmoptionNoArg, "False" },
1505 { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
1506 { "-size", "boardSize", XrmoptionSepArg, NULL },
1507 { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
1508 { "-st", "searchTime", XrmoptionSepArg, NULL },
1509 { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
1510 { "-depth", "searchDepth", XrmoptionSepArg, NULL },
1511 { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
1512 { "-coords", "showCoords", XrmoptionNoArg, "True" },
1513 { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
1515 { "-showJail", "showJail", XrmoptionSepArg, NULL },
1516 { "-jail", "showJail", XrmoptionNoArg, "1" },
1517 { "-sidejail", "showJail", XrmoptionNoArg, "2" },
1518 { "-xjail", "showJail", XrmoptionNoArg, "0" },
1520 { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
1521 { "-thinking", "showThinking", XrmoptionNoArg, "True" },
1522 { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
1523 { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
1524 { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
1525 { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
1526 { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
1527 { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
1528 { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
1529 { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
1530 { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
1531 { "-font", "font", XrmoptionSepArg, NULL },
1532 { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
1533 { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1534 { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1535 { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1536 { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1537 { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
1538 { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
1539 { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
1540 { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
1541 { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
1542 { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
1543 { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
1544 { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
1545 { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
1546 { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
1547 { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
1548 { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
1549 { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
1550 { "-moves", "getMoveList", XrmoptionNoArg, "True" },
1551 { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
1553 { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
1554 { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
1555 { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
1557 { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
1558 { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
1559 { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
1560 { "-premove", "premove", XrmoptionSepArg, NULL },
1561 { "-pre", "premove", XrmoptionNoArg, "True" },
1562 { "-xpre", "premove", XrmoptionNoArg, "False" },
1563 { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
1564 { "-legal", "testLegality", XrmoptionNoArg, "True" },
1565 { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
1566 { "-flipView", "flipView", XrmoptionSepArg, NULL },
1567 { "-flip", "flipView", XrmoptionNoArg, "True" },
1568 { "-xflip", "flipView", XrmoptionNoArg, "False" },
1569 { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
1570 { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
1571 XrmoptionSepArg, NULL },
1572 { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
1573 { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
1574 { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
1575 { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
1576 { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
1577 { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
1578 { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
1579 { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
1580 { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
1581 { "-title", "titleInWindow", XrmoptionNoArg, "True" },
1582 { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
1584 { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
1585 { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
1586 { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
1587 { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
1588 { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
1589 { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
1590 { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
1591 { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
1592 { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
1593 { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
1594 { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
1595 { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
1596 { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
1597 { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
1598 { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
1599 { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
1600 { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
1601 { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
1602 { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
1603 { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
1604 { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
1605 { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
1606 { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
1607 { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
1608 { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
1609 { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
1610 { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
1611 { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
1612 { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
1613 { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
1614 { "-zippyShortGame", "zippyShortGame", XrmoptionSepArg, NULL },
1616 { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
1617 { "-flash", "flashCount", XrmoptionNoArg, "3" },
1618 { "-xflash", "flashCount", XrmoptionNoArg, "0" },
1619 { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
1620 { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
1621 { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
1622 { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
1623 { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
1624 { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
1625 { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
1626 { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
1627 { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
1628 { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1629 { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
1630 { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
1631 { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
1632 { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
1633 { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
1634 { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
1635 { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
1636 { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
1637 { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
1638 { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
1639 { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
1640 { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1641 { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
1642 { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
1643 { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
1644 { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
1645 { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
1646 { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
1647 { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
1648 { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
1649 { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
1650 { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
1651 { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
1652 { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
1653 { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
1654 { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
1655 { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
1656 { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
1657 { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
1658 { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
1659 { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
1660 { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
1661 { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
1662 { "-animate", "animateMoving", XrmoptionNoArg, "True" },
1663 { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
1664 { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
1665 { "-drag", "animateDragging", XrmoptionNoArg, "True" },
1666 { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
1667 { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
1668 { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
1669 { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
1670 { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
1671 { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
1672 { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
1673 { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
1674 { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
1675 { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
1676 { "-mode", "initialMode", XrmoptionSepArg, NULL },
1677 { "-variant", "variant", XrmoptionSepArg, NULL },
1678 { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
1679 { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
1680 { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
1681 { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
1682 { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
1683 { "-lowTimeWarningColor", "lowTimeWarningColor", XrmoptionSepArg, NULL },
1684 { "-lowTimeWarning", "lowTimeWarning", XrmoptionSepArg, NULL },
1685 /* [AS,HR] New features */
1686 { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
1687 { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
1688 { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
1689 { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
1690 { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
1691 { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },
1692 { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },
1693 { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },
1694 { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },
1695 { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },
1696 { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },
1697 { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },
1698 { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1699 { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1700 { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1701 { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1702 { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },
1703 { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },
1704 { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },
1705 { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },
1706 { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },
1707 { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },
1708 { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },
1709 { "-gameListTags", "gameListTags", XrmoptionSepArg, NULL },
1710 // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c
1712 /* [HGM,HR] User-selectable board size */
1713 { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
1714 { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
1715 { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
1717 /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */
1718 { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work
1719 { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL }, // requires front-end changes to work
1720 { "-allWhite", "allWhite", XrmoptionSepArg, NULL }, // requires front-end changes to work
1721 { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL },
1722 { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL },
1723 { "-testClaims", "testClaims", XrmoptionSepArg, NULL },
1724 { "-checkMates", "checkMates", XrmoptionSepArg, NULL },
1725 { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL },
1726 { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL },
1727 { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL },
1728 { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },
1729 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1730 { "-userName", "userName", XrmoptionSepArg, NULL },
1731 { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" },
1732 { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL },
1733 { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL },
1734 { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL },
1735 { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL },
1736 { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL },
1737 { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL },
1738 { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL },
1739 { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL },
1740 { "-serverPause", "serverPause", XrmoptionSepArg, NULL },
1741 { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL },
1742 { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL },
1743 { "-userName", "userName", XrmoptionSepArg, NULL },
1744 { "-smpCores", "smpCores", XrmoptionSepArg, NULL },
1745 { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL },
1746 { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL },
1747 { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL },
1748 { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL },
1749 { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL },
1750 { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1751 { "-debugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1752 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1753 { "-noGUI", "noGUI", XrmoptionNoArg, "True" },
1754 { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL },
1755 { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL },
1756 { "-firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1757 { "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1761 XtActionsRec boardActions[] = {
1762 { "DrawPosition", DrawPositionProc },
1763 { "HandleUserMove", HandleUserMove },
1764 { "AnimateUserMove", AnimateUserMove },
1765 { "FileNameAction", FileNameAction },
1766 { "AskQuestionProc", AskQuestionProc },
1767 { "AskQuestionReplyAction", AskQuestionReplyAction },
1768 { "PieceMenuPopup", PieceMenuPopup },
1769 { "WhiteClock", WhiteClock },
1770 { "BlackClock", BlackClock },
1771 { "Iconify", Iconify },
1772 { "ResetProc", ResetProc },
1773 { "LoadGameProc", LoadGameProc },
1774 { "LoadNextGameProc", LoadNextGameProc },
1775 { "LoadPrevGameProc", LoadPrevGameProc },
1776 { "LoadSelectedProc", LoadSelectedProc },
1777 { "ReloadGameProc", ReloadGameProc },
1778 { "LoadPositionProc", LoadPositionProc },
1779 { "LoadNextPositionProc", LoadNextPositionProc },
1780 { "LoadPrevPositionProc", LoadPrevPositionProc },
1781 { "ReloadPositionProc", ReloadPositionProc },
1782 { "CopyPositionProc", CopyPositionProc },
1783 { "PastePositionProc", PastePositionProc },
1784 { "CopyGameProc", CopyGameProc },
1785 { "PasteGameProc", PasteGameProc },
1786 { "SaveGameProc", SaveGameProc },
1787 { "SavePositionProc", SavePositionProc },
1788 { "MailMoveProc", MailMoveProc },
1789 { "ReloadCmailMsgProc", ReloadCmailMsgProc },
1790 { "QuitProc", QuitProc },
1791 { "MachineWhiteProc", MachineWhiteProc },
1792 { "MachineBlackProc", MachineBlackProc },
1793 { "AnalysisModeProc", AnalyzeModeProc },
1794 { "AnalyzeFileProc", AnalyzeFileProc },
1795 { "TwoMachinesProc", TwoMachinesProc },
1796 { "IcsClientProc", IcsClientProc },
1797 { "EditGameProc", EditGameProc },
1798 { "EditPositionProc", EditPositionProc },
1799 { "TrainingProc", EditPositionProc },
1800 { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
1801 { "ShowGameListProc", ShowGameListProc },
1802 { "ShowMoveListProc", HistoryShowProc},
1803 { "EditTagsProc", EditCommentProc },
1804 { "EditCommentProc", EditCommentProc },
1805 { "IcsAlarmProc", IcsAlarmProc },
1806 { "IcsInputBoxProc", IcsInputBoxProc },
1807 { "PauseProc", PauseProc },
1808 { "AcceptProc", AcceptProc },
1809 { "DeclineProc", DeclineProc },
1810 { "RematchProc", RematchProc },
1811 { "CallFlagProc", CallFlagProc },
1812 { "DrawProc", DrawProc },
1813 { "AdjournProc", AdjournProc },
1814 { "AbortProc", AbortProc },
1815 { "ResignProc", ResignProc },
1816 { "AdjuWhiteProc", AdjuWhiteProc },
1817 { "AdjuBlackProc", AdjuBlackProc },
1818 { "AdjuDrawProc", AdjuDrawProc },
1819 { "EnterKeyProc", EnterKeyProc },
1820 { "StopObservingProc", StopObservingProc },
1821 { "StopExaminingProc", StopExaminingProc },
1822 { "BackwardProc", BackwardProc },
1823 { "ForwardProc", ForwardProc },
1824 { "ToStartProc", ToStartProc },
1825 { "ToEndProc", ToEndProc },
1826 { "RevertProc", RevertProc },
1827 { "TruncateGameProc", TruncateGameProc },
1828 { "MoveNowProc", MoveNowProc },
1829 { "RetractMoveProc", RetractMoveProc },
1830 { "AlwaysQueenProc", AlwaysQueenProc },
1831 { "AnimateDraggingProc", AnimateDraggingProc },
1832 { "AnimateMovingProc", AnimateMovingProc },
1833 { "AutoflagProc", AutoflagProc },
1834 { "AutoflipProc", AutoflipProc },
1835 { "AutobsProc", AutobsProc },
1836 { "AutoraiseProc", AutoraiseProc },
1837 { "AutosaveProc", AutosaveProc },
1838 { "BlindfoldProc", BlindfoldProc },
1839 { "FlashMovesProc", FlashMovesProc },
1840 { "FlipViewProc", FlipViewProc },
1841 { "GetMoveListProc", GetMoveListProc },
1843 { "HighlightDraggingProc", HighlightDraggingProc },
1845 { "HighlightLastMoveProc", HighlightLastMoveProc },
1846 { "IcsAlarmProc", IcsAlarmProc },
1847 { "MoveSoundProc", MoveSoundProc },
1848 { "OldSaveStyleProc", OldSaveStyleProc },
1849 { "PeriodicUpdatesProc", PeriodicUpdatesProc },
1850 { "PonderNextMoveProc", PonderNextMoveProc },
1851 { "PopupExitMessageProc", PopupExitMessageProc },
1852 { "PopupMoveErrorsProc", PopupMoveErrorsProc },
1853 { "PremoveProc", PremoveProc },
1854 { "QuietPlayProc", QuietPlayProc },
1855 { "ShowCoordsProc", ShowCoordsProc },
1856 { "ShowThinkingProc", ShowThinkingProc },
1857 { "HideThinkingProc", HideThinkingProc },
1858 { "TestLegalityProc", TestLegalityProc },
1859 { "InfoProc", InfoProc },
1860 { "ManProc", ManProc },
1861 { "HintProc", HintProc },
1862 { "BookProc", BookProc },
1863 { "AboutGameProc", AboutGameProc },
1864 { "AboutProc", AboutProc },
1865 { "DebugProc", DebugProc },
1866 { "NothingProc", NothingProc },
1867 { "CommentPopDown", (XtActionProc) CommentPopDown },
1868 { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
1869 { "TagsPopDown", (XtActionProc) TagsPopDown },
1870 { "ErrorPopDown", (XtActionProc) ErrorPopDown },
1871 { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
1872 { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
1873 { "FileNamePopDown", (XtActionProc) FileNamePopDown },
1874 { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
1875 { "GameListPopDown", (XtActionProc) GameListPopDown },
1876 { "PromotionPopDown", (XtActionProc) PromotionPopDown },
1877 { "HistoryPopDown", (XtActionProc) HistoryPopDown },
1878 { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
1879 { "ShufflePopDown", (XtActionProc) ShufflePopDown },
1880 { "EnginePopDown", (XtActionProc) EnginePopDown },
1881 { "UciPopDown", (XtActionProc) UciPopDown },
1882 { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
1883 { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
1884 { "SettingsPopDown", (XtActionProc) SettingsPopDown },
1887 char globalTranslations[] =
1888 ":<Key>R: ResignProc() \n \
1889 :<Key>r: ResetProc() \n \
1890 :<Key>g: LoadGameProc() \n \
1891 :<Key>N: LoadNextGameProc() \n \
1892 :<Key>P: LoadPrevGameProc() \n \
1893 :<Key>Q: QuitProc() \n \
1894 :<Key>F: ToEndProc() \n \
1895 :<Key>f: ForwardProc() \n \
1896 :<Key>B: ToStartProc() \n \
1897 :<Key>b: BackwardProc() \n \
1898 :<Key>p: PauseProc() \n \
1899 :<Key>d: DrawProc() \n \
1900 :<Key>t: CallFlagProc() \n \
1901 :<Key>i: Iconify() \n \
1902 :<Key>c: Iconify() \n \
1903 :<Key>v: FlipViewProc() \n \
1904 <KeyDown>Control_L: BackwardProc() \n \
1905 <KeyUp>Control_L: ForwardProc() \n \
1906 <KeyDown>Control_R: BackwardProc() \n \
1907 <KeyUp>Control_R: ForwardProc() \n \
1908 Shift<Key>1: AskQuestionProc(\"Direct command\",\
1909 \"Send to chess program:\",,1) \n \
1910 Shift<Key>2: AskQuestionProc(\"Direct command\",\
1911 \"Send to second chess program:\",,2) \n";
1913 char boardTranslations[] =
1914 "<Btn1Down>: HandleUserMove() \n \
1915 <Btn1Up>: HandleUserMove() \n \
1916 <Btn1Motion>: AnimateUserMove() \n \
1917 Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
1918 PieceMenuPopup(menuB) \n \
1919 Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
1920 PieceMenuPopup(menuW) \n \
1921 Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
1922 PieceMenuPopup(menuW) \n \
1923 Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
1924 PieceMenuPopup(menuB) \n";
1926 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
1927 char blackTranslations[] = "<BtnDown>: BlackClock()\n";
1929 char ICSInputTranslations[] =
1930 "<Key>Return: EnterKeyProc() \n";
1932 String xboardResources[] = {
1933 "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
1934 "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
1935 "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
1940 /* Max possible square size */
1941 #define MAXSQSIZE 256
1943 static int xpm_avail[MAXSQSIZE];
1945 #ifdef HAVE_DIR_STRUCT
1947 /* Extract piece size from filename */
1949 xpm_getsize(name, len, ext)
1960 if ((p=strchr(name, '.')) == NULL ||
1961 StrCaseCmp(p+1, ext) != 0)
1967 while (*p && isdigit(*p))
1974 /* Setup xpm_avail */
1976 xpm_getavail(dirname, ext)
1984 for (i=0; i<MAXSQSIZE; ++i)
1987 if (appData.debugMode)
1988 fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
1990 dir = opendir(dirname);
1993 fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
1994 programName, dirname);
1998 while ((ent=readdir(dir)) != NULL) {
1999 i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
2000 if (i > 0 && i < MAXSQSIZE)
2010 xpm_print_avail(fp, ext)
2016 fprintf(fp, _("Available `%s' sizes:\n"), ext);
2017 for (i=1; i<MAXSQSIZE; ++i) {
2023 /* Return XPM piecesize closest to size */
2025 xpm_closest_to(dirname, size, ext)
2031 int sm_diff = MAXSQSIZE;
2035 xpm_getavail(dirname, ext);
2037 if (appData.debugMode)
2038 xpm_print_avail(stderr, ext);
2040 for (i=1; i<MAXSQSIZE; ++i) {
2043 diff = (diff<0) ? -diff : diff;
2044 if (diff < sm_diff) {
2052 fprintf(stderr, _("Error: No `%s' files!\n"), ext);
2058 #else /* !HAVE_DIR_STRUCT */
2059 /* If we are on a system without a DIR struct, we can't
2060 read the directory, so we can't collect a list of
2061 filenames, etc., so we can't do any size-fitting. */
2063 xpm_closest_to(dirname, size, ext)
2068 fprintf(stderr, _("\
2069 Warning: No DIR structure found on this system --\n\
2070 Unable to autosize for XPM/XIM pieces.\n\
2071 Please report this error to frankm@hiwaay.net.\n\
2072 Include system type & operating system in message.\n"));
2075 #endif /* HAVE_DIR_STRUCT */
2077 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
2078 "magenta", "cyan", "white" };
2082 TextColors textColors[(int)NColorClasses];
2084 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
2086 parse_color(str, which)
2090 char *p, buf[100], *d;
2093 if (strlen(str) > 99) /* watch bounds on buf */
2098 for (i=0; i<which; ++i) {
2105 /* Could be looking at something like:
2107 .. in which case we want to stop on a comma also */
2108 while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
2112 return -1; /* Use default for empty field */
2115 if (which == 2 || isdigit(*p))
2118 while (*p && isalpha(*p))
2123 for (i=0; i<8; ++i) {
2124 if (!StrCaseCmp(buf, cnames[i]))
2125 return which? (i+40) : (i+30);
2127 if (!StrCaseCmp(buf, "default")) return -1;
2129 fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
2134 parse_cpair(cc, str)
2138 if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
2139 fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
2144 /* bg and attr are optional */
2145 textColors[(int)cc].bg = parse_color(str, 1);
2146 if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {
2147 textColors[(int)cc].attr = 0;
2153 /* Arrange to catch delete-window events */
2154 Atom wm_delete_window;
2156 CatchDeleteWindow(Widget w, String procname)
2159 XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
2160 snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
2161 XtAugmentTranslations(w, XtParseTranslationTable(buf));
2168 XtSetArg(args[0], XtNiconic, False);
2169 XtSetValues(shellWidget, args, 1);
2171 XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
2175 // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
2177 #define BoardSize int
2178 void InitDrawingSizes(BoardSize boardSize, int flags)
2179 { // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
2180 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2182 XtGeometryResult gres;
2185 if(!formWidget) return;
2188 * Enable shell resizing.
2190 shellArgs[0].value = (XtArgVal) &w;
2191 shellArgs[1].value = (XtArgVal) &h;
2192 XtGetValues(shellWidget, shellArgs, 2);
2194 shellArgs[4].value = 2*w; shellArgs[2].value = 10;
2195 shellArgs[5].value = 2*h; shellArgs[3].value = 10;
2196 XtSetValues(shellWidget, &shellArgs[2], 4);
2198 XtSetArg(args[0], XtNdefaultDistance, &sep);
2199 XtGetValues(formWidget, args, 1);
2201 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2202 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2205 XtSetArg(args[0], XtNwidth, boardWidth);
2206 XtSetArg(args[1], XtNheight, boardHeight);
2207 XtSetValues(boardWidget, args, 2);
2209 timerWidth = (boardWidth - sep) / 2;
2210 XtSetArg(args[0], XtNwidth, timerWidth);
2211 XtSetValues(whiteTimerWidget, args, 1);
2212 XtSetValues(blackTimerWidget, args, 1);
2214 XawFormDoLayout(formWidget, False);
2216 if (appData.titleInWindow) {
2218 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2219 XtSetArg(args[i], XtNheight, &h); i++;
2220 XtGetValues(titleWidget, args, i);
2222 w = boardWidth - 2*bor;
2224 XtSetArg(args[0], XtNwidth, &w);
2225 XtGetValues(menuBarWidget, args, 1);
2226 w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
2229 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2230 if (gres != XtGeometryYes && appData.debugMode) {
2232 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2233 programName, gres, w, h, wr, hr);
2237 XawFormDoLayout(formWidget, True);
2240 * Inhibit shell resizing.
2242 shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
2243 shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
2244 shellArgs[4].value = shellArgs[2].value = w;
2245 shellArgs[5].value = shellArgs[3].value = h;
2246 XtSetValues(shellWidget, &shellArgs[0], 6);
2255 int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
2256 XSetWindowAttributes window_attributes;
2258 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2259 XrmValue vFrom, vTo;
2260 XtGeometryResult gres;
2263 int forceMono = False;
2266 // [HGM] before anything else, expand any indirection files amongst options
2267 char *argvCopy[1000]; // 1000 seems enough
2268 char newArgs[10000]; // holds actual characters
2271 srandom(time(0)); // [HGM] book: make random truly random
2274 for(i=0; i<argc; i++) {
2275 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2276 //fprintf(stderr, "arg %s\n", argv[i]);
2277 if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
2279 FILE *f = fopen(argv[i]+1, "rb");
2280 if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
2281 argvCopy[j++] = newArgs + k; // get ready for first argument from file
2282 while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
2284 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2285 newArgs[k++] = 0; // terminate current arg
2286 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2287 argvCopy[j++] = newArgs + k; // get ready for next
2289 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2302 if(appData.debugMode,1) { // OK, appData is not initialized here yet...
2303 for(i=0; i<argc; i++) fprintf(stderr, "argv[%2d] = '%s'\n", i, argv[i]);
2309 setbuf(stdout, NULL);
2310 setbuf(stderr, NULL);
2313 programName = strrchr(argv[0], '/');
2314 if (programName == NULL)
2315 programName = argv[0];
2320 XtSetLanguageProc(NULL, NULL, NULL);
2321 bindtextdomain(PRODUCT, LOCALEDIR);
2322 textdomain(PRODUCT);
2326 XtAppInitialize(&appContext, "XBoard", shellOptions,
2327 XtNumber(shellOptions),
2328 &argc, argv, xboardResources, NULL, 0);
2330 fprintf(stderr, _("%s: unrecognized argument %s\n"),
2331 programName, argv[1]);
2332 fprintf(stderr, "Recognized options:\n");
2333 for(i = 0; i < XtNumber(shellOptions); i++) {
2334 j = fprintf(stderr, " %s%s", shellOptions[i].option,
2335 (shellOptions[i].argKind == XrmoptionSepArg
2337 if (i++ < XtNumber(shellOptions)) {
2338 fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
2339 shellOptions[i].option,
2340 (shellOptions[i].argKind == XrmoptionSepArg
2343 fprintf(stderr, "\n");
2349 if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
2352 if (chdir(chessDir) != 0) {
2353 fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
2360 if (p == NULL) p = "/tmp";
2361 i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
2362 gameCopyFilename = (char*) malloc(i);
2363 gamePasteFilename = (char*) malloc(i);
2364 snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
2365 snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
2367 XtGetApplicationResources(shellWidget, (XtPointer) &appData,
2368 clientResources, XtNumber(clientResources),
2371 if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
2372 /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
2373 if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL) {
2374 printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
2377 setbuf(debugFP, NULL);
2380 /* [HGM,HR] make sure board size is acceptable */
2381 if(appData.NrFiles > BOARD_SIZE ||
2382 appData.NrRanks > BOARD_SIZE )
2383 DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
2386 /* This feature does not work; animation needs a rewrite */
2387 appData.highlightDragging = FALSE;
2391 xDisplay = XtDisplay(shellWidget);
2392 xScreen = DefaultScreen(xDisplay);
2393 wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
2395 gameInfo.variant = StringToVariant(appData.variant);
2396 InitPosition(FALSE);
2399 * Determine boardSize
2401 gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8
2404 // [HGM] as long as we have not created the possibility to change size while running, start with requested size
2405 gameInfo.boardWidth = appData.NrFiles > 0 ? appData.NrFiles : 8;
2406 gameInfo.boardHeight = appData.NrRanks > 0 ? appData.NrRanks : 8;
2407 gameInfo.holdingsWidth = appData.holdingsSize > 0 ? 2 : 0;
2412 InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
2414 if (isdigit(appData.boardSize[0])) {
2415 i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
2416 &lineGap, &clockFontPxlSize, &coordFontPxlSize,
2417 &fontPxlSize, &smallLayout, &tinyLayout);
2419 fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
2420 programName, appData.boardSize);
2424 /* Find some defaults; use the nearest known size */
2425 SizeDefaults *szd, *nearest;
2426 int distance = 99999;
2427 nearest = szd = sizeDefaults;
2428 while (szd->name != NULL) {
2429 if (abs(szd->squareSize - squareSize) < distance) {
2431 distance = abs(szd->squareSize - squareSize);
2432 if (distance == 0) break;
2436 if (i < 2) lineGap = nearest->lineGap;
2437 if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
2438 if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
2439 if (i < 5) fontPxlSize = nearest->fontPxlSize;
2440 if (i < 6) smallLayout = nearest->smallLayout;
2441 if (i < 7) tinyLayout = nearest->tinyLayout;
2444 SizeDefaults *szd = sizeDefaults;
2445 if (*appData.boardSize == NULLCHAR) {
2446 while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
2447 DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
2450 if (szd->name == NULL) szd--;
2452 while (szd->name != NULL &&
2453 StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
2454 if (szd->name == NULL) {
2455 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
2456 programName, appData.boardSize);
2460 squareSize = szd->squareSize;
2461 lineGap = szd->lineGap;
2462 clockFontPxlSize = szd->clockFontPxlSize;
2463 coordFontPxlSize = szd->coordFontPxlSize;
2464 fontPxlSize = szd->fontPxlSize;
2465 smallLayout = szd->smallLayout;
2466 tinyLayout = szd->tinyLayout;
2469 /* Now, using squareSize as a hint, find a good XPM/XIM set size */
2470 if (strlen(appData.pixmapDirectory) > 0) {
2471 p = ExpandPathName(appData.pixmapDirectory);
2473 fprintf(stderr, _("Error expanding path name \"%s\"\n"),
2474 appData.pixmapDirectory);
2477 if (appData.debugMode) {
2478 fprintf(stderr, _("\
2479 XBoard square size (hint): %d\n\
2480 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
2482 squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
2483 if (appData.debugMode) {
2484 fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
2488 /* [HR] height treated separately (hacked) */
2489 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2490 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2491 if (appData.showJail == 1) {
2492 /* Jail on top and bottom */
2493 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2494 XtSetArg(boardArgs[2], XtNheight,
2495 boardHeight + 2*(lineGap + squareSize));
2496 } else if (appData.showJail == 2) {
2498 XtSetArg(boardArgs[1], XtNwidth,
2499 boardWidth + 2*(lineGap + squareSize));
2500 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2503 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2504 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2508 * Determine what fonts to use.
2510 appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
2511 clockFontID = XLoadFont(xDisplay, appData.clockFont);
2512 clockFontStruct = XQueryFont(xDisplay, clockFontID);
2513 appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
2514 coordFontID = XLoadFont(xDisplay, appData.coordFont);
2515 coordFontStruct = XQueryFont(xDisplay, coordFontID);
2516 appData.font = FindFont(appData.font, fontPxlSize);
2517 countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
2518 countFontStruct = XQueryFont(xDisplay, countFontID);
2519 // appData.font = FindFont(appData.font, fontPxlSize);
2521 xdb = XtDatabase(xDisplay);
2522 XrmPutStringResource(&xdb, "*font", appData.font);
2525 * Detect if there are not enough colors available and adapt.
2527 if (DefaultDepth(xDisplay, xScreen) <= 2) {
2528 appData.monoMode = True;
2531 if (!appData.monoMode) {
2532 vFrom.addr = (caddr_t) appData.lightSquareColor;
2533 vFrom.size = strlen(appData.lightSquareColor);
2534 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2535 if (vTo.addr == NULL) {
2536 appData.monoMode = True;
2539 lightSquareColor = *(Pixel *) vTo.addr;
2542 if (!appData.monoMode) {
2543 vFrom.addr = (caddr_t) appData.darkSquareColor;
2544 vFrom.size = strlen(appData.darkSquareColor);
2545 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2546 if (vTo.addr == NULL) {
2547 appData.monoMode = True;
2550 darkSquareColor = *(Pixel *) vTo.addr;
2553 if (!appData.monoMode) {
2554 vFrom.addr = (caddr_t) appData.whitePieceColor;
2555 vFrom.size = strlen(appData.whitePieceColor);
2556 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2557 if (vTo.addr == NULL) {
2558 appData.monoMode = True;
2561 whitePieceColor = *(Pixel *) vTo.addr;
2564 if (!appData.monoMode) {
2565 vFrom.addr = (caddr_t) appData.blackPieceColor;
2566 vFrom.size = strlen(appData.blackPieceColor);
2567 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2568 if (vTo.addr == NULL) {
2569 appData.monoMode = True;
2572 blackPieceColor = *(Pixel *) vTo.addr;
2576 if (!appData.monoMode) {
2577 vFrom.addr = (caddr_t) appData.highlightSquareColor;
2578 vFrom.size = strlen(appData.highlightSquareColor);
2579 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2580 if (vTo.addr == NULL) {
2581 appData.monoMode = True;
2584 highlightSquareColor = *(Pixel *) vTo.addr;
2588 if (!appData.monoMode) {
2589 vFrom.addr = (caddr_t) appData.premoveHighlightColor;
2590 vFrom.size = strlen(appData.premoveHighlightColor);
2591 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2592 if (vTo.addr == NULL) {
2593 appData.monoMode = True;
2596 premoveHighlightColor = *(Pixel *) vTo.addr;
2601 fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
2605 if (appData.lowTimeWarning && !appData.monoMode) {
2606 vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
2607 vFrom.size = strlen(appData.lowTimeWarningColor);
2608 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2609 if (vTo.addr == NULL)
2610 appData.monoMode = True;
2612 lowTimeWarningColor = *(Pixel *) vTo.addr;
2615 if (appData.monoMode && appData.debugMode) {
2616 fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
2617 (unsigned long) XWhitePixel(xDisplay, xScreen),
2618 (unsigned long) XBlackPixel(xDisplay, xScreen));
2621 if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
2622 parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
2623 parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
2624 parse_cpair(ColorChannel, appData.colorChannel) < 0 ||
2625 parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||
2626 parse_cpair(ColorTell, appData.colorTell) < 0 ||
2627 parse_cpair(ColorChallenge, appData.colorChallenge) < 0 ||
2628 parse_cpair(ColorRequest, appData.colorRequest) < 0 ||
2629 parse_cpair(ColorSeek, appData.colorSeek) < 0 ||
2630 parse_cpair(ColorNormal, appData.colorNormal) < 0)
2632 if (appData.colorize) {
2634 _("%s: can't parse color names; disabling colorization\n"),
2637 appData.colorize = FALSE;
2639 textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
2640 textColors[ColorNone].attr = 0;
2642 XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
2648 layoutName = "tinyLayout";
2649 } else if (smallLayout) {
2650 layoutName = "smallLayout";
2652 layoutName = "normalLayout";
2654 /* Outer layoutWidget is there only to provide a name for use in
2655 resources that depend on the layout style */
2657 XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
2658 layoutArgs, XtNumber(layoutArgs));
2660 XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
2661 formArgs, XtNumber(formArgs));
2662 XtSetArg(args[0], XtNdefaultDistance, &sep);
2663 XtGetValues(formWidget, args, 1);
2666 widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
2667 XtSetArg(args[0], XtNtop, XtChainTop);
2668 XtSetArg(args[1], XtNbottom, XtChainTop);
2669 XtSetValues(menuBarWidget, args, 2);
2671 widgetList[j++] = whiteTimerWidget =
2672 XtCreateWidget("whiteTime", labelWidgetClass,
2673 formWidget, timerArgs, XtNumber(timerArgs));
2674 XtSetArg(args[0], XtNfont, clockFontStruct);
2675 XtSetArg(args[1], XtNtop, XtChainTop);
2676 XtSetArg(args[2], XtNbottom, XtChainTop);
2677 XtSetValues(whiteTimerWidget, args, 3);
2679 widgetList[j++] = blackTimerWidget =
2680 XtCreateWidget("blackTime", labelWidgetClass,
2681 formWidget, timerArgs, XtNumber(timerArgs));
2682 XtSetArg(args[0], XtNfont, clockFontStruct);
2683 XtSetArg(args[1], XtNtop, XtChainTop);
2684 XtSetArg(args[2], XtNbottom, XtChainTop);
2685 XtSetValues(blackTimerWidget, args, 3);
2687 if (appData.titleInWindow) {
2688 widgetList[j++] = titleWidget =
2689 XtCreateWidget("title", labelWidgetClass, formWidget,
2690 titleArgs, XtNumber(titleArgs));
2691 XtSetArg(args[0], XtNtop, XtChainTop);
2692 XtSetArg(args[1], XtNbottom, XtChainTop);
2693 XtSetValues(titleWidget, args, 2);
2696 if (appData.showButtonBar) {
2697 widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
2698 XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
2699 XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
2700 XtSetArg(args[2], XtNtop, XtChainTop);
2701 XtSetArg(args[3], XtNbottom, XtChainTop);
2702 XtSetValues(buttonBarWidget, args, 4);
2705 widgetList[j++] = messageWidget =
2706 XtCreateWidget("message", labelWidgetClass, formWidget,
2707 messageArgs, XtNumber(messageArgs));
2708 XtSetArg(args[0], XtNtop, XtChainTop);
2709 XtSetArg(args[1], XtNbottom, XtChainTop);
2710 XtSetValues(messageWidget, args, 2);
2712 widgetList[j++] = boardWidget =
2713 XtCreateWidget("board", widgetClass, formWidget, boardArgs,
2714 XtNumber(boardArgs));
2716 XtManageChildren(widgetList, j);
2718 timerWidth = (boardWidth - sep) / 2;
2719 XtSetArg(args[0], XtNwidth, timerWidth);
2720 XtSetValues(whiteTimerWidget, args, 1);
2721 XtSetValues(blackTimerWidget, args, 1);
2723 XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
2724 XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
2725 XtGetValues(whiteTimerWidget, args, 2);
2727 if (appData.showButtonBar) {
2728 XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
2729 XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
2730 XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
2734 * formWidget uses these constraints but they are stored
2738 XtSetArg(args[i], XtNfromHoriz, 0); i++;
2739 XtSetValues(menuBarWidget, args, i);
2740 if (appData.titleInWindow) {
2743 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2744 XtSetValues(whiteTimerWidget, args, i);
2746 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2747 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2748 XtSetValues(blackTimerWidget, args, i);
2750 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2751 XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
2752 XtSetValues(titleWidget, args, i);
2754 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2755 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2756 XtSetValues(messageWidget, args, i);
2757 if (appData.showButtonBar) {
2759 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2760 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2761 XtSetValues(buttonBarWidget, args, i);
2765 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2766 XtSetValues(whiteTimerWidget, args, i);
2768 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2769 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2770 XtSetValues(blackTimerWidget, args, i);
2772 XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
2773 XtSetValues(titleWidget, args, i);
2775 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2776 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2777 XtSetValues(messageWidget, args, i);
2778 if (appData.showButtonBar) {
2780 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2781 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2782 XtSetValues(buttonBarWidget, args, i);
2787 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2788 XtSetValues(whiteTimerWidget, args, i);
2790 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2791 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2792 XtSetValues(blackTimerWidget, args, i);
2794 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2795 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2796 XtSetValues(messageWidget, args, i);
2797 if (appData.showButtonBar) {
2799 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2800 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2801 XtSetValues(buttonBarWidget, args, i);
2805 XtSetArg(args[0], XtNfromVert, messageWidget);
2806 XtSetArg(args[1], XtNtop, XtChainTop);
2807 XtSetArg(args[2], XtNbottom, XtChainBottom);
2808 XtSetArg(args[3], XtNleft, XtChainLeft);
2809 XtSetArg(args[4], XtNright, XtChainRight);
2810 XtSetValues(boardWidget, args, 5);
2812 XtRealizeWidget(shellWidget);
2815 * Correct the width of the message and title widgets.
2816 * It is not known why some systems need the extra fudge term.
2817 * The value "2" is probably larger than needed.
2819 XawFormDoLayout(formWidget, False);
2821 #define WIDTH_FUDGE 2
2823 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2824 XtSetArg(args[i], XtNheight, &h); i++;
2825 XtGetValues(messageWidget, args, i);
2826 if (appData.showButtonBar) {
2828 XtSetArg(args[i], XtNwidth, &w); i++;
2829 XtGetValues(buttonBarWidget, args, i);
2830 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2832 w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
2835 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2836 if (gres != XtGeometryYes && appData.debugMode) {
2837 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2838 programName, gres, w, h, wr, hr);
2841 /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
2842 /* The size used for the child widget in layout lags one resize behind
2843 its true size, so we resize a second time, 1 pixel smaller. Yeech! */
2845 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2846 if (gres != XtGeometryYes && appData.debugMode) {
2847 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2848 programName, gres, w, h, wr, hr);
2851 XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
2852 XtSetArg(args[1], XtNright, XtChainRight);
2853 XtSetValues(messageWidget, args, 2);
2855 if (appData.titleInWindow) {
2857 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2858 XtSetArg(args[i], XtNheight, &h); i++;
2859 XtGetValues(titleWidget, args, i);
2861 w = boardWidth - 2*bor;
2863 XtSetArg(args[0], XtNwidth, &w);
2864 XtGetValues(menuBarWidget, args, 1);
2865 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2868 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2869 if (gres != XtGeometryYes && appData.debugMode) {
2871 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2872 programName, gres, w, h, wr, hr);
2875 XawFormDoLayout(formWidget, True);
2877 xBoardWindow = XtWindow(boardWidget);
2879 // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
2880 // not need to go into InitDrawingSizes().
2884 * Create X checkmark bitmap and initialize option menu checks.
2886 ReadBitmap(&xMarkPixmap, "checkmark.bm",
2887 checkmark_bits, checkmark_width, checkmark_height);
2888 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
2889 if (appData.alwaysPromoteToQueen) {
2890 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
2893 if (appData.animateDragging) {
2894 XtSetValues(XtNameToWidget(menuBarWidget,
2895 "menuOptions.Animate Dragging"),
2898 if (appData.animate) {
2899 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
2902 if (appData.autoComment) {
2903 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
2906 if (appData.autoCallFlag) {
2907 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
2910 if (appData.autoFlipView) {
2911 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
2914 if (appData.autoObserve) {
2915 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
2918 if (appData.autoRaiseBoard) {
2919 XtSetValues(XtNameToWidget(menuBarWidget,
2920 "menuOptions.Auto Raise Board"), args, 1);
2922 if (appData.autoSaveGames) {
2923 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2926 if (appData.saveGameFile[0] != NULLCHAR) {
2927 /* Can't turn this off from menu */
2928 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2930 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2934 if (appData.blindfold) {
2935 XtSetValues(XtNameToWidget(menuBarWidget,
2936 "menuOptions.Blindfold"), args, 1);
2938 if (appData.flashCount > 0) {
2939 XtSetValues(XtNameToWidget(menuBarWidget,
2940 "menuOptions.Flash Moves"),
2943 if (appData.getMoveList) {
2944 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
2948 if (appData.highlightDragging) {
2949 XtSetValues(XtNameToWidget(menuBarWidget,
2950 "menuOptions.Highlight Dragging"),
2954 if (appData.highlightLastMove) {
2955 XtSetValues(XtNameToWidget(menuBarWidget,
2956 "menuOptions.Highlight Last Move"),
2959 if (appData.icsAlarm) {
2960 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
2963 if (appData.ringBellAfterMoves) {
2964 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
2967 if (appData.oldSaveStyle) {
2968 XtSetValues(XtNameToWidget(menuBarWidget,
2969 "menuOptions.Old Save Style"), args, 1);
2971 if (appData.periodicUpdates) {
2972 XtSetValues(XtNameToWidget(menuBarWidget,
2973 "menuOptions.Periodic Updates"), args, 1);
2975 if (appData.ponderNextMove) {
2976 XtSetValues(XtNameToWidget(menuBarWidget,
2977 "menuOptions.Ponder Next Move"), args, 1);
2979 if (appData.popupExitMessage) {
2980 XtSetValues(XtNameToWidget(menuBarWidget,
2981 "menuOptions.Popup Exit Message"), args, 1);
2983 if (appData.popupMoveErrors) {
2984 XtSetValues(XtNameToWidget(menuBarWidget,
2985 "menuOptions.Popup Move Errors"), args, 1);
2987 if (appData.premove) {
2988 XtSetValues(XtNameToWidget(menuBarWidget,
2989 "menuOptions.Premove"), args, 1);
2991 if (appData.quietPlay) {
2992 XtSetValues(XtNameToWidget(menuBarWidget,
2993 "menuOptions.Quiet Play"), args, 1);
2995 if (appData.showCoords) {
2996 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
2999 if (appData.hideThinkingFromHuman) {
3000 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
3003 if (appData.testLegality) {
3004 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
3011 ReadBitmap(&wIconPixmap, "icon_white.bm",
3012 icon_white_bits, icon_white_width, icon_white_height);
3013 ReadBitmap(&bIconPixmap, "icon_black.bm",
3014 icon_black_bits, icon_black_width, icon_black_height);
3015 iconPixmap = wIconPixmap;
3017 XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
3018 XtSetValues(shellWidget, args, i);
3021 * Create a cursor for the board widget.
3023 window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
3024 XChangeWindowAttributes(xDisplay, xBoardWindow,
3025 CWCursor, &window_attributes);
3028 * Inhibit shell resizing.
3030 shellArgs[0].value = (XtArgVal) &w;
3031 shellArgs[1].value = (XtArgVal) &h;
3032 XtGetValues(shellWidget, shellArgs, 2);
3033 shellArgs[4].value = shellArgs[2].value = w;
3034 shellArgs[5].value = shellArgs[3].value = h;
3035 XtSetValues(shellWidget, &shellArgs[2], 4);
3036 marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
3037 marginH = h - boardHeight;
3039 CatchDeleteWindow(shellWidget, "QuitProc");
3044 if (appData.bitmapDirectory[0] != NULLCHAR) {
3051 /* Create regular pieces */
3052 if (!useImages) CreatePieces();
3057 if (appData.animate || appData.animateDragging)
3060 XtAugmentTranslations(formWidget,
3061 XtParseTranslationTable(globalTranslations));
3062 XtAugmentTranslations(boardWidget,
3063 XtParseTranslationTable(boardTranslations));
3064 XtAugmentTranslations(whiteTimerWidget,
3065 XtParseTranslationTable(whiteTranslations));
3066 XtAugmentTranslations(blackTimerWidget,
3067 XtParseTranslationTable(blackTranslations));
3069 /* Why is the following needed on some versions of X instead
3070 * of a translation? */
3071 XtAddEventHandler(boardWidget, ExposureMask, False,
3072 (XtEventHandler) EventProc, NULL);
3077 if (errorExitStatus == -1) {
3078 if (appData.icsActive) {
3079 /* We now wait until we see "login:" from the ICS before
3080 sending the logon script (problems with timestamp otherwise) */
3081 /*ICSInitScript();*/
3082 if (appData.icsInputBox) ICSInputBoxPopUp();
3085 signal(SIGINT, IntSigHandler);
3086 signal(SIGTERM, IntSigHandler);
3087 if (*appData.cmailGameName != NULLCHAR) {
3088 signal(SIGUSR1, CmailSigHandler);
3093 XtAppMainLoop(appContext);
3094 if (appData.debugMode) fclose(debugFP); // [DM] debug
3101 if (appData.icsActive && oldICSInteractionTitle != NULL) {
3102 DisplayIcsInteractionTitle(oldICSInteractionTitle);
3104 unlink(gameCopyFilename);
3105 unlink(gamePasteFilename);
3116 CmailSigHandler(sig)
3122 signal(SIGUSR1, SIG_IGN); /* suspend handler */
3124 /* Activate call-back function CmailSigHandlerCallBack() */
3125 OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
3127 signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
3131 CmailSigHandlerCallBack(isr, closure, message, count, error)
3139 ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */
3141 /**** end signal code ****/
3151 f = fopen(appData.icsLogon, "r");
3157 strcat(buf, appData.icsLogon);
3158 f = fopen(buf, "r");
3162 ProcessICSInitScript(f);
3169 EditCommentPopDown();
3180 SetMenuEnables(enab)
3184 if (!menuBarWidget) return;
3185 while (enab->name != NULL) {
3186 w = XtNameToWidget(menuBarWidget, enab->name);
3188 DisplayError(enab->name, 0);
3190 XtSetSensitive(w, enab->value);
3196 Enables icsEnables[] = {
3197 { "menuFile.Mail Move", False },
3198 { "menuFile.Reload CMail Message", False },
3199 { "menuMode.Machine Black", False },
3200 { "menuMode.Machine White", False },
3201 { "menuMode.Analysis Mode", False },
3202 { "menuMode.Analyze File", False },
3203 { "menuMode.Two Machines", False },
3205 { "menuHelp.Hint", False },
3206 { "menuHelp.Book", False },
3207 { "menuStep.Move Now", False },
3208 { "menuOptions.Periodic Updates", False },
3209 { "menuOptions.Hide Thinking", False },
3210 { "menuOptions.Ponder Next Move", False },
3215 Enables ncpEnables[] = {
3216 { "menuFile.Mail Move", False },
3217 { "menuFile.Reload CMail Message", False },
3218 { "menuMode.Machine White", False },
3219 { "menuMode.Machine Black", False },
3220 { "menuMode.Analysis Mode", False },
3221 { "menuMode.Analyze File", False },
3222 { "menuMode.Two Machines", False },
3223 { "menuMode.ICS Client", False },
3224 { "menuMode.ICS Input Box", False },
3225 { "Action", False },
3226 { "menuStep.Revert", False },
3227 { "menuStep.Move Now", False },
3228 { "menuStep.Retract Move", False },
3229 { "menuOptions.Auto Comment", False },
3230 { "menuOptions.Auto Flag", False },
3231 { "menuOptions.Auto Flip View", False },
3232 { "menuOptions.Auto Observe", False },
3233 { "menuOptions.Auto Raise Board", False },
3234 { "menuOptions.Get Move List", False },
3235 { "menuOptions.ICS Alarm", False },
3236 { "menuOptions.Move Sound", False },
3237 { "menuOptions.Quiet Play", False },
3238 { "menuOptions.Hide Thinking", False },
3239 { "menuOptions.Periodic Updates", False },
3240 { "menuOptions.Ponder Next Move", False },
3241 { "menuHelp.Hint", False },
3242 { "menuHelp.Book", False },
3246 Enables gnuEnables[] = {
3247 { "menuMode.ICS Client", False },
3248 { "menuMode.ICS Input Box", False },
3249 { "menuAction.Accept", False },
3250 { "menuAction.Decline", False },
3251 { "menuAction.Rematch", False },
3252 { "menuAction.Adjourn", False },
3253 { "menuAction.Stop Examining", False },
3254 { "menuAction.Stop Observing", False },
3255 { "menuStep.Revert", False },
3256 { "menuOptions.Auto Comment", False },
3257 { "menuOptions.Auto Observe", False },
3258 { "menuOptions.Auto Raise Board", False },
3259 { "menuOptions.Get Move List", False },
3260 { "menuOptions.Premove", False },
3261 { "menuOptions.Quiet Play", False },
3263 /* The next two options rely on SetCmailMode being called *after* */
3264 /* SetGNUMode so that when GNU is being used to give hints these */
3265 /* menu options are still available */
3267 { "menuFile.Mail Move", False },
3268 { "menuFile.Reload CMail Message", False },
3272 Enables cmailEnables[] = {
3274 { "menuAction.Call Flag", False },
3275 { "menuAction.Draw", True },
3276 { "menuAction.Adjourn", False },
3277 { "menuAction.Abort", False },
3278 { "menuAction.Stop Observing", False },
3279 { "menuAction.Stop Examining", False },
3280 { "menuFile.Mail Move", True },
3281 { "menuFile.Reload CMail Message", True },
3285 Enables trainingOnEnables[] = {
3286 { "menuMode.Edit Comment", False },
3287 { "menuMode.Pause", False },
3288 { "menuStep.Forward", False },
3289 { "menuStep.Backward", False },
3290 { "menuStep.Forward to End", False },
3291 { "menuStep.Back to Start", False },
3292 { "menuStep.Move Now", False },
3293 { "menuStep.Truncate Game", False },
3297 Enables trainingOffEnables[] = {
3298 { "menuMode.Edit Comment", True },
3299 { "menuMode.Pause", True },
3300 { "menuStep.Forward", True },
3301 { "menuStep.Backward", True },
3302 { "menuStep.Forward to End", True },
3303 { "menuStep.Back to Start", True },
3304 { "menuStep.Move Now", True },
3305 { "menuStep.Truncate Game", True },
3309 Enables machineThinkingEnables[] = {
3310 { "menuFile.Load Game", False },
3311 { "menuFile.Load Next Game", False },
3312 { "menuFile.Load Previous Game", False },
3313 { "menuFile.Reload Same Game", False },
3314 { "menuFile.Paste Game", False },
3315 { "menuFile.Load Position", False },
3316 { "menuFile.Load Next Position", False },
3317 { "menuFile.Load Previous Position", False },
3318 { "menuFile.Reload Same Position", False },
3319 { "menuFile.Paste Position", False },
3320 { "menuMode.Machine White", False },
3321 { "menuMode.Machine Black", False },
3322 { "menuMode.Two Machines", False },
3323 { "menuStep.Retract Move", False },
3327 Enables userThinkingEnables[] = {
3328 { "menuFile.Load Game", True },
3329 { "menuFile.Load Next Game", True },
3330 { "menuFile.Load Previous Game", True },
3331 { "menuFile.Reload Same Game", True },
3332 { "menuFile.Paste Game", True },
3333 { "menuFile.Load Position", True },
3334 { "menuFile.Load Next Position", True },
3335 { "menuFile.Load Previous Position", True },
3336 { "menuFile.Reload Same Position", True },
3337 { "menuFile.Paste Position", True },
3338 { "menuMode.Machine White", True },
3339 { "menuMode.Machine Black", True },
3340 { "menuMode.Two Machines", True },
3341 { "menuStep.Retract Move", True },
3347 SetMenuEnables(icsEnables);
3350 if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
3351 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
3358 SetMenuEnables(ncpEnables);
3364 SetMenuEnables(gnuEnables);
3370 SetMenuEnables(cmailEnables);
3376 SetMenuEnables(trainingOnEnables);
3377 if (appData.showButtonBar) {
3378 XtSetSensitive(buttonBarWidget, False);
3384 SetTrainingModeOff()
3386 SetMenuEnables(trainingOffEnables);
3387 if (appData.showButtonBar) {
3388 XtSetSensitive(buttonBarWidget, True);
3393 SetUserThinkingEnables()
3395 if (appData.noChessProgram) return;
3396 SetMenuEnables(userThinkingEnables);
3400 SetMachineThinkingEnables()
3402 if (appData.noChessProgram) return;
3403 SetMenuEnables(machineThinkingEnables);
3405 case MachinePlaysBlack:
3406 case MachinePlaysWhite:
3407 case TwoMachinesPlay:
3408 XtSetSensitive(XtNameToWidget(menuBarWidget,
3409 ModeToWidgetName(gameMode)), True);
3416 #define Abs(n) ((n)<0 ? -(n) : (n))
3419 * Find a font that matches "pattern" that is as close as
3420 * possible to the targetPxlSize. Prefer fonts that are k
3421 * pixels smaller to fonts that are k pixels larger. The
3422 * pattern must be in the X Consortium standard format,
3423 * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
3424 * The return value should be freed with XtFree when no
3427 char *FindFont(pattern, targetPxlSize)
3431 char **fonts, *p, *best, *scalable, *scalableTail;
3432 int i, j, nfonts, minerr, err, pxlSize;
3435 char **missing_list;
3437 char *def_string, *base_fnt_lst, strInt[3];
3439 XFontStruct **fnt_list;
3441 base_fnt_lst = calloc(1, strlen(pattern) + 3);
3442 sprintf(strInt, "%d", targetPxlSize);
3443 p = strstr(pattern, "--");
3444 strncpy(base_fnt_lst, pattern, p - pattern + 2);
3445 strcat(base_fnt_lst, strInt);
3446 strcat(base_fnt_lst, strchr(p + 2, '-'));
3448 if ((fntSet = XCreateFontSet(xDisplay,
3452 &def_string)) == NULL) {
3454 fprintf(stderr, _("Unable to create font set.\n"));
3458 nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
3460 fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
3462 fprintf(stderr, _("%s: no fonts match pattern %s\n"),
3463 programName, pattern);
3471 for (i=0; i<nfonts; i++) {
3474 if (*p != '-') continue;
3476 if (*p == NULLCHAR) break;
3477 if (*p++ == '-') j++;
3479 if (j < 7) continue;
3482 scalable = fonts[i];
3485 err = pxlSize - targetPxlSize;
3486 if (Abs(err) < Abs(minerr) ||
3487 (minerr > 0 && err < 0 && -err == minerr)) {
3493 if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
3494 /* If the error is too big and there is a scalable font,
3495 use the scalable font. */
3496 int headlen = scalableTail - scalable;
3497 p = (char *) XtMalloc(strlen(scalable) + 10);
3498 while (isdigit(*scalableTail)) scalableTail++;
3499 sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
3501 p = (char *) XtMalloc(strlen(best) + 1);
3504 if (appData.debugMode) {
3505 fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
3506 pattern, targetPxlSize, p);
3509 if (missing_count > 0)
3510 XFreeStringList(missing_list);
3511 XFreeFontSet(xDisplay, fntSet);
3513 XFreeFontNames(fonts);
3520 XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
3521 | GCBackground | GCFunction | GCPlaneMask;
3522 XGCValues gc_values;
3525 gc_values.plane_mask = AllPlanes;
3526 gc_values.line_width = lineGap;
3527 gc_values.line_style = LineSolid;
3528 gc_values.function = GXcopy;
3530 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3531 gc_values.background = XBlackPixel(xDisplay, xScreen);
3532 lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3534 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3535 gc_values.background = XWhitePixel(xDisplay, xScreen);
3536 coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
3537 XSetFont(xDisplay, coordGC, coordFontID);
3539 // [HGM] make font for holdings counts (white on black0
3540 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3541 gc_values.background = XBlackPixel(xDisplay, xScreen);
3542 countGC = XtGetGC(shellWidget, value_mask, &gc_values);
3543 XSetFont(xDisplay, countGC, countFontID);
3545 if (appData.monoMode) {
3546 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3547 gc_values.background = XWhitePixel(xDisplay, xScreen);
3548 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3550 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3551 gc_values.background = XBlackPixel(xDisplay, xScreen);
3552 lightSquareGC = wbPieceGC
3553 = XtGetGC(shellWidget, value_mask, &gc_values);
3555 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3556 gc_values.background = XWhitePixel(xDisplay, xScreen);
3557 darkSquareGC = bwPieceGC
3558 = XtGetGC(shellWidget, value_mask, &gc_values);
3560 if (DefaultDepth(xDisplay, xScreen) == 1) {
3561 /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
3562 gc_values.function = GXcopyInverted;
3563 copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);
3564 gc_values.function = GXcopy;
3565 if (XBlackPixel(xDisplay, xScreen) == 1) {
3566 bwPieceGC = darkSquareGC;
3567 wbPieceGC = copyInvertedGC;
3569 bwPieceGC = copyInvertedGC;
3570 wbPieceGC = lightSquareGC;
3574 gc_values.foreground = highlightSquareColor;
3575 gc_values.background = highlightSquareColor;
3576 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3578 gc_values.foreground = premoveHighlightColor;
3579 gc_values.background = premoveHighlightColor;
3580 prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3582 gc_values.foreground = lightSquareColor;
3583 gc_values.background = darkSquareColor;
3584 lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3586 gc_values.foreground = darkSquareColor;
3587 gc_values.background = lightSquareColor;
3588 darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3590 gc_values.foreground = jailSquareColor;
3591 gc_values.background = jailSquareColor;
3592 jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3594 gc_values.foreground = whitePieceColor;
3595 gc_values.background = darkSquareColor;
3596 wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3598 gc_values.foreground = whitePieceColor;
3599 gc_values.background = lightSquareColor;
3600 wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3602 gc_values.foreground = whitePieceColor;
3603 gc_values.background = jailSquareColor;
3604 wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3606 gc_values.foreground = blackPieceColor;
3607 gc_values.background = darkSquareColor;
3608 bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3610 gc_values.foreground = blackPieceColor;
3611 gc_values.background = lightSquareColor;
3612 blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3614 gc_values.foreground = blackPieceColor;
3615 gc_values.background = jailSquareColor;
3616 bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3620 void loadXIM(xim, xmask, filename, dest, mask)
3633 fp = fopen(filename, "rb");
3635 fprintf(stderr, _("%s: error loading XIM!\n"), programName);
3642 for (y=0; y<h; ++y) {
3643 for (x=0; x<h; ++x) {
3648 XPutPixel(xim, x, y, blackPieceColor);
3650 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3653 XPutPixel(xim, x, y, darkSquareColor);
3655 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3658 XPutPixel(xim, x, y, whitePieceColor);
3660 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3663 XPutPixel(xim, x, y, lightSquareColor);
3665 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3671 /* create Pixmap of piece */
3672 *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3674 XPutImage(xDisplay, *dest, lightSquareGC, xim,
3677 /* create Pixmap of clipmask
3678 Note: We assume the white/black pieces have the same
3679 outline, so we make only 6 masks. This is okay
3680 since the XPM clipmask routines do the same. */
3682 temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3684 XPutImage(xDisplay, temp, lightSquareGC, xmask,
3687 /* now create the 1-bit version */
3688 *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3691 values.foreground = 1;
3692 values.background = 0;
3694 /* Don't use XtGetGC, not read only */
3695 maskGC = XCreateGC(xDisplay, *mask,
3696 GCForeground | GCBackground, &values);
3697 XCopyPlane(xDisplay, temp, *mask, maskGC,
3698 0, 0, squareSize, squareSize, 0, 0, 1);
3699 XFreePixmap(xDisplay, temp);
3703 void CreateXIMPieces()
3708 static char *ximkind[] = { "ll", "ld", "dl", "dd" };
3713 /* The XSynchronize calls were copied from CreatePieces.
3714 Not sure if needed, but can't hurt */
3715 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3718 /* temp needed by loadXIM() */
3719 ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3720 0, 0, ss, ss, AllPlanes, XYPixmap);
3722 if (strlen(appData.pixmapDirectory) == 0) {
3726 if (appData.monoMode) {
3727 DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
3731 fprintf(stderr, _("\nLoading XIMs...\n"));
3733 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3734 fprintf(stderr, "%d", piece+1);
3735 for (kind=0; kind<4; kind++) {
3736 fprintf(stderr, ".");
3737 snprintf(buf, sizeof(buf), "%s/%c%s%u.xim",
3738 ExpandPathName(appData.pixmapDirectory),
3739 ToLower(PieceToChar((ChessSquare)piece)),
3741 ximPieceBitmap[kind][piece] =
3742 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3743 0, 0, ss, ss, AllPlanes, XYPixmap);
3744 if (appData.debugMode)
3745 fprintf(stderr, _("(File:%s:) "), buf);
3746 loadXIM(ximPieceBitmap[kind][piece],
3748 &(xpmPieceBitmap[kind][piece]),
3749 &(ximMaskPm[piece%(int)BlackPawn]));
3751 fprintf(stderr," ");
3753 /* Load light and dark squares */
3754 /* If the LSQ and DSQ pieces don't exist, we will
3755 draw them with solid squares. */
3756 snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
3757 if (access(buf, 0) != 0) {
3761 fprintf(stderr, _("light square "));
3763 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3764 0, 0, ss, ss, AllPlanes, XYPixmap);
3765 if (appData.debugMode)
3766 fprintf(stderr, _("(File:%s:) "), buf);
3768 loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
3769 fprintf(stderr, _("dark square "));
3770 snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
3771 ExpandPathName(appData.pixmapDirectory), ss);
3772 if (appData.debugMode)
3773 fprintf(stderr, _("(File:%s:) "), buf);
3775 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3776 0, 0, ss, ss, AllPlanes, XYPixmap);
3777 loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
3778 xpmJailSquare = xpmLightSquare;
3780 fprintf(stderr, _("Done.\n"));
3782 XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
3786 void CreateXPMPieces()
3790 u_int ss = squareSize;
3792 static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
3793 XpmColorSymbol symbols[4];
3796 /* Apparently some versions of Xpm don't define XpmFormat at all --tpm */
3797 if (appData.debugMode) {
3798 fprintf(stderr, "XPM Library Version: %d.%d%c\n",
3799 XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));
3803 /* The XSynchronize calls were copied from CreatePieces.
3804 Not sure if needed, but can't hurt */
3805 XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
3807 /* Setup translations so piece colors match square colors */
3808 symbols[0].name = "light_piece";
3809 symbols[0].value = appData.whitePieceColor;
3810 symbols[1].name = "dark_piece";
3811 symbols[1].value = appData.blackPieceColor;
3812 symbols[2].name = "light_square";
3813 symbols[2].value = appData.lightSquareColor;
3814 symbols[3].name = "dark_square";
3815 symbols[3].value = appData.darkSquareColor;
3817 attr.valuemask = XpmColorSymbols;
3818 attr.colorsymbols = symbols;
3819 attr.numsymbols = 4;
3821 if (appData.monoMode) {
3822 DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
3826 if (strlen(appData.pixmapDirectory) == 0) {
3827 XpmPieces* pieces = builtInXpms;
3830 while (pieces->size != squareSize && pieces->size) pieces++;
3831 if (!pieces->size) {
3832 fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
3835 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3836 for (kind=0; kind<4; kind++) {
3838 if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
3839 pieces->xpm[piece][kind],
3840 &(xpmPieceBitmap[kind][piece]),
3841 NULL, &attr)) != 0) {
3842 fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
3849 xpmJailSquare = xpmLightSquare;
3853 fprintf(stderr, _("\nLoading XPMs...\n"));
3856 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3857 fprintf(stderr, "%d ", piece+1);
3858 for (kind=0; kind<4; kind++) {
3859 snprintf(buf, sizeof(buf), "%s/%c%s%u.xpm",
3860 ExpandPathName(appData.pixmapDirectory),
3861 ToLower(PieceToChar((ChessSquare)piece)),
3863 if (appData.debugMode) {
3864 fprintf(stderr, _("(File:%s:) "), buf);
3866 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3867 &(xpmPieceBitmap[kind][piece]),
3868 NULL, &attr)) != 0) {
3869 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
3875 /* Load light and dark squares */
3876 /* If the LSQ and DSQ pieces don't exist, we will
3877 draw them with solid squares. */
3878 fprintf(stderr, _("light square "));
3879 snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
3880 if (access(buf, 0) != 0) {
3884 if (appData.debugMode)
3885 fprintf(stderr, _("(File:%s:) "), buf);
3887 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3888 &xpmLightSquare, NULL, &attr)) != 0) {
3889 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3892 fprintf(stderr, _("dark square "));
3893 snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
3894 ExpandPathName(appData.pixmapDirectory), ss);
3895 if (appData.debugMode) {
3896 fprintf(stderr, _("(File:%s:) "), buf);
3898 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3899 &xpmDarkSquare, NULL, &attr)) != 0) {
3900 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3904 xpmJailSquare = xpmLightSquare;
3905 fprintf(stderr, _("Done.\n"));
3907 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3910 #endif /* HAVE_LIBXPM */
3913 /* No built-in bitmaps */
3918 u_int ss = squareSize;
3920 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3923 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
3924 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3925 sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
3926 ss, kind == SOLID ? 's' : 'o');
3927 ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);
3931 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3935 /* With built-in bitmaps */
3938 BuiltInBits* bib = builtInBits;
3941 u_int ss = squareSize;
3943 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3946 while (bib->squareSize != ss && bib->squareSize != 0) bib++;
3948 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
3949 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3950 sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
3951 ss, kind == SOLID ? 's' : 'o');
3952 ReadBitmap(&pieceBitmap[kind][piece], buf,
3953 bib->bits[kind][piece], ss, ss);
3957 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3962 void ReadBitmap(pm, name, bits, wreq, hreq)
3965 unsigned char bits[];
3971 char msg[MSG_SIZ], fullname[MSG_SIZ];
3973 if (*appData.bitmapDirectory != NULLCHAR) {
3974 strcpy(fullname, appData.bitmapDirectory);
3975 strcat(fullname, "/");
3976 strcat(fullname, name);
3977 errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
3978 &w, &h, pm, &x_hot, &y_hot);
3979 if (errcode != BitmapSuccess) {
3981 case BitmapOpenFailed:
3982 snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
3984 case BitmapFileInvalid:
3985 snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
3987 case BitmapNoMemory:
3988 snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
3992 snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
3996 fprintf(stderr, _("%s: %s...using built-in\n"),
3998 } else if (w != wreq || h != hreq) {
4000 _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
4001 programName, fullname, w, h, wreq, hreq);
4008 fprintf(stderr, _("%s: No built-in bitmap for %s; giving up\n"),
4012 ; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
4014 *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
4023 if (lineGap == 0) return;
4025 /* [HR] Split this into 2 loops for non-square boards. */
4027 for (i = 0; i < BOARD_HEIGHT + 1; i++) {
4028 gridSegments[i].x1 = 0;
4029 gridSegments[i].x2 =
4030 lineGap + BOARD_WIDTH * (squareSize + lineGap);
4031 gridSegments[i].y1 = gridSegments[i].y2
4032 = lineGap / 2 + (i * (squareSize + lineGap));
4035 for (j = 0; j < BOARD_WIDTH + 1; j++) {
4036 gridSegments[j + i].y1 = 0;
4037 gridSegments[j + i].y2 =
4038 lineGap + BOARD_HEIGHT * (squareSize + lineGap);
4039 gridSegments[j + i].x1 = gridSegments[j + i].x2
4040 = lineGap / 2 + (j * (squareSize + lineGap));
4044 static void MenuBarSelect(w, addr, index)
4049 XtActionProc proc = (XtActionProc) addr;
4051 (proc)(NULL, NULL, NULL, NULL);
4054 void CreateMenuBarPopup(parent, name, mb)
4064 menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
4067 XtSetArg(args[j], XtNleftMargin, 20); j++;
4068 XtSetArg(args[j], XtNrightMargin, 20); j++;
4070 while (mi->string != NULL) {
4071 if (strcmp(mi->string, "----") == 0) {
4072 entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
4075 XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
4076 entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
4078 XtAddCallback(entry, XtNcallback,
4079 (XtCallbackProc) MenuBarSelect,
4080 (caddr_t) mi->proc);
4086 Widget CreateMenuBar(mb)
4090 Widget anchor, menuBar;
4092 char menuName[MSG_SIZ];
4095 XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
4096 XtSetArg(args[j], XtNvSpace, 0); j++;
4097 XtSetArg(args[j], XtNborderWidth, 0); j++;
4098 menuBar = XtCreateWidget("menuBar", boxWidgetClass,
4099 formWidget, args, j);
4101 while (mb->name != NULL) {
4102 strcpy(menuName, "menu");
4103 strcat(menuName, mb->name);
4105 XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;