xboard.c

   1 /*
   2  * xboard.c -- X front end for XBoard
   3  * $Id: xboard.c,v 2.2 2003/11/06 07:22:14 mann Exp $
   4  *
   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
   8  * Foundation, Inc.
   9  *
  10  * The following terms apply to Digital Equipment Corporation's copyright
  11  * interest in XBoard:
  12  * ------------------------------------------------------------------------
  13  * All Rights Reserved
  14  *
  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.
  22  *
  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
  29  * SOFTWARE.
  30  * ------------------------------------------------------------------------
  31  *
  32  * The following terms apply to the enhanced version of XBoard
  33  * distributed by the Free Software Foundation:
  34  * ------------------------------------------------------------------------
  35  *
  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.
  40  *
  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.
  45  *
  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/.  *
  48  *
  49  *------------------------------------------------------------------------
  50  ** See the file ChangeLog for a revision history.  */
  51
  52 #include "config.h"
  53
  54 #include <stdio.h>
  55 #include <ctype.h>
  56 #include <signal.h>
  57 #include <errno.h>
  58 #include <sys/types.h>
  59 #include <sys/stat.h>
  60 #include <pwd.h>
  61
  62 #if !OMIT_SOCKETS
  63 # if HAVE_SYS_SOCKET_H
  64 #  include <sys/socket.h>
  65 #  include <netinet/in.h>
  66 #  include <netdb.h>
  67 # else /* not HAVE_SYS_SOCKET_H */
  68 #  if HAVE_LAN_SOCKET_H
  69 #   include <lan/socket.h>
  70 #   include <lan/in.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 */
  77
  78 #if STDC_HEADERS
  79 # include <stdlib.h>
  80 # include <string.h>
  81 #else /* not STDC_HEADERS */
  82 extern char *getenv();
  83 # if HAVE_STRING_H
  84 #  include <string.h>
  85 # else /* not HAVE_STRING_H */
  86 #  include <strings.h>
  87 # endif /* not HAVE_STRING_H */
  88 #endif /* not STDC_HEADERS */
  89
  90 #if HAVE_SYS_FCNTL_H
  91 # include <sys/fcntl.h>
  92 #else /* not HAVE_SYS_FCNTL_H */
  93 # if HAVE_FCNTL_H
  94 #  include <fcntl.h>
  95 # endif /* HAVE_FCNTL_H */
  96 #endif /* not HAVE_SYS_FCNTL_H */
  97
  98 #if HAVE_SYS_SYSTEMINFO_H
  99 # include <sys/systeminfo.h>
 100 #endif /* HAVE_SYS_SYSTEMINFO_H */
 101
 102 #if TIME_WITH_SYS_TIME
 103 # include <sys/time.h>
 104 # include <time.h>
 105 #else
 106 # if HAVE_SYS_TIME_H
 107 #  include <sys/time.h>
 108 # else
 109 #  include <time.h>
 110 # endif
 111 #endif
 112
 113 #if HAVE_UNISTD_H
 114 # include <unistd.h>
 115 #endif
 116
 117 #if HAVE_SYS_WAIT_H
 118 # include <sys/wait.h>
 119 #endif
 120
 121 #if HAVE_DIRENT_H
 122 # include <dirent.h>
 123 # define NAMLEN(dirent) strlen((dirent)->d_name)
 124 # define HAVE_DIR_STRUCT
 125 #else
 126 # define dirent direct
 127 # define NAMLEN(dirent) (dirent)->d_namlen
 128 # if HAVE_SYS_NDIR_H
 129 #  include <sys/ndir.h>
 130 #  define HAVE_DIR_STRUCT
 131 # endif
 132 # if HAVE_SYS_DIR_H
 133 #  include <sys/dir.h>
 134 #  define HAVE_DIR_STRUCT
 135 # endif
 136 # if HAVE_NDIR_H
 137 #  include <ndir.h>
 138 #  define HAVE_DIR_STRUCT
 139 # endif
 140 #endif
 141
 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>
 147 #if USE_XAW3D
 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>
 159 #else
 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>
 171 #endif
 172
 173 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
 174 #include "common.h"
 175
 176 #if HAVE_LIBXPM
 177 #include <X11/xpm.h>
 178 #include "pixmaps/pixmaps.h"
 179 #define IMAGE_EXT "xpm"
 180 #else
 181 #define IMAGE_EXT "xim"
 182 #include "bitmaps/bitmaps.h"
 183 #endif
 184
 185 #include "bitmaps/icon_white.bm"
 186 #include "bitmaps/icon_black.bm"
 187 #include "bitmaps/checkmark.bm"
 188
 189 #include "frontend.h"
 190 #include "backend.h"
 191 #include "moves.h"
 192 #include "xboard.h"
 193 #include "childio.h"
 194 #include "xgamelist.h"
 195 #include "xhistory.h"
 196 #include "xedittags.h"
 197 #include "gettext.h"
 198
 199 // must be moved to xengineoutput.h
 200
 201 void EngineOutputProc P((Widget w, XEvent *event,
 202  String *prms, Cardinal *nprms));
 203
 204 void EngineOutputPopDown();
 205
 206
 207 #ifdef __EMX__
 208 #ifndef HAVE_USLEEP
 209 #define HAVE_USLEEP
 210 #endif
 211 #define usleep(t)   _sleep2(((t)+500)/1000)
 212 #endif
 213
 214 #ifdef ENABLE_NLS
 215 # define  _(s) gettext (s)
 216 # define N_(s) gettext_noop (s)
 217 #else
 218 # define  _(s) (s)
 219 # define N_(s)  s
 220 #endif
 221
 222 typedef struct {
 223     String string;
 224     XtActionProc proc;
 225 } MenuItem;
 226
 227 typedef struct {
 228     String name;
 229     MenuItem *mi;
 230 } Menu;
 231
 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,
 264                      Board board));
 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,
 294                          Cardinal *nprms));
 295 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
 296                          Cardinal *nprms));
 297 void ReloadGameProc P((Widget w, XEvent *event, String *prms,
 298                        Cardinal *nprms));
 299 void LoadPositionProc P((Widget w, XEvent *event,
 300                          String *prms, Cardinal *nprms));
 301 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
 302                          Cardinal *nprms));
 303 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
 304                          Cardinal *nprms));
 305 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
 306                        Cardinal *nprms));
 307 void CopyPositionProc P((Widget w, XEvent *event, String *prms,
 308                          Cardinal *nprms));
 309 void PastePositionProc P((Widget w, XEvent *event, String *prms,
 310                           Cardinal *nprms));
 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,
 318                             Cardinal *nprms));
 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,
 322                          Cardinal *nprms));
 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,
 330                         Cardinal *nprms));
 331 void IcsClientProc P((Widget w, XEvent *event, String *prms,
 332                       Cardinal *nprms));
 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,
 354                           Cardinal *nprms));
 355 void StopExaminingProc P((Widget w, XEvent *event, String *prms,
 356                           Cardinal *nprms));
 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,
 363                          Cardinal *nprms));
 364 void RetractMoveProc P((Widget w, XEvent *event, String *prms,
 365                         Cardinal *nprms));
 366 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 367 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
 368                         Cardinal *nprms));
 369 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
 370                          Cardinal *nprms));
 371 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
 372                          Cardinal *nprms));
 373 void AutocommProc P((Widget w, XEvent *event, String *prms,
 374                      Cardinal *nprms));
 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,
 378                         Cardinal *nprms));
 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,
 383                        Cardinal *nprms));
 384 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 385 void GetMoveListProc P((Widget w, XEvent *event, String *prms,
 386                         Cardinal *nprms));
 387 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
 388                               Cardinal *nprms));
 389 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
 390                               Cardinal *nprms));
 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,
 394                          Cardinal *nprms));
 395 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
 396                          Cardinal *nprms));
 397 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
 398                            Cardinal *nprms));
 399 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
 400                         Cardinal *nprms));
 401 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
 402                              Cardinal *nprms));
 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,
 406                        Cardinal *nprms));
 407 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
 408                          Cardinal *nprms));
 409 void HideThinkingProc P((Widget w, XEvent *event, String *prms,
 410                          Cardinal *nprms));
 411 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
 412                           Cardinal *nprms));
 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(());
 449 /*
 450 * XBoard depends on Xt R4 or higher
 451 */
 452 int xtVersion = XtSpecificationRelease;
 453
 454 int xScreen;
 455 Display *xDisplay;
 456 Window xBoardWindow;
 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;
 474 char *layoutName;
 475 char *oldICSInteractionTitle;
 476
 477 FileProc fileProc;
 478 char *fileOpenMode;
 479 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
 480
 481 Position commentX = -1, commentY = -1;
 482 Dimension commentW, commentH;
 483
 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;
 494
 495 #define SOLID 0
 496 #define OUTLINE 1
 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;
 504 XImage *xim_Cross;
 505
 506 #define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % (int)BlackPawn]
 507 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % (int)BlackPawn]
 508
 509 #define White(piece) ((int)(piece) < (int)BlackPawn)
 510
 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.       */
 514
 515 typedef struct {
 516         Pixmap  saveBuf;
 517         Pixmap  newBuf;
 518         GC      blitGC, pieceGC, outlineGC;
 519         XPoint  startSquare, prevFrame, mouseDelta;
 520         int     startColor;
 521         int     dragPiece;
 522         Boolean dragActive;
 523         int     startBoardX, startBoardY;
 524     } AnimState;
 525
 526 /* There can be two pieces being animated at once: a player
 527    can begin dragging a piece before the remote opponent has moved. */
 528
 529 static AnimState game, player;
 530
 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];
 534
 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.  */
 538 #define kFactor    4
 539
 540 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
 541
 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},
 569     {NULL, NULL}
 570 };
 571
 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},
 592     {NULL, NULL}
 593 };
 594
 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},
 612     {NULL, NULL}
 613 };
 614
 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},
 625     {NULL, NULL}
 626 };
 627
 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},
 649 #if HIGHDRAG
 650     {N_("Highlight Dragging"), HighlightDraggingProc},
 651 #endif
 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},
 665     {NULL, NULL}
 666 };
 667
 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},
 676     {NULL, NULL}
 677 };
 678
 679 Menu menuBar[] = {
 680     {N_("File"), fileMenu},
 681     {N_("Mode"), modeMenu},
 682     {N_("Action"), actionMenu},
 683     {N_("Step"), stepMenu},
 684     {N_("Options"), optionsMenu},
 685     {N_("Help"), helpMenu},
 686     {NULL, NULL}
 687 };
 688
 689 #define PAUSE_BUTTON N_("P")
 690 MenuItem buttonBar[] = {
 691     {"<<", ToStartProc},
 692     {"<", BackwardProc},
 693     {PAUSE_BUTTON, PauseProc},
 694     {">", ForwardProc},
 695     {">>", ToEndProc},
 696     {NULL, NULL}
 697 };
 698
 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") },
 705 };
 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 },
 714 };
 715
 716 #define DROP_MENU_SIZE 6
 717 String dropMenuStrings[DROP_MENU_SIZE] = {
 718     "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
 719   };
 720 /* must be in same order as PieceMenuStrings! */
 721 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
 722     (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
 723     WhiteRook, WhiteQueen
 724 };
 725
 726 typedef struct {
 727     char piece;
 728     char* widget;
 729 } DropMenuEnables;
 730
 731 DropMenuEnables dmEnables[] = {
 732     { 'P', "Pawn" },
 733     { 'N', "Knight" },
 734     { 'B', "Bishop" },
 735     { 'R', "Rook" },
 736     { 'Q', "Queen" }
 737 };
 738
 739 Arg shellArgs[] = {
 740     { XtNwidth, 0 },
 741     { XtNheight, 0 },
 742     { XtNminWidth, 0 },
 743     { XtNminHeight, 0 },
 744     { XtNmaxWidth, 0 },
 745     { XtNmaxHeight, 0 }
 746 };
 747
 748 Arg layoutArgs[] = {
 749     { XtNborderWidth, 0 },
 750     { XtNdefaultDistance, 0 },
 751 };
 752
 753 Arg formArgs[] = {
 754     { XtNborderWidth, 0 },
 755     { XtNresizable, (XtArgVal) True },
 756 };
 757
 758 Arg boardArgs[] = {
 759     { XtNborderWidth, 0 },
 760     { XtNwidth, 0 },
 761     { XtNheight, 0 }
 762 };
 763
 764 Arg titleArgs[] = {
 765     { XtNjustify, (XtArgVal) XtJustifyRight },
 766     { XtNlabel, (XtArgVal) "..." },
 767     { XtNresizable, (XtArgVal) True },
 768     { XtNresize, (XtArgVal) False }
 769 };
 770
 771 Arg messageArgs[] = {
 772     { XtNjustify, (XtArgVal) XtJustifyLeft },
 773     { XtNlabel, (XtArgVal) "..." },
 774     { XtNresizable, (XtArgVal) True },
 775     { XtNresize, (XtArgVal) False }
 776 };
 777
 778 Arg timerArgs[] = {
 779     { XtNborderWidth, 0 },
 780     { XtNjustify, (XtArgVal) XtJustifyLeft }
 781 };
 782
 783 XtResource clientResources[] = {
 784     { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
 785         XtOffset(AppDataPtr, whitePieceColor), XtRString,
 786         WHITE_PIECE_COLOR },
 787     { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
 788         XtOffset(AppDataPtr, blackPieceColor), XtRString,
 789         BLACK_PIECE_COLOR },
 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,
 795         DARK_SQUARE_COLOR },
 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,
 814       COMPUTER_STRING },
 815     { "secondComputerString", "secondComputerString", XtRString,
 816         sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
 817       COMPUTER_STRING },
 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),
 840         XtRString, "" },
 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,
 854         (XtPointer) False },
 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,
 866         ICS_COMM_PORT },
 867     { "internetChessServerLogonScript", "internetChessServerLogonScript",
 868         XtRString, sizeof(String),
 869         XtOffset(AppDataPtr, icsLogon), XtRString,
 870         ICS_LOGON },
 871     { "internetChessServerHelper", "internetChessServerHelper",
 872         XtRString, sizeof(String),
 873         XtOffset(AppDataPtr, icsHelper), XtRString, "" },
 874     { "internetChessServerInputBox", "internetChessServerInputBox",
 875         XtRBoolean, sizeof(Boolean),
 876         XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
 877         (XtPointer) False },
 878     { "icsAlarm", "icsAlarm",
 879         XtRBoolean, sizeof(Boolean),
 880         XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
 881         (XtPointer) True },
 882     { "icsAlarmTime", "icsAlarmTime",
 883         XtRInt, sizeof(int),
 884         XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
 885         (XtPointer) 5000 },
 886     { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
 887         XtOffset(AppDataPtr, useTelnet), XtRImmediate,
 888         (XtPointer) False },
 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",
 896         XtRInt, sizeof(int),
 897         XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
 898         (XtPointer) 0 },
 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),
 912         XtRString, "" },
 913     { "loadPositionIndex", "loadPositionIndex",
 914         XtRInt, sizeof(int),
 915         XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
 916         (XtPointer) 1 },
 917     { "savePositionFile", "savePositionFile", XtRString,
 918         sizeof(String), XtOffset(AppDataPtr, savePositionFile),
 919         XtRString, "" },
 920     { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
 921         XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
 922     { "matchGames", "matchGames", XtRInt, sizeof(int),
 923         XtOffset(AppDataPtr, matchGames), XtRImmediate,
 924         (XtPointer) 0 },
 925     { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
 926         XtOffset(AppDataPtr, monoMode), XtRImmediate,
 927         (XtPointer) False },
 928     { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
 929         XtOffset(AppDataPtr, debugMode), XtRImmediate,
 930         (XtPointer) False },
 931     { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
 932         XtOffset(AppDataPtr, clockMode), XtRImmediate,
 933         (XtPointer) True },
 934     { "boardSize", "boardSize", XtRString, sizeof(String),
 935         XtOffset(AppDataPtr, boardSize), XtRString, "" },
 936     { "searchTime", "searchTime", XtRString, sizeof(String),
 937         XtOffset(AppDataPtr, searchTime), XtRString,
 938         (XtPointer) "" },
 939     { "searchDepth", "searchDepth", XtRInt, sizeof(int),
 940         XtOffset(AppDataPtr, searchDepth), XtRImmediate,
 941         (XtPointer) 0 },
 942     { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
 943         XtOffset(AppDataPtr, showCoords), XtRImmediate,
 944         (XtPointer) False },
 945     { "showJail", "showJail", XtRInt, sizeof(int),
 946         XtOffset(AppDataPtr, showJail), XtRImmediate,
 947         (XtPointer) 0 },
 948     { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
 949         XtOffset(AppDataPtr, showThinking), XtRImmediate,
 950         (XtPointer) True },
 951     { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
 952         XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
 953         (XtPointer) True },
 954     { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
 955         XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
 956         (XtPointer) True },
 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 },
 982 #if HIGHDRAG
 983     { "highlightDragging", "highlightDragging", XtRBoolean,
 984         sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
 985         XtRImmediate, (XtPointer) False },
 986 #endif
 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 */
1016 #ifdef ZIPPY
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,
1065         (XtPointer) 0 },
1066 #endif
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),
1075         XtRString, "" },
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),
1117       XtRString, "" },
1118     { "soundSShout", "soundSShout", XtRString,
1119       sizeof(String), XtOffset(AppDataPtr, soundSShout),
1120       XtRString, "" },
1121     { "soundChannel1", "soundChannel1", XtRString,
1122       sizeof(String), XtOffset(AppDataPtr, soundChannel1),
1123       XtRString, "" },
1124     { "soundChannel", "soundChannel", XtRString,
1125       sizeof(String), XtOffset(AppDataPtr, soundChannel),
1126       XtRString, "" },
1127     { "soundKibitz", "soundKibitz", XtRString,
1128       sizeof(String), XtOffset(AppDataPtr, soundKibitz),
1129       XtRString, "" },
1130     { "soundTell", "soundTell", XtRString,
1131       sizeof(String), XtOffset(AppDataPtr, soundTell),
1132       XtRString, "" },
1133     { "soundChallenge", "soundChallenge", XtRString,
1134       sizeof(String), XtOffset(AppDataPtr, soundChallenge),
1135       XtRString, "" },
1136     { "soundRequest", "soundRequest", XtRString,
1137       sizeof(String), XtOffset(AppDataPtr, soundRequest),
1138       XtRString, "" },
1139     { "soundSeek", "soundSeek", XtRString,
1140       sizeof(String), XtOffset(AppDataPtr, soundSeek),
1141       XtRString, "" },
1142     { "soundMove", "soundMove", XtRString,
1143       sizeof(String), XtOffset(AppDataPtr, soundMove),
1144       XtRString, "$" },
1145     { "soundIcsWin", "soundIcsWin", XtRString,
1146       sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
1147       XtRString, "" },
1148     { "soundIcsLoss", "soundIcsLoss", XtRString,
1149       sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
1150       XtRString, "" },
1151     { "soundIcsDraw", "soundIcsDraw", XtRString,
1152       sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
1153       XtRString, "" },
1154     { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
1155       sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
1156       XtRString, "" },
1157     { "soundIcsAlarm", "soundIcsAlarm", XtRString,
1158       sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
1159       XtRString, "$" },
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 },
1232
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 },
1354
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},
1392 };
1393
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" },
1514 #if JAIL
1515     { "-showJail", "showJail", XrmoptionSepArg, NULL },
1516     { "-jail", "showJail", XrmoptionNoArg, "1" },
1517     { "-sidejail", "showJail", XrmoptionNoArg, "2" },
1518     { "-xjail", "showJail", XrmoptionNoArg, "0" },
1519 #endif
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" },
1552 #if HIGHDRAG
1553     { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
1554     { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
1555     { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
1556 #endif
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" },
1583 #ifdef ZIPPY
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 },
1615 #endif
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
1711
1712     /* [HGM,HR] User-selectable board size */
1713     { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
1714     { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
1715     { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
1716
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 },
1758 };
1759
1760
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 },
1842 #if HIGHDRAG
1843     { "HighlightDraggingProc", HighlightDraggingProc },
1844 #endif
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 },
1885 };
1886
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";
1912
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";
1925
1926 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
1927 char blackTranslations[] = "<BtnDown>: BlackClock()\n";
1928
1929 char ICSInputTranslations[] =
1930     "<Key>Return: EnterKeyProc() \n";
1931
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()",
1936     NULL
1937   };
1938
1939
1940 /* Max possible square size */
1941 #define MAXSQSIZE 256
1942
1943 static int xpm_avail[MAXSQSIZE];
1944
1945 #ifdef HAVE_DIR_STRUCT
1946
1947 /* Extract piece size from filename */
1948 static int
1949 xpm_getsize(name, len, ext)
1950      char *name;
1951      int len;
1952      char *ext;
1953 {
1954     char *p, *d;
1955     char buf[10];
1956
1957     if (len < 4)
1958       return 0;
1959
1960     if ((p=strchr(name, '.')) == NULL ||
1961         StrCaseCmp(p+1, ext) != 0)
1962       return 0;
1963
1964     p = name + 3;
1965     d = buf;
1966
1967     while (*p && isdigit(*p))
1968       *(d++) = *(p++);
1969
1970     *d = 0;
1971     return atoi(buf);
1972 }
1973
1974 /* Setup xpm_avail */
1975 static int
1976 xpm_getavail(dirname, ext)
1977      char *dirname;
1978      char *ext;
1979 {
1980     DIR *dir;
1981     struct dirent *ent;
1982     int  i;
1983
1984     for (i=0; i<MAXSQSIZE; ++i)
1985       xpm_avail[i] = 0;
1986
1987     if (appData.debugMode)
1988       fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
1989
1990     dir = opendir(dirname);
1991     if (!dir)
1992       {
1993           fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
1994                   programName, dirname);
1995           exit(1);
1996       }
1997
1998     while ((ent=readdir(dir)) != NULL) {
1999         i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
2000         if (i > 0 && i < MAXSQSIZE)
2001           xpm_avail[i] = 1;
2002     }
2003
2004     closedir(dir);
2005
2006     return 0;
2007 }
2008
2009 void
2010 xpm_print_avail(fp, ext)
2011      FILE *fp;
2012      char *ext;
2013 {
2014     int i;
2015
2016     fprintf(fp, _("Available `%s' sizes:\n"), ext);
2017     for (i=1; i<MAXSQSIZE; ++i) {
2018         if (xpm_avail[i])
2019           printf("%d\n", i);
2020     }
2021 }
2022
2023 /* Return XPM piecesize closest to size */
2024 int
2025 xpm_closest_to(dirname, size, ext)
2026      char *dirname;
2027      int size;
2028      char *ext;
2029 {
2030     int i;
2031     int sm_diff = MAXSQSIZE;
2032     int sm_index = 0;
2033     int diff;
2034
2035     xpm_getavail(dirname, ext);
2036
2037     if (appData.debugMode)
2038       xpm_print_avail(stderr, ext);
2039
2040     for (i=1; i<MAXSQSIZE; ++i) {
2041         if (xpm_avail[i]) {
2042             diff = size - i;
2043             diff = (diff<0) ? -diff : diff;
2044             if (diff < sm_diff) {
2045                 sm_diff = diff;
2046                 sm_index = i;
2047             }
2048         }
2049     }
2050
2051     if (!sm_index) {
2052         fprintf(stderr, _("Error: No `%s' files!\n"), ext);
2053         exit(1);
2054     }
2055
2056     return sm_index;
2057 }
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. */
2062 int
2063 xpm_closest_to(dirname, size, ext)
2064      char *dirname;
2065      int size;
2066      char *ext;
2067 {
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"));
2073     return size;
2074 }
2075 #endif /* HAVE_DIR_STRUCT */
2076
2077 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
2078                              "magenta", "cyan", "white" };
2079 typedef struct {
2080     int attr, bg, fg;
2081 } TextColors;
2082 TextColors textColors[(int)NColorClasses];
2083
2084 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
2085 static int
2086 parse_color(str, which)
2087      char *str;
2088      int which;
2089 {
2090     char *p, buf[100], *d;
2091     int i;
2092
2093     if (strlen(str) > 99)       /* watch bounds on buf */
2094       return -1;
2095
2096     p = str;
2097     d = buf;
2098     for (i=0; i<which; ++i) {
2099         p = strchr(p, ',');
2100         if (!p)
2101           return -1;
2102         ++p;
2103     }
2104
2105     /* Could be looking at something like:
2106        black, , 1
2107        .. in which case we want to stop on a comma also */
2108     while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
2109       ++p;
2110
2111     if (*p == ',') {
2112         return -1;              /* Use default for empty field */
2113     }
2114
2115     if (which == 2 || isdigit(*p))
2116       return atoi(p);
2117
2118     while (*p && isalpha(*p))
2119       *(d++) = *(p++);
2120
2121     *d = 0;
2122
2123     for (i=0; i<8; ++i) {
2124         if (!StrCaseCmp(buf, cnames[i]))
2125           return which? (i+40) : (i+30);
2126     }
2127     if (!StrCaseCmp(buf, "default")) return -1;
2128
2129     fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
2130     return -2;
2131 }
2132
2133 static int
2134 parse_cpair(cc, str)
2135      ColorClass cc;
2136      char *str;
2137 {
2138     if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
2139         fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
2140                 programName, str);
2141         return -1;
2142     }
2143
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;
2148     }
2149     return 0;
2150 }
2151
2152
2153 /* Arrange to catch delete-window events */
2154 Atom wm_delete_window;
2155 void
2156 CatchDeleteWindow(Widget w, String procname)
2157 {
2158   char buf[MSG_SIZ];
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));
2162 }
2163
2164 void
2165 BoardToTop()
2166 {
2167   Arg args[16];
2168   XtSetArg(args[0], XtNiconic, False);
2169   XtSetValues(shellWidget, args, 1);
2170
2171   XtPopup(shellWidget, XtGrabNone); /* Raise if lowered  */
2172 }
2173
2174 #ifdef IDSIZES
2175   // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
2176 #else
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;
2181     Arg args[16];
2182     XtGeometryResult gres;
2183     int i;
2184
2185     if(!formWidget) return;
2186
2187     /*
2188      * Enable shell resizing.
2189      */
2190     shellArgs[0].value = (XtArgVal) &w;
2191     shellArgs[1].value = (XtArgVal) &h;
2192     XtGetValues(shellWidget, shellArgs, 2);
2193
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);
2197
2198     XtSetArg(args[0], XtNdefaultDistance, &sep);
2199     XtGetValues(formWidget, args, 1);
2200
2201     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2202     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2203     CreateGrid();
2204
2205     XtSetArg(args[0], XtNwidth, boardWidth);
2206     XtSetArg(args[1], XtNheight, boardHeight);
2207     XtSetValues(boardWidget, args, 2);
2208
2209     timerWidth = (boardWidth - sep) / 2;
2210     XtSetArg(args[0], XtNwidth, timerWidth);
2211     XtSetValues(whiteTimerWidget, args, 1);
2212     XtSetValues(blackTimerWidget, args, 1);
2213
2214     XawFormDoLayout(formWidget, False);
2215
2216     if (appData.titleInWindow) {
2217         i = 0;
2218         XtSetArg(args[i], XtNborderWidth, &bor); i++;
2219         XtSetArg(args[i], XtNheight, &h);  i++;
2220         XtGetValues(titleWidget, args, i);
2221         if (smallLayout) {
2222             w = boardWidth - 2*bor;
2223         } else {
2224             XtSetArg(args[0], XtNwidth, &w);
2225             XtGetValues(menuBarWidget, args, 1);
2226             w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
2227         }
2228
2229         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2230         if (gres != XtGeometryYes && appData.debugMode) {
2231             fprintf(stderr,
2232                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2233                     programName, gres, w, h, wr, hr);
2234         }
2235     }
2236
2237     XawFormDoLayout(formWidget, True);
2238
2239     /*
2240      * Inhibit shell resizing.
2241      */
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);
2247 }
2248 #endif
2249
2250 int
2251 main(argc, argv)
2252      int argc;
2253      char **argv;
2254 {
2255     int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
2256     XSetWindowAttributes window_attributes;
2257     Arg args[16];
2258     Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2259     XrmValue vFrom, vTo;
2260     XtGeometryResult gres;
2261     char *p;
2262     XrmDatabase xdb;
2263     int forceMono = False;
2264 #define INDIRECTION
2265 #ifdef INDIRECTION
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
2269     int k = 0;
2270
2271     srandom(time(0)); // [HGM] book: make random truly random
2272
2273     j = 0;
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 {
2278             char c;
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
2283                 if(c == '\n') {
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
2288                 } else {
2289                     if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2290                     newArgs[k++] = c;
2291                 }
2292             }
2293             newArgs[k] = 0;
2294             j--;
2295             fclose(f);
2296         }
2297     }
2298     argvCopy[j] = NULL;
2299     argv = argvCopy;
2300     argc = j;
2301 #if 0
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]);
2304     }
2305 #endif
2306 #endif
2307
2308
2309     setbuf(stdout, NULL);
2310     setbuf(stderr, NULL);
2311     debugFP = stderr;
2312
2313     programName = strrchr(argv[0], '/');
2314     if (programName == NULL)
2315       programName = argv[0];
2316     else
2317       programName++;
2318
2319 #ifdef ENABLE_NLS
2320     XtSetLanguageProc(NULL, NULL, NULL);
2321     bindtextdomain(PRODUCT, LOCALEDIR);
2322     textdomain(PRODUCT);
2323 #endif
2324
2325     shellWidget =
2326       XtAppInitialize(&appContext, "XBoard", shellOptions,
2327                       XtNumber(shellOptions),
2328                       &argc, argv, xboardResources, NULL, 0);
2329     if (argc > 1) {
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
2336                          ? " ARG" : ""));
2337             if (i++ < XtNumber(shellOptions)) {
2338                 fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
2339                         shellOptions[i].option,
2340                         (shellOptions[i].argKind == XrmoptionSepArg
2341                          ? " ARG" : ""));
2342             } else {
2343                 fprintf(stderr, "\n");
2344             }
2345         }
2346         exit(2);
2347     }
2348
2349     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
2350         chessDir = ".";
2351     } else {
2352         if (chdir(chessDir) != 0) {
2353             fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
2354             perror(chessDir);
2355             exit(1);
2356         }
2357     }
2358
2359     p = getenv("HOME");
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());
2366
2367     XtGetApplicationResources(shellWidget, (XtPointer) &appData,
2368                               clientResources, XtNumber(clientResources),
2369                               NULL, 0);
2370
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);
2375            exit(errno);
2376         }
2377         setbuf(debugFP, NULL);
2378     }
2379
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);
2384
2385 #if !HIGHDRAG
2386     /* This feature does not work; animation needs a rewrite */
2387     appData.highlightDragging = FALSE;
2388 #endif
2389     InitBackEnd1();
2390
2391     xDisplay = XtDisplay(shellWidget);
2392     xScreen = DefaultScreen(xDisplay);
2393     wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
2394
2395         gameInfo.variant = StringToVariant(appData.variant);
2396         InitPosition(FALSE);
2397 #if 0
2398     /*
2399      * Determine boardSize
2400      */
2401     gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8
2402
2403 //#ifndef IDSIZE
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;
2408 #endif
2409
2410
2411 #ifdef IDSIZE
2412     InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
2413 #else
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);
2418         if (i == 0) {
2419             fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
2420                     programName, appData.boardSize);
2421             exit(2);
2422         }
2423         if (i < 7) {
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) {
2430                     nearest = szd;
2431                     distance = abs(szd->squareSize - squareSize);
2432                     if (distance == 0) break;
2433                 }
2434                 szd++;
2435             }
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;
2442         }
2443     } else {
2444         SizeDefaults *szd = sizeDefaults;
2445         if (*appData.boardSize == NULLCHAR) {
2446             while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
2447                    DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
2448               szd++;
2449             }
2450             if (szd->name == NULL) szd--;
2451         } else {
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);
2457                 exit(2);
2458             }
2459         }
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;
2467     }
2468
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);
2472         if (!p) {
2473             fprintf(stderr, _("Error expanding path name \"%s\"\n"),
2474                    appData.pixmapDirectory);
2475             exit(1);
2476         }
2477         if (appData.debugMode) {
2478           fprintf(stderr, _("\
2479 XBoard square size (hint): %d\n\
2480 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
2481         }
2482         squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
2483         if (appData.debugMode) {
2484             fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
2485         }
2486     }
2487
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) {
2497         /* Jail on sides */
2498         XtSetArg(boardArgs[1], XtNwidth,
2499                  boardWidth + 2*(lineGap + squareSize));
2500         XtSetArg(boardArgs[2], XtNheight, boardHeight);
2501     } else {
2502         /* No jail */
2503         XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2504         XtSetArg(boardArgs[2], XtNheight, boardHeight);
2505     }
2506
2507     /*
2508      * Determine what fonts to use.
2509      */
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);
2520
2521     xdb = XtDatabase(xDisplay);
2522     XrmPutStringResource(&xdb, "*font", appData.font);
2523
2524     /*
2525      * Detect if there are not enough colors available and adapt.
2526      */
2527     if (DefaultDepth(xDisplay, xScreen) <= 2) {
2528       appData.monoMode = True;
2529     }
2530
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;
2537           forceMono = True;
2538         } else {
2539           lightSquareColor = *(Pixel *) vTo.addr;
2540         }
2541     }
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;
2548           forceMono = True;
2549         } else {
2550           darkSquareColor = *(Pixel *) vTo.addr;
2551         }
2552     }
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;
2559           forceMono = True;
2560         } else {
2561           whitePieceColor = *(Pixel *) vTo.addr;
2562         }
2563     }
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;
2570           forceMono = True;
2571         } else {
2572           blackPieceColor = *(Pixel *) vTo.addr;
2573         }
2574     }
2575
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;
2582           forceMono = True;
2583         } else {
2584           highlightSquareColor = *(Pixel *) vTo.addr;
2585         }
2586     }
2587
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;
2594           forceMono = True;
2595         } else {
2596           premoveHighlightColor = *(Pixel *) vTo.addr;
2597         }
2598     }
2599
2600     if (forceMono) {
2601       fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
2602               programName);
2603     }
2604
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;
2611       else
2612                 lowTimeWarningColor = *(Pixel *) vTo.addr;
2613     }
2614
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));
2619     }
2620
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)
2631       {
2632           if (appData.colorize) {
2633               fprintf(stderr,
2634                       _("%s: can't parse color names; disabling colorization\n"),
2635                       programName);
2636           }
2637           appData.colorize = FALSE;
2638       }
2639     textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
2640     textColors[ColorNone].attr = 0;
2641
2642     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
2643
2644     /*
2645      * widget hierarchy
2646      */
2647     if (tinyLayout) {
2648         layoutName = "tinyLayout";
2649     } else if (smallLayout) {
2650         layoutName = "smallLayout";
2651     } else {
2652         layoutName = "normalLayout";
2653     }
2654     /* Outer layoutWidget is there only to provide a name for use in
2655        resources that depend on the layout style */
2656     layoutWidget =
2657       XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
2658                             layoutArgs, XtNumber(layoutArgs));
2659     formWidget =
2660       XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
2661                             formArgs, XtNumber(formArgs));
2662     XtSetArg(args[0], XtNdefaultDistance, &sep);
2663     XtGetValues(formWidget, args, 1);
2664
2665     j = 0;
2666     widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
2667     XtSetArg(args[0], XtNtop,    XtChainTop);
2668     XtSetArg(args[1], XtNbottom, XtChainTop);
2669     XtSetValues(menuBarWidget, args, 2);
2670
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);
2678
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);
2686
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);
2694     }
2695
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);
2703     }
2704
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);
2711
2712     widgetList[j++] = boardWidget =
2713       XtCreateWidget("board", widgetClass, formWidget, boardArgs,
2714                      XtNumber(boardArgs));
2715
2716     XtManageChildren(widgetList, j);
2717
2718     timerWidth = (boardWidth - sep) / 2;
2719     XtSetArg(args[0], XtNwidth, timerWidth);
2720     XtSetValues(whiteTimerWidget, args, 1);
2721     XtSetValues(blackTimerWidget, args, 1);
2722
2723     XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
2724     XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
2725     XtGetValues(whiteTimerWidget, args, 2);
2726
2727     if (appData.showButtonBar) {
2728       XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
2729       XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
2730       XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
2731     }
2732
2733     /*
2734      * formWidget uses these constraints but they are stored
2735      * in the children.
2736      */
2737     i = 0;
2738     XtSetArg(args[i], XtNfromHoriz, 0); i++;
2739     XtSetValues(menuBarWidget, args, i);
2740     if (appData.titleInWindow) {
2741         if (smallLayout) {
2742             i = 0;
2743             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2744             XtSetValues(whiteTimerWidget, args, i);
2745             i = 0;
2746             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2747             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2748             XtSetValues(blackTimerWidget, args, i);
2749             i = 0;
2750             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2751             XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
2752             XtSetValues(titleWidget, args, i);
2753             i = 0;
2754             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2755             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2756             XtSetValues(messageWidget, args, i);
2757             if (appData.showButtonBar) {
2758               i = 0;
2759               XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2760               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2761               XtSetValues(buttonBarWidget, args, i);
2762             }
2763         } else {
2764             i = 0;
2765             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2766             XtSetValues(whiteTimerWidget, args, i);
2767             i = 0;
2768             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2769             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2770             XtSetValues(blackTimerWidget, args, i);
2771             i = 0;
2772             XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
2773             XtSetValues(titleWidget, args, i);
2774             i = 0;
2775             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2776             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2777             XtSetValues(messageWidget, args, i);
2778             if (appData.showButtonBar) {
2779               i = 0;
2780               XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2781               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2782               XtSetValues(buttonBarWidget, args, i);
2783             }
2784         }
2785     } else {
2786         i = 0;
2787         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2788         XtSetValues(whiteTimerWidget, args, i);
2789         i = 0;
2790         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2791         XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2792         XtSetValues(blackTimerWidget, args, i);
2793         i = 0;
2794         XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2795         XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2796         XtSetValues(messageWidget, args, i);
2797         if (appData.showButtonBar) {
2798           i = 0;
2799           XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2800           XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2801           XtSetValues(buttonBarWidget, args, i);
2802         }
2803     }
2804     i = 0;
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);
2811
2812     XtRealizeWidget(shellWidget);
2813
2814     /*
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.
2818      */
2819     XawFormDoLayout(formWidget, False);
2820
2821 #define WIDTH_FUDGE 2
2822     i = 0;
2823     XtSetArg(args[i], XtNborderWidth, &bor);  i++;
2824     XtSetArg(args[i], XtNheight, &h);  i++;
2825     XtGetValues(messageWidget, args, i);
2826     if (appData.showButtonBar) {
2827       i = 0;
2828       XtSetArg(args[i], XtNwidth, &w);  i++;
2829       XtGetValues(buttonBarWidget, args, i);
2830       w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2831     } else {
2832       w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
2833     }
2834
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);
2839     }
2840
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! */
2844     w--;
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);
2849     }
2850     /* !! end hack */
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);
2854
2855     if (appData.titleInWindow) {
2856         i = 0;
2857         XtSetArg(args[i], XtNborderWidth, &bor); i++;
2858         XtSetArg(args[i], XtNheight, &h);  i++;
2859         XtGetValues(titleWidget, args, i);
2860         if (smallLayout) {
2861             w = boardWidth - 2*bor;
2862         } else {
2863             XtSetArg(args[0], XtNwidth, &w);
2864             XtGetValues(menuBarWidget, args, 1);
2865             w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2866         }
2867
2868         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2869         if (gres != XtGeometryYes && appData.debugMode) {
2870             fprintf(stderr,
2871                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2872                     programName, gres, w, h, wr, hr);
2873         }
2874     }
2875     XawFormDoLayout(formWidget, True);
2876
2877     xBoardWindow = XtWindow(boardWidget);
2878
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().
2881 #endif
2882
2883     /*
2884      * Create X checkmark bitmap and initialize option menu checks.
2885      */
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"),
2891                     args, 1);
2892     }
2893     if (appData.animateDragging) {
2894         XtSetValues(XtNameToWidget(menuBarWidget,
2895                                    "menuOptions.Animate Dragging"),
2896                     args, 1);
2897     }
2898     if (appData.animate) {
2899         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
2900                     args, 1);
2901     }
2902     if (appData.autoComment) {
2903         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
2904                     args, 1);
2905     }
2906     if (appData.autoCallFlag) {
2907         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
2908                     args, 1);
2909     }
2910     if (appData.autoFlipView) {
2911         XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
2912                     args, 1);
2913     }
2914     if (appData.autoObserve) {
2915         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
2916                     args, 1);
2917     }
2918     if (appData.autoRaiseBoard) {
2919         XtSetValues(XtNameToWidget(menuBarWidget,
2920                                    "menuOptions.Auto Raise Board"), args, 1);
2921     }
2922     if (appData.autoSaveGames) {
2923         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2924                     args, 1);
2925     }
2926     if (appData.saveGameFile[0] != NULLCHAR) {
2927         /* Can't turn this off from menu */
2928         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2929                     args, 1);
2930         XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2931                        False);
2932
2933     }
2934     if (appData.blindfold) {
2935         XtSetValues(XtNameToWidget(menuBarWidget,
2936                                    "menuOptions.Blindfold"), args, 1);
2937     }
2938     if (appData.flashCount > 0) {
2939         XtSetValues(XtNameToWidget(menuBarWidget,
2940                                    "menuOptions.Flash Moves"),
2941                     args, 1);
2942     }
2943     if (appData.getMoveList) {
2944         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
2945                     args, 1);
2946     }
2947 #if HIGHDRAG
2948     if (appData.highlightDragging) {
2949         XtSetValues(XtNameToWidget(menuBarWidget,
2950                                    "menuOptions.Highlight Dragging"),
2951                     args, 1);
2952     }
2953 #endif
2954     if (appData.highlightLastMove) {
2955         XtSetValues(XtNameToWidget(menuBarWidget,
2956                                    "menuOptions.Highlight Last Move"),
2957                     args, 1);
2958     }
2959     if (appData.icsAlarm) {
2960         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
2961                     args, 1);
2962     }
2963     if (appData.ringBellAfterMoves) {
2964         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
2965                     args, 1);
2966     }
2967     if (appData.oldSaveStyle) {
2968         XtSetValues(XtNameToWidget(menuBarWidget,
2969                                    "menuOptions.Old Save Style"), args, 1);
2970     }
2971     if (appData.periodicUpdates) {
2972         XtSetValues(XtNameToWidget(menuBarWidget,
2973                                    "menuOptions.Periodic Updates"), args, 1);
2974     }
2975     if (appData.ponderNextMove) {
2976         XtSetValues(XtNameToWidget(menuBarWidget,
2977                                    "menuOptions.Ponder Next Move"), args, 1);
2978     }
2979     if (appData.popupExitMessage) {
2980         XtSetValues(XtNameToWidget(menuBarWidget,
2981                                    "menuOptions.Popup Exit Message"), args, 1);
2982     }
2983     if (appData.popupMoveErrors) {
2984         XtSetValues(XtNameToWidget(menuBarWidget,
2985                                    "menuOptions.Popup Move Errors"), args, 1);
2986     }
2987     if (appData.premove) {
2988         XtSetValues(XtNameToWidget(menuBarWidget,
2989                                    "menuOptions.Premove"), args, 1);
2990     }
2991     if (appData.quietPlay) {
2992         XtSetValues(XtNameToWidget(menuBarWidget,
2993                                    "menuOptions.Quiet Play"), args, 1);
2994     }
2995     if (appData.showCoords) {
2996         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
2997                     args, 1);
2998     }
2999     if (appData.hideThinkingFromHuman) {
3000         XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
3001                     args, 1);
3002     }
3003     if (appData.testLegality) {
3004         XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
3005                     args, 1);
3006     }
3007
3008     /*
3009      * Create an icon.
3010      */
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;
3016     i = 0;
3017     XtSetArg(args[i], XtNiconPixmap, iconPixmap);  i++;
3018     XtSetValues(shellWidget, args, i);
3019
3020     /*
3021      * Create a cursor for the board widget.
3022      */
3023     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
3024     XChangeWindowAttributes(xDisplay, xBoardWindow,
3025                             CWCursor, &window_attributes);
3026
3027     /*
3028      * Inhibit shell resizing.
3029      */
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;
3038
3039     CatchDeleteWindow(shellWidget, "QuitProc");
3040
3041     CreateGCs();
3042     CreateGrid();
3043 #if HAVE_LIBXPM
3044     if (appData.bitmapDirectory[0] != NULLCHAR) {
3045       CreatePieces();
3046     } else {
3047       CreateXPMPieces();
3048     }
3049 #else
3050     CreateXIMPieces();
3051     /* Create regular pieces */
3052     if (!useImages) CreatePieces();
3053 #endif
3054
3055     CreatePieceMenus();
3056
3057     if (appData.animate || appData.animateDragging)
3058       CreateAnimVars();
3059
3060     XtAugmentTranslations(formWidget,
3061                           XtParseTranslationTable(globalTranslations));
3062     XtAugmentTranslations(boardWidget,
3063                           XtParseTranslationTable(boardTranslations));
3064     XtAugmentTranslations(whiteTimerWidget,
3065                           XtParseTranslationTable(whiteTranslations));
3066     XtAugmentTranslations(blackTimerWidget,
3067                           XtParseTranslationTable(blackTranslations));
3068
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);
3073     /* end why */
3074
3075     InitBackEnd2();
3076
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();
3083         }
3084
3085         signal(SIGINT, IntSigHandler);
3086         signal(SIGTERM, IntSigHandler);
3087         if (*appData.cmailGameName != NULLCHAR) {
3088             signal(SIGUSR1, CmailSigHandler);
3089         }
3090     }
3091         InitPosition(TRUE);
3092
3093     XtAppMainLoop(appContext);
3094     if (appData.debugMode) fclose(debugFP); // [DM] debug
3095     return 0;
3096 }
3097
3098 void
3099 ShutDownFrontEnd()
3100 {
3101     if (appData.icsActive && oldICSInteractionTitle != NULL) {
3102         DisplayIcsInteractionTitle(oldICSInteractionTitle);
3103     }
3104     unlink(gameCopyFilename);
3105     unlink(gamePasteFilename);
3106 }
3107
3108 RETSIGTYPE
3109 IntSigHandler(sig)
3110      int sig;
3111 {
3112     ExitEvent(sig);
3113 }
3114
3115 RETSIGTYPE
3116 CmailSigHandler(sig)
3117      int sig;
3118 {
3119     int dummy = 0;
3120     int error;
3121
3122     signal(SIGUSR1, SIG_IGN);   /* suspend handler     */
3123
3124     /* Activate call-back function CmailSigHandlerCallBack()             */
3125     OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
3126
3127     signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
3128 }
3129
3130 void
3131 CmailSigHandlerCallBack(isr, closure, message, count, error)
3132      InputSourceRef isr;
3133      VOIDSTAR closure;
3134      char *message;
3135      int count;
3136      int error;
3137 {
3138     BoardToTop();
3139     ReloadCmailMsgEvent(TRUE);  /* Reload cmail msg  */
3140 }
3141 /**** end signal code ****/
3142
3143
3144 void
3145 ICSInitScript()
3146 {
3147     FILE *f;
3148     char buf[MSG_SIZ];
3149     char *p;
3150
3151     f = fopen(appData.icsLogon, "r");
3152     if (f == NULL) {
3153         p = getenv("HOME");
3154         if (p != NULL) {
3155             strcpy(buf, p);
3156             strcat(buf, "/");
3157             strcat(buf, appData.icsLogon);
3158             f = fopen(buf, "r");
3159         }
3160     }
3161     if (f != NULL)
3162       ProcessICSInitScript(f);
3163 }
3164
3165 void
3166 ResetFrontEnd()
3167 {
3168     CommentPopDown();
3169     EditCommentPopDown();
3170     TagsPopDown();
3171     return;
3172 }
3173
3174 typedef struct {
3175     char *name;
3176     Boolean value;
3177 } Enables;
3178
3179 void
3180 SetMenuEnables(enab)
3181      Enables *enab;
3182 {
3183   Widget w;
3184   if (!menuBarWidget) return;
3185   while (enab->name != NULL) {
3186     w = XtNameToWidget(menuBarWidget, enab->name);
3187     if (w == NULL) {
3188       DisplayError(enab->name, 0);
3189     } else {
3190       XtSetSensitive(w, enab->value);
3191     }
3192     enab++;
3193   }
3194 }
3195
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 },
3204 #ifndef ZIPPY
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 },
3211 #endif
3212     { NULL, False }
3213 };
3214
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 },
3243     { NULL, False }
3244 };
3245
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 },
3262
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                                  */
3266
3267     { "menuFile.Mail Move", False },
3268     { "menuFile.Reload CMail Message", False },
3269     { NULL, False }
3270 };
3271
3272 Enables cmailEnables[] = {
3273     { "Action", True },
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 },
3282     { NULL, False }
3283 };
3284
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 },
3294   { NULL, False }
3295 };
3296
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 },
3306   { NULL, False }
3307 };
3308
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 },
3324   { NULL, False }
3325 };
3326
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 },
3342   { NULL, False }
3343 };
3344
3345 void SetICSMode()
3346 {
3347   SetMenuEnables(icsEnables);
3348
3349 #ifdef ZIPPY
3350   if (appData.zippyPlay && !appData.noChessProgram)   /* [DM] icsEngineAnalyze */
3351      XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
3352 #endif
3353 }
3354
3355 void
3356 SetNCPMode()
3357 {
3358   SetMenuEnables(ncpEnables);
3359 }
3360
3361 void
3362 SetGNUMode()
3363 {
3364   SetMenuEnables(gnuEnables);
3365 }
3366
3367 void
3368 SetCmailMode()
3369 {
3370   SetMenuEnables(cmailEnables);
3371 }
3372
3373 void
3374 SetTrainingModeOn()
3375 {
3376   SetMenuEnables(trainingOnEnables);
3377   if (appData.showButtonBar) {
3378     XtSetSensitive(buttonBarWidget, False);
3379   }
3380   CommentPopDown();
3381 }
3382
3383 void
3384 SetTrainingModeOff()
3385 {
3386   SetMenuEnables(trainingOffEnables);
3387   if (appData.showButtonBar) {
3388     XtSetSensitive(buttonBarWidget, True);
3389   }
3390 }
3391
3392 void
3393 SetUserThinkingEnables()
3394 {
3395   if (appData.noChessProgram) return;
3396   SetMenuEnables(userThinkingEnables);
3397 }
3398
3399 void
3400 SetMachineThinkingEnables()
3401 {
3402   if (appData.noChessProgram) return;
3403   SetMenuEnables(machineThinkingEnables);
3404   switch (gameMode) {
3405   case MachinePlaysBlack:
3406   case MachinePlaysWhite:
3407   case TwoMachinesPlay:
3408     XtSetSensitive(XtNameToWidget(menuBarWidget,
3409                                   ModeToWidgetName(gameMode)), True);
3410     break;
3411   default:
3412     break;
3413   }
3414 }
3415
3416 #define Abs(n) ((n)<0 ? -(n) : (n))
3417
3418 /*
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
3425  * longer needed.
3426  */
3427 char *FindFont(pattern, targetPxlSize)
3428      char *pattern;
3429      int targetPxlSize;
3430 {
3431     char **fonts, *p, *best, *scalable, *scalableTail;
3432     int i, j, nfonts, minerr, err, pxlSize;
3433
3434 #ifdef ENABLE_NLS
3435     char **missing_list;
3436     int missing_count;
3437     char *def_string, *base_fnt_lst, strInt[3];
3438     XFontSet fntSet;
3439     XFontStruct **fnt_list;
3440
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, '-'));
3447
3448     if ((fntSet = XCreateFontSet(xDisplay,
3449                                  base_fnt_lst,
3450                                  &missing_list,
3451                                  &missing_count,
3452                                  &def_string)) == NULL) {
3453
3454        fprintf(stderr, _("Unable to create font set.\n"));
3455        exit (2);
3456     }
3457
3458     nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
3459 #else
3460     fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
3461     if (nfonts < 1) {
3462         fprintf(stderr, _("%s: no fonts match pattern %s\n"),
3463                 programName, pattern);
3464         exit(2);
3465     }
3466 #endif
3467
3468     best = fonts[0];
3469     scalable = NULL;
3470     minerr = 999999;
3471     for (i=0; i<nfonts; i++) {
3472         j = 0;
3473         p = fonts[i];
3474         if (*p != '-') continue;
3475         while (j < 7) {
3476             if (*p == NULLCHAR) break;
3477             if (*p++ == '-') j++;
3478         }
3479         if (j < 7) continue;
3480         pxlSize = atoi(p);
3481         if (pxlSize == 0) {
3482             scalable = fonts[i];
3483             scalableTail = p;
3484         } else {
3485             err = pxlSize - targetPxlSize;
3486             if (Abs(err) < Abs(minerr) ||
3487                 (minerr > 0 && err < 0 && -err == minerr)) {
3488                 best = fonts[i];
3489                 minerr = err;
3490             }
3491         }
3492     }
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);
3500     } else {
3501         p = (char *) XtMalloc(strlen(best) + 1);
3502         strcpy(p, best);
3503     }
3504     if (appData.debugMode) {
3505         fprintf(debugFP, _("resolved %s at pixel size %d\n  to %s\n"),
3506                 pattern, targetPxlSize, p);
3507     }
3508 #ifdef ENABLE_NLS
3509     if (missing_count > 0)
3510        XFreeStringList(missing_list);
3511     XFreeFontSet(xDisplay, fntSet);
3512 #else
3513      XFreeFontNames(fonts);
3514 #endif
3515     return p;
3516 }
3517
3518 void CreateGCs()
3519 {
3520     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
3521       | GCBackground | GCFunction | GCPlaneMask;
3522     XGCValues gc_values;
3523     GC copyInvertedGC;
3524
3525     gc_values.plane_mask = AllPlanes;
3526     gc_values.line_width = lineGap;
3527     gc_values.line_style = LineSolid;
3528     gc_values.function = GXcopy;
3529
3530     gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3531     gc_values.background = XBlackPixel(xDisplay, xScreen);
3532     lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3533
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);
3538
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);
3544
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);
3549
3550         gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3551         gc_values.background = XBlackPixel(xDisplay, xScreen);
3552         lightSquareGC = wbPieceGC
3553           = XtGetGC(shellWidget, value_mask, &gc_values);
3554
3555         gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3556         gc_values.background = XWhitePixel(xDisplay, xScreen);
3557         darkSquareGC = bwPieceGC
3558           = XtGetGC(shellWidget, value_mask, &gc_values);
3559
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;
3568             } else {
3569                 bwPieceGC = copyInvertedGC;
3570                 wbPieceGC = lightSquareGC;
3571             }
3572         }
3573     } else {
3574         gc_values.foreground = highlightSquareColor;
3575         gc_values.background = highlightSquareColor;
3576         highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3577
3578         gc_values.foreground = premoveHighlightColor;
3579         gc_values.background = premoveHighlightColor;
3580         prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3581
3582         gc_values.foreground = lightSquareColor;
3583         gc_values.background = darkSquareColor;
3584         lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3585
3586         gc_values.foreground = darkSquareColor;
3587         gc_values.background = lightSquareColor;
3588         darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3589
3590         gc_values.foreground = jailSquareColor;
3591         gc_values.background = jailSquareColor;
3592         jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3593
3594         gc_values.foreground = whitePieceColor;
3595         gc_values.background = darkSquareColor;
3596         wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3597
3598         gc_values.foreground = whitePieceColor;
3599         gc_values.background = lightSquareColor;
3600         wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3601
3602         gc_values.foreground = whitePieceColor;
3603         gc_values.background = jailSquareColor;
3604         wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3605
3606         gc_values.foreground = blackPieceColor;
3607         gc_values.background = darkSquareColor;
3608         bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3609
3610         gc_values.foreground = blackPieceColor;
3611         gc_values.background = lightSquareColor;
3612         blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3613
3614         gc_values.foreground = blackPieceColor;
3615         gc_values.background = jailSquareColor;
3616         bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3617     }
3618 }
3619
3620 void loadXIM(xim, xmask, filename, dest, mask)
3621      XImage *xim;
3622      XImage *xmask;
3623      char *filename;
3624      Pixmap *dest;
3625      Pixmap *mask;
3626 {
3627     int x, y, w, h, p;
3628     FILE *fp;
3629     Pixmap temp;
3630     XGCValues   values;
3631     GC maskGC;
3632
3633     fp = fopen(filename, "rb");
3634     if (!fp) {
3635         fprintf(stderr, _("%s: error loading XIM!\n"), programName);
3636         exit(1);
3637     }
3638
3639     w = fgetc(fp);
3640     h = fgetc(fp);
3641
3642     for (y=0; y<h; ++y) {
3643         for (x=0; x<h; ++x) {
3644             p = fgetc(fp);
3645
3646             switch (p) {
3647               case 0:
3648                 XPutPixel(xim, x, y, blackPieceColor);
3649                 if (xmask)
3650                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3651                 break;
3652               case 1:
3653                 XPutPixel(xim, x, y, darkSquareColor);
3654                 if (xmask)
3655                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3656                 break;
3657               case 2:
3658                 XPutPixel(xim, x, y, whitePieceColor);
3659                 if (xmask)
3660                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3661                 break;
3662               case 3:
3663                 XPutPixel(xim, x, y, lightSquareColor);
3664                 if (xmask)
3665                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3666                 break;
3667             }
3668         }
3669     }
3670
3671     /* create Pixmap of piece */
3672     *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3673                           w, h, xim->depth);
3674     XPutImage(xDisplay, *dest, lightSquareGC, xim,
3675               0, 0, 0, 0, w, h);
3676
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. */
3681     if (xmask) {
3682       temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3683                             w, h, xim->depth);
3684       XPutImage(xDisplay, temp, lightSquareGC, xmask,
3685               0, 0, 0, 0, w, h);
3686
3687       /* now create the 1-bit version */
3688       *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3689                           w, h, 1);
3690
3691       values.foreground = 1;
3692       values.background = 0;
3693
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);
3700     }
3701 }
3702
3703 void CreateXIMPieces()
3704 {
3705     int piece, kind;
3706     char buf[MSG_SIZ];
3707     u_int ss;
3708     static char *ximkind[] = { "ll", "ld", "dl", "dd" };
3709     XImage *ximtemp;
3710
3711     ss = squareSize;
3712
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
3716                                      buffering bug */
3717
3718     /* temp needed by loadXIM() */
3719     ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3720                  0, 0, ss, ss, AllPlanes, XYPixmap);
3721
3722     if (strlen(appData.pixmapDirectory) == 0) {
3723       useImages = 0;
3724     } else {
3725         useImages = 1;
3726         if (appData.monoMode) {
3727           DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
3728                             0, 2);
3729           ExitEvent(2);
3730         }
3731         fprintf(stderr, _("\nLoading XIMs...\n"));
3732         /* Load pieces */
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)),
3740                         ximkind[kind], ss);
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],
3747                         ximtemp, buf,
3748                         &(xpmPieceBitmap[kind][piece]),
3749                         &(ximMaskPm[piece%(int)BlackPawn]));
3750             }
3751             fprintf(stderr," ");
3752         }
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) {
3758             useImageSqs = 0;
3759         } else {
3760             useImageSqs = 1;
3761             fprintf(stderr, _("light square "));
3762             ximLightSquare=
3763               XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3764                         0, 0, ss, ss, AllPlanes, XYPixmap);
3765             if (appData.debugMode)
3766               fprintf(stderr, _("(File:%s:) "), buf);
3767
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);
3774             ximDarkSquare=
3775               XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3776                         0, 0, ss, ss, AllPlanes, XYPixmap);
3777             loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
3778             xpmJailSquare = xpmLightSquare;
3779         }
3780         fprintf(stderr, _("Done.\n"));
3781     }
3782     XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
3783 }
3784
3785 #if HAVE_LIBXPM
3786 void CreateXPMPieces()
3787 {
3788     int piece, kind, r;
3789     char buf[MSG_SIZ];
3790     u_int ss = squareSize;
3791     XpmAttributes attr;
3792     static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
3793     XpmColorSymbol symbols[4];
3794
3795 #if 0
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));
3800     }
3801 #endif
3802
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 */
3806
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;
3816
3817     attr.valuemask = XpmColorSymbols;
3818     attr.colorsymbols = symbols;
3819     attr.numsymbols = 4;
3820
3821     if (appData.monoMode) {
3822       DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
3823                         0, 2);
3824       ExitEvent(2);
3825     }
3826     if (strlen(appData.pixmapDirectory) == 0) {
3827         XpmPieces* pieces = builtInXpms;
3828         useImages = 1;
3829         /* Load pieces */
3830         while (pieces->size != squareSize && pieces->size) pieces++;
3831         if (!pieces->size) {
3832           fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
3833           exit(1);
3834         }
3835         for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3836             for (kind=0; kind<4; kind++) {
3837
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"),
3843                           r, buf);
3844                   exit(1);
3845                 }
3846             }
3847         }
3848         useImageSqs = 0;
3849         xpmJailSquare = xpmLightSquare;
3850     } else {
3851         useImages = 1;
3852
3853         fprintf(stderr, _("\nLoading XPMs...\n"));
3854
3855         /* Load pieces */
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)),
3862                         xpmkind[kind], ss);
3863                 if (appData.debugMode) {
3864                     fprintf(stderr, _("(File:%s:) "), buf);
3865                 }
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"),
3870                             r, buf);
3871                     exit(1);
3872                 }
3873             }
3874         }
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) {
3881             useImageSqs = 0;
3882         } else {
3883             useImageSqs = 1;
3884             if (appData.debugMode)
3885               fprintf(stderr, _("(File:%s:) "), buf);
3886
3887             if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3888                                        &xpmLightSquare, NULL, &attr)) != 0) {
3889                 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3890                 exit(1);
3891             }
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);
3897             }
3898             if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3899                                        &xpmDarkSquare, NULL, &attr)) != 0) {
3900                 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3901                 exit(1);
3902             }
3903         }
3904         xpmJailSquare = xpmLightSquare;
3905         fprintf(stderr, _("Done.\n"));
3906     }
3907     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3908                                       buffering bug */
3909 }
3910 #endif /* HAVE_LIBXPM */
3911
3912 #if HAVE_LIBXPM
3913 /* No built-in bitmaps */
3914 void CreatePieces()
3915 {
3916     int piece, kind;
3917     char buf[MSG_SIZ];
3918     u_int ss = squareSize;
3919
3920     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3921                                      buffering bug */
3922
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);
3928         }
3929     }
3930
3931     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3932                                       buffering bug */
3933 }
3934 #else
3935 /* With built-in bitmaps */
3936 void CreatePieces()
3937 {
3938     BuiltInBits* bib = builtInBits;
3939     int piece, kind;
3940     char buf[MSG_SIZ];
3941     u_int ss = squareSize;
3942
3943     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3944                                      buffering bug */
3945
3946     while (bib->squareSize != ss && bib->squareSize != 0) bib++;
3947
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);
3954         }
3955     }
3956
3957     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3958                                       buffering bug */
3959 }
3960 #endif
3961
3962 void ReadBitmap(pm, name, bits, wreq, hreq)
3963      Pixmap *pm;
3964      String name;
3965      unsigned char bits[];
3966      u_int wreq, hreq;
3967 {
3968     int x_hot, y_hot;
3969     u_int w, h;
3970     int errcode;
3971     char msg[MSG_SIZ], fullname[MSG_SIZ];
3972
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) {
3980             switch (errcode) {
3981               case BitmapOpenFailed:
3982                 snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
3983                 break;
3984               case BitmapFileInvalid:
3985                 snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
3986                 break;
3987               case BitmapNoMemory:
3988                 snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
3989                         fullname);
3990                 break;
3991               default:
3992                 snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
3993                         errcode, fullname);
3994                 break;
3995             }
3996             fprintf(stderr, _("%s: %s...using built-in\n"),
3997                     programName, msg);
3998         } else if (w != wreq || h != hreq) {
3999             fprintf(stderr,
4000                     _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
4001                     programName, fullname, w, h, wreq, hreq);
4002         } else {
4003             return;
4004         }
4005     }
4006     if (bits == NULL) {
4007 #if 0
4008         fprintf(stderr, _("%s: No built-in bitmap for %s; giving up\n"),
4009                 programName, name);
4010         exit(1);
4011 #endif
4012         ; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
4013     } else {
4014         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
4015                                     wreq, hreq);
4016     }
4017 }
4018
4019 void CreateGrid()
4020 {
4021     int i, j;
4022
4023     if (lineGap == 0) return;
4024
4025     /* [HR] Split this into 2 loops for non-square boards. */
4026
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));
4033     }
4034
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));
4041     }
4042 }
4043
4044 static void MenuBarSelect(w, addr, index)
4045      Widget w;
4046      caddr_t addr;
4047      caddr_t index;
4048 {
4049     XtActionProc proc = (XtActionProc) addr;
4050
4051     (proc)(NULL, NULL, NULL, NULL);
4052 }
4053
4054 void CreateMenuBarPopup(parent, name, mb)
4055      Widget parent;
4056      String name;
4057      Menu *mb;
4058 {
4059     int j;
4060     Widget menu, entry;
4061     MenuItem *mi;
4062     Arg args[16];
4063
4064     menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
4065                               parent, NULL, 0);
4066     j = 0;
4067     XtSetArg(args[j], XtNleftMargin, 20);   j++;
4068     XtSetArg(args[j], XtNrightMargin, 20);  j++;
4069     mi = mb->mi;
4070     while (mi->string != NULL) {
4071         if (strcmp(mi->string, "----") == 0) {
4072             entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
4073                                           menu, args, j);
4074         } else {
4075           XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
4076             entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
4077                                           menu, args, j+1);
4078             XtAddCallback(entry, XtNcallback,
4079                           (XtCallbackProc) MenuBarSelect,
4080                           (caddr_t) mi->proc);
4081         }
4082         mi++;
4083     }
4084 }
4085
4086 Widget CreateMenuBar(mb)
4087      Menu *mb;
4088 {
4089     int j;
4090     Widget anchor, menuBar;
4091     Arg args[16];
4092     char menuName[MSG_SIZ];
4093
4094     j = 0;
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);
4100
4101     while (mb->name != NULL) {
4102         strcpy(menuName, "menu");
4103         strcat(menuName, mb->name);
4104         j = 0;
4105         XtSetArg(args[j], XtNmenuName, XtNewString(menuName));  j++;
4106         if (tinyLayout) {