Let XBoard print version with argument --version or -v
[xboard.git] / xboard.c
index b599a8d..e4c19e4 100644 (file)
--- a/xboard.c
+++ b/xboard.c
@@ -1,11 +1,11 @@
 /*
  * xboard.c -- X front end for XBoard
- * $Id: xboard.c,v 2.2 2003/11/06 07:22:14 mann Exp $
  *
  * Copyright 1991 by Digital Equipment Corporation, Maynard,
- * Massachusetts.  Enhancements Copyright
- * 1992-2001,2002,2003,2004,2005,2006,2007,2008,2009 Free Software
- * Foundation, Inc.
+ * Massachusetts. 
+ *
+ * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
+ * 2007, 2008, 2009 Free Software Foundation, Inc.
  *
  * The following terms apply to Digital Equipment Corporation's copyright
  * interest in XBoard:
@@ -144,6 +144,7 @@ extern char *getenv();
 #include <X11/Shell.h>
 #include <X11/cursorfont.h>
 #include <X11/Xatom.h>
+#include <X11/Xmu/Atoms.h>
 #if USE_XAW3D
 #include <X11/Xaw3d/Dialog.h>
 #include <X11/Xaw3d/Form.h>
@@ -199,9 +200,9 @@ extern char *getenv();
 // must be moved to xengineoutput.h
 
 void EngineOutputProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-
-void EngineOutputPopDown();
                       String *prms, Cardinal *nprms));
+void EvalGraphProc P((Widget w, XEvent *event,
+                     String *prms, Cardinal *nprms));
 
 
 #ifdef __EMX__
@@ -232,6 +233,7 @@ typedef struct {
 int main P((int argc, char **argv));
 RETSIGTYPE CmailSigHandler P((int sig));
 RETSIGTYPE IntSigHandler P((int sig));
+RETSIGTYPE TermSizeSigHandler P((int sig));
 void CreateGCs P((void));
 void CreateXIMPieces P((void));
 void CreateXPMPieces P((void));
@@ -280,7 +282,6 @@ void AskQuestionReplyAction P((Widget w, XEvent *event,
 void AskQuestionProc P((Widget w, XEvent *event,
                          String *prms, Cardinal *nprms));
 void AskQuestionPopDown P((void));
-void PromotionPopUp P((void));
 void PromotionPopDown P((void));
 void PromotionCallback P((Widget w, XtPointer client_data,
                          XtPointer call_data));
@@ -410,6 +411,8 @@ void HideThinkingProc P((Widget w, XEvent *event, String *prms,
                         Cardinal *nprms));
 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
                          Cardinal *nprms));
+void SaveSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SaveOnExitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
@@ -427,12 +430,9 @@ void ErrorPopUp P((char *title, char *text, int modal));
 void ErrorPopDown P((void));
 static char *ExpandPathName P((char *path));
 static void CreateAnimVars P((void));
-static void DragPieceBegin P((int x, int y));
 static void DragPieceMove P((int x, int y));
-static void DragPieceEnd P((int x, int y));
 static void DrawDragPiece P((void));
 char *ModeToWidgetName P((GameMode mode));
-void EngineOutputUpdate( FrontEndProgramStats * stats );
 void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
 void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
@@ -446,6 +446,8 @@ void UciPopDown P(());
 void TimeControlPopDown P(());
 void NewVariantPopDown P(());
 void SettingsPopDown P(());
+void update_ics_width P(());
+int get_term_width P(());
 /*
 * XBoard depends on Xt R4 or higher
 */
@@ -456,6 +458,7 @@ Display *xDisplay;
 Window xBoardWindow;
 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
   jailSquareColor, highlightSquareColor, premoveHighlightColor;
+Pixel lowTimeWarningColor;
 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
   bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
   wjPieceGC, bjPieceGC, prelineGC, countGC;
@@ -465,8 +468,9 @@ Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
   commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
   menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
   ICSInputShell, fileNameShell, askQuestionShell;
-XSegment gridSegments[(BOARD_SIZE + 1) * 2];
-XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
+Widget historyShell, evalGraphShell, gameListShell;
+XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
 Font clockFontID, coordFontID, countFontID;
 XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
 XtAppContext appContext;
@@ -479,7 +483,11 @@ char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time i
 
 Position commentX = -1, commentY = -1;
 Dimension commentW, commentH;
+typedef unsigned int BoardSize;
+BoardSize boardSize;
+Boolean chessProgram;
 
+int  minX, minY; // [HGM] placement: volatile limits on upper-left corner
 int squareSize, smallLayout = 0, tinyLayout = 0,
   marginW, marginH, // [HGM] for run-time resizing
   fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
@@ -490,20 +498,39 @@ Pixel timerForegroundPixel, timerBackgroundPixel;
 Pixel buttonForegroundPixel, buttonBackgroundPixel;
 char *chessDir, *programName, *programVersion,
   *gameCopyFilename, *gamePasteFilename;
+Boolean alwaysOnTop = False;
+Boolean saveSettingsOnExit;
+char *settingsFileName;
+char *icsTextMenuString;
+char *icsNames;
+char *firstChessProgramNames;
+char *secondChessProgramNames;
+
+WindowPlacement wpMain;
+WindowPlacement wpConsole;
+WindowPlacement wpComment;
+WindowPlacement wpMoveHistory;
+WindowPlacement wpEvalGraph;
+WindowPlacement wpEngineOutput;
+WindowPlacement wpGameList;
+WindowPlacement wpTags;
 
 #define SOLID 0
 #define OUTLINE 1
 Pixmap pieceBitmap[2][(int)BlackPawn];
-Pixmap xpmPieceBitmap[4][(int)BlackPawn];      /* LL, LD, DL, DD */
+Pixmap pieceBitmap2[2][(int)BlackPawn+4];       /* [HGM] pieces */
+Pixmap xpmPieceBitmap[4][(int)BlackPawn];      /* LL, LD, DL, DD actually used*/
+Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4];   /* LL, LD, DL, DD set to select from */
 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
 int useImages, useImageSqs;
-XImage *ximPieceBitmap[4][(int)BlackPawn];     /* LL, LD, DL, DD */
-Pixmap ximMaskPm[(int)BlackPawn];            /* clipmasks, used for XIM pieces */
+XImage *ximPieceBitmap[4][(int)BlackPawn+4];   /* LL, LD, DL, DD */
+Pixmap ximMaskPm[(int)BlackPawn];               /* clipmasks, used for XIM pieces */
+Pixmap ximMaskPm2[(int)BlackPawn+4];            /* clipmasks, used for XIM pieces */
 XImage *ximLightSquare, *ximDarkSquare;
 XImage *xim_Cross;
 
-#define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % (int)BlackPawn]
-#define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % (int)BlackPawn]
+#define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
+#define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
 
 #define White(piece) ((int)(piece) < (int)BlackPawn)
 
@@ -580,9 +607,9 @@ MenuItem modeMenu[] = {
     {N_("Training"), TrainingProc},
     {"----", NothingProc},
     {N_("Show Engine Output"), EngineOutputProc},
-    {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
+    {N_("Show Evaluation Graph"), EvalGraphProc},
     {N_("Show Game List"), ShowGameListProc},
-    {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
+    {N_("Show Move History"), HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
     {"----", NothingProc},
     {N_("Edit Tags"), EditTagsProc},
     {N_("Edit Comment"), EditCommentProc},
@@ -661,6 +688,9 @@ MenuItem optionsMenu[] = {
     {N_("Show Coords"), ShowCoordsProc},
     {N_("Hide Thinking"), HideThinkingProc},
     {N_("Test Legality"), TestLegalityProc},
+    {"----", NothingProc},
+    {N_("Save Settings Now"), SaveSettingsProc},
+    {N_("Save Settings on Exit"), SaveOnExitProc},
     {NULL, NULL}
 };
 
@@ -695,21 +725,27 @@ MenuItem buttonBar[] = {
     {NULL, NULL}
 };
 
-#define PIECE_MENU_SIZE 11
+#define PIECE_MENU_SIZE 18
 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
     { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
-      N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
+      N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"), 
+      N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"), 
+      N_("Empty square"), N_("Clear board") },
     { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
-      N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
+      N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"), 
+      N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"), 
+      N_("Empty square"), N_("Clear board") }
 };
 /* must be in same order as PieceMenuStrings! */
 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
     { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
-       WhiteRook, WhiteQueen, WhiteKing,
-       (ChessSquare) 0, EmptySquare, ClearBoard },
+       WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
+       WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0, 
+       PromotePiece, DemotePiece, EmptySquare, ClearBoard },
     { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
-       BlackRook, BlackQueen, BlackKing,
-       (ChessSquare) 0, EmptySquare, ClearBoard },
+       BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
+       BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0, 
+       PromotePiece, DemotePiece, EmptySquare, ClearBoard },
 };
 
 #define DROP_MENU_SIZE 6
@@ -780,975 +816,17 @@ Arg timerArgs[] = {
 };
 
 XtResource clientResources[] = {
-    { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, whitePieceColor), XtRString,
-       WHITE_PIECE_COLOR },
-    { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, blackPieceColor), XtRString,
-       BLACK_PIECE_COLOR },
-    { "lightSquareColor", "lightSquareColor", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
-       XtRString, LIGHT_SQUARE_COLOR },
-    { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, darkSquareColor), XtRString,
-       DARK_SQUARE_COLOR },
-    { "highlightSquareColor", "highlightSquareColor", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
-       XtRString, HIGHLIGHT_SQUARE_COLOR },
-    { "premoveHighlightColor", "premoveHighlightColor", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
-       XtRString, PREMOVE_HIGHLIGHT_COLOR },
-    { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
-       (XtPointer) MOVES_PER_SESSION },
-    { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
-       (XtPointer) TIME_INCREMENT },
-    { "initString", "initString", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
-    { "secondInitString", "secondInitString", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
-    { "firstComputerString", "firstComputerString", XtRString,
-        sizeof(String),        XtOffset(AppDataPtr, firstComputerString), XtRString,
-      COMPUTER_STRING },
-    { "secondComputerString", "secondComputerString", XtRString,
-        sizeof(String),        XtOffset(AppDataPtr, secondComputerString), XtRString,
-      COMPUTER_STRING },
-    { "firstChessProgram", "firstChessProgram", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
-       XtRString, FIRST_CHESS_PROGRAM },
-    { "secondChessProgram", "secondChessProgram", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
-       XtRString, SECOND_CHESS_PROGRAM },
-    { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
-       XtRImmediate, (XtPointer) False },
-    { "noChessProgram", "noChessProgram", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
-       XtRImmediate, (XtPointer) False },
-    { "firstHost", "firstHost", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
-    { "secondHost", "secondHost", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
-    { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
-    { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
-    { "bitmapDirectory", "bitmapDirectory", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
-       XtRString, "" },
-    { "remoteShell", "remoteShell", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
-    { "remoteUser", "remoteUser", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, remoteUser), XtRString, "" },
-    { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
-       XtOffset(AppDataPtr, timeDelay), XtRString,
-       (XtPointer) TIME_DELAY_QUOTE },
-    { "timeControl", "timeControl", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, timeControl), XtRString,
-       (XtPointer) TIME_CONTROL },
-    { "internetChessServerMode", "internetChessServerMode",
-       XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, icsActive), XtRImmediate,
-       (XtPointer) False },
-    { "internetChessServerHost", "internetChessServerHost",
-       XtRString, sizeof(String),
-       XtOffset(AppDataPtr, icsHost),
-       XtRString, (XtPointer) ICS_HOST },
-    { "internetChessServerPort", "internetChessServerPort",
-       XtRString, sizeof(String),
-       XtOffset(AppDataPtr, icsPort), XtRString,
-       (XtPointer) ICS_PORT },
-    { "internetChessServerCommPort", "internetChessServerCommPort",
-       XtRString, sizeof(String),
-       XtOffset(AppDataPtr, icsCommPort), XtRString,
-       ICS_COMM_PORT },
-    { "internetChessServerLogonScript", "internetChessServerLogonScript",
-       XtRString, sizeof(String),
-       XtOffset(AppDataPtr, icsLogon), XtRString,
-       ICS_LOGON },
-    { "internetChessServerHelper", "internetChessServerHelper",
-       XtRString, sizeof(String),
-       XtOffset(AppDataPtr, icsHelper), XtRString, "" },
-    { "internetChessServerInputBox", "internetChessServerInputBox",
-       XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
-       (XtPointer) False },
-    { "icsAlarm", "icsAlarm",
-       XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
-       (XtPointer) True },
-    { "icsAlarmTime", "icsAlarmTime",
-       XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
-       (XtPointer) 5000 },
-    { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, useTelnet), XtRImmediate,
-       (XtPointer) False },
-    { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
-    { "gateway", "gateway", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, gateway), XtRString, "" },
-    { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
-    { "loadGameIndex", "loadGameIndex",
-       XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
-       (XtPointer) 0 },
-    { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
-    { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
-       XtRImmediate, (XtPointer) True },
-    { "autoSaveGames", "autoSaveGames", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
-       XtRImmediate, (XtPointer) False },
-    { "blindfold", "blindfold", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
-       XtRImmediate, (XtPointer) False },
-    { "loadPositionFile", "loadPositionFile", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
-       XtRString, "" },
-    { "loadPositionIndex", "loadPositionIndex",
-       XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
-       (XtPointer) 1 },
-    { "savePositionFile", "savePositionFile", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, savePositionFile),
-       XtRString, "" },
-    { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
-    { "matchGames", "matchGames", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, matchGames), XtRImmediate,
-       (XtPointer) 0 },
-    { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, monoMode), XtRImmediate,
-       (XtPointer) False },
-    { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, debugMode), XtRImmediate,
-       (XtPointer) False },
-    { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, clockMode), XtRImmediate,
-       (XtPointer) True },
-    { "boardSize", "boardSize", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, boardSize), XtRString, "" },
-    { "searchTime", "searchTime", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, searchTime), XtRString,
-       (XtPointer) "" },
-    { "searchDepth", "searchDepth", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, searchDepth), XtRImmediate,
-       (XtPointer) 0 },
-    { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, showCoords), XtRImmediate,
-       (XtPointer) False },
-    { "showJail", "showJail", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, showJail), XtRImmediate,
-       (XtPointer) 0 },
-    { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, showThinking), XtRImmediate,
-       (XtPointer) True },
-    { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
-       (XtPointer) True },
-    { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
-       (XtPointer) True },
-    { "clockFont", "clockFont", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
-    { "coordFont", "coordFont", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
-    { "font", "font", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
-    { "ringBellAfterMoves", "ringBellAfterMoves",
-       XtRBoolean, sizeof(Boolean),
-       XtOffset(AppDataPtr, ringBellAfterMoves),
-       XtRImmediate, (XtPointer) False },
-    { "autoCallFlag", "autoCallFlag", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
-       XtRImmediate, (XtPointer) False },
-    { "autoFlipView", "autoFlipView", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
-       XtRImmediate, (XtPointer) True },
-    { "autoObserve", "autoObserve", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
-       XtRImmediate, (XtPointer) False },
-    { "autoComment", "autoComment", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
-       XtRImmediate, (XtPointer) False },
-    { "getMoveList", "getMoveList", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
-       XtRImmediate, (XtPointer) True },
-#if HIGHDRAG
-    { "highlightDragging", "highlightDragging", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
-       XtRImmediate, (XtPointer) False },
-#endif
-    { "highlightLastMove", "highlightLastMove", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
-       XtRImmediate, (XtPointer) False },
-    { "premove", "premove", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, premove),
-        XtRImmediate, (XtPointer) True },
-    { "testLegality", "testLegality", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
-       XtRImmediate, (XtPointer) True },
-    { "flipView", "flipView", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, flipView),
-       XtRImmediate, (XtPointer) False },
-    { "cmail", "cmailGameName", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
-    { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
-       XtRImmediate, (XtPointer) False },
-    { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
-       XtRImmediate, (XtPointer) False },
-    { "quietPlay", "quietPlay", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
-       XtRImmediate, (XtPointer) False },
-    { "titleInWindow", "titleInWindow", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
-       XtRImmediate, (XtPointer) False },
-    { "localLineEditing", "localLineEditing", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
-       XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
-#ifdef ZIPPY
-    { "zippyTalk", "zippyTalk", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
-       XtRImmediate, (XtPointer) ZIPPY_TALK },
-    { "zippyPlay", "zippyPlay", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
-       XtRImmediate, (XtPointer) ZIPPY_PLAY },
-    { "zippyLines", "zippyLines", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
-    { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
-        XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
-    { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
-    { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
-    { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
-        ZIPPY_WRONG_PASSWORD },
-    { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
-    { "zippyUseI", "zippyUseI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
-        XtRImmediate, (XtPointer) ZIPPY_USE_I },
-    { "zippyBughouse", "zippyBughouse", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
-       XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
-    { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
-        XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
-    { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
-    { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
-    { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
-       XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
-    { "zippyAbort", "zippyAbort", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
-       XtRImmediate, (XtPointer) ZIPPY_ABORT },
-    { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
-       XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
-    { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
-        (XtPointer) ZIPPY_MAX_GAMES },
-    { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
-        (XtPointer) ZIPPY_REPLAY_TIMEOUT },
-    { "zippyShortGame", "zippyShortGame", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, zippyShortGame), XtRImmediate,
-        (XtPointer) 0 },
-#endif
     { "flashCount", "flashCount", XtRInt, sizeof(int),
        XtOffset(AppDataPtr, flashCount), XtRImmediate,
        (XtPointer) FLASH_COUNT  },
-    { "flashRate", "flashRate", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, flashRate), XtRImmediate,
-       (XtPointer) FLASH_RATE },
-    { "pixmapDirectory", "pixmapDirectory", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
-       XtRString, "" },
-    { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
-       XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
-       (XtPointer) MS_LOGIN_DELAY },
-    { "colorizeMessages", "colorizeMessages", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, colorize),
-       XtRImmediate, (XtPointer) False },
-    { "colorShout", "colorShout", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorShout),
-       XtRString, COLOR_SHOUT },
-    { "colorSShout", "colorSShout", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorSShout),
-       XtRString, COLOR_SSHOUT },
-    { "colorChannel1", "colorChannel1", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorChannel1),
-       XtRString, COLOR_CHANNEL1 },
-    { "colorChannel", "colorChannel", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorChannel),
-       XtRString, COLOR_CHANNEL },
-    { "colorKibitz", "colorKibitz", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorKibitz),
-       XtRString, COLOR_KIBITZ },
-    { "colorTell", "colorTell", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorTell),
-       XtRString, COLOR_TELL },
-    { "colorChallenge", "colorChallenge", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorChallenge),
-       XtRString, COLOR_CHALLENGE },
-    { "colorRequest", "colorRequest", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorRequest),
-       XtRString, COLOR_REQUEST },
-    { "colorSeek", "colorSeek", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorSeek),
-       XtRString, COLOR_SEEK },
-    { "colorNormal", "colorNormal", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, colorNormal),
-       XtRString, COLOR_NORMAL },
-    { "soundProgram", "soundProgram", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundProgram),
-      XtRString, "play" },
-    { "soundShout", "soundShout", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundShout),
-      XtRString, "" },
-    { "soundSShout", "soundSShout", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundSShout),
-      XtRString, "" },
-    { "soundChannel1", "soundChannel1", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundChannel1),
-      XtRString, "" },
-    { "soundChannel", "soundChannel", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundChannel),
-      XtRString, "" },
-    { "soundKibitz", "soundKibitz", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundKibitz),
-      XtRString, "" },
-    { "soundTell", "soundTell", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundTell),
-      XtRString, "" },
-    { "soundChallenge", "soundChallenge", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundChallenge),
-      XtRString, "" },
-    { "soundRequest", "soundRequest", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundRequest),
-      XtRString, "" },
-    { "soundSeek", "soundSeek", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundSeek),
-      XtRString, "" },
-    { "soundMove", "soundMove", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundMove),
-      XtRString, "$" },
-    { "soundIcsWin", "soundIcsWin", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
-      XtRString, "" },
-    { "soundIcsLoss", "soundIcsLoss", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
-      XtRString, "" },
-    { "soundIcsDraw", "soundIcsDraw", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
-      XtRString, "" },
-    { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
-      XtRString, "" },
-    { "soundIcsAlarm", "soundIcsAlarm", XtRString,
-      sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
-      XtRString, "$" },
-    { "reuseFirst", "reuseFirst", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
-       XtRImmediate, (XtPointer) True },
-    { "reuseSecond", "reuseSecond", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
-       XtRImmediate, (XtPointer) True },
-    { "animateDragging", "animateDragging", XtRBoolean,
-        sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
-       XtRImmediate, (XtPointer) True },
-    { "animateMoving", "animateMoving", XtRBoolean,
-        sizeof(Boolean), XtOffset(AppDataPtr, animate),
-       XtRImmediate, (XtPointer) True },
-    { "animateSpeed", "animateSpeed", XtRInt,
-        sizeof(int), XtOffset(AppDataPtr, animSpeed),
-       XtRImmediate, (XtPointer)10 },
-    { "popupExitMessage", "popupExitMessage", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
-       XtRImmediate, (XtPointer) True },
-    { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
-       XtRImmediate, (XtPointer) False },
-    { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
-        sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
-       XtRImmediate, (XtPointer)4 },
-    { "initialMode", "initialMode", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, initialMode),
-       XtRImmediate, (XtPointer) "" },
-    { "variant", "variant", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, variant),
-       XtRImmediate, (XtPointer) "normal" },
-    { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
-        sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
-       XtRImmediate, (XtPointer)PROTOVER },
-    { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
-        sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
-       XtRImmediate, (XtPointer)PROTOVER },
-    { "showButtonBar", "showButtonBar", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
-       XtRImmediate, (XtPointer) True },
-    {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean,        /* [DM] icsEngineAnalyze */
-        sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
-        XtRImmediate, (XtPointer) False },
-    { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
-       XtRImmediate, (XtPointer) False },
-    { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
-       XtRImmediate, (XtPointer) False },
-    { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
-       XtRImmediate, (XtPointer) False },
-    { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
-       XtRImmediate, (XtPointer) True },
-    { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
-       XtRImmediate, (XtPointer) 0},
-    { "pgnEventHeader", "pgnEventHeader", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
-       XtRImmediate, (XtPointer) "Computer Chess Game" },
-    { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
-       XtRImmediate, (XtPointer) -1},
-    { "gameListTags", "gameListTags", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, gameListTags),
-       XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
-
-    // [HGM] 4.3.xx options
-    { "boardWidth", "boardWidth", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, NrFiles),
-       XtRImmediate, (XtPointer) -1},
-    { "boardHeight", "boardHeight", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, NrRanks),
-       XtRImmediate, (XtPointer) -1},
-    { "matchPause", "matchPause", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, matchPause),
-       XtRImmediate, (XtPointer) 10000},
-    { "holdingsSize", "holdingsSize", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, holdingsSize),
-       XtRImmediate, (XtPointer) -1},
-    { "flipBlack", "flipBlack", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
-       XtRImmediate, (XtPointer) False},
-    { "allWhite", "allWhite", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
-       XtRImmediate, (XtPointer) False},
-    { "pieceToCharTable", "pieceToCharTable", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
-       XtRImmediate, (XtPointer) 0},
-    { "alphaRank", "alphaRank", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
-       XtRImmediate, (XtPointer) False},
-    { "testClaims", "testClaims", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
-       XtRImmediate, (XtPointer) True},
-    { "checkMates", "checkMates", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
-       XtRImmediate, (XtPointer) True},
-    { "materialDraws", "materialDraws", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
-       XtRImmediate, (XtPointer) True},
-    { "trivialDraws", "trivialDraws", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
-       XtRImmediate, (XtPointer) False},
-    { "ruleMoves", "ruleMoves", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, ruleMoves),
-       XtRImmediate, (XtPointer) 51},
-    { "repeatsToDraw", "repeatsToDraw", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, drawRepeats),
-       XtRImmediate, (XtPointer) 6},
-    { "engineDebugOutput", "engineDebugOutput", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, engineComments),
-       XtRImmediate, (XtPointer) 1},
-    { "userName", "userName", XtRString,
-       sizeof(int), XtOffset(AppDataPtr, userName),
-       XtRImmediate, (XtPointer) 0},
-    { "autoKibitz", "autoKibitz", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
-       XtRImmediate, (XtPointer) False},
-    { "firstTimeOdds", "firstTimeOdds", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
-       XtRImmediate, (XtPointer) 1},
-    { "secondTimeOdds", "secondTimeOdds", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
-       XtRImmediate, (XtPointer) 1},
-    { "timeOddsMode", "timeOddsMode", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
-       XtRImmediate, (XtPointer) 0},
-    { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
-       XtRImmediate, (XtPointer) 1},
-    { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
-       XtRImmediate, (XtPointer) 1},
-    { "firstNPS", "firstNPS", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, firstNPS),
-       XtRImmediate, (XtPointer) -1},
-    { "secondNPS", "secondNPS", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, secondNPS),
-       XtRImmediate, (XtPointer) -1},
-    { "serverMoves", "serverMoves", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, serverMovesName),
-       XtRImmediate, (XtPointer) 0},
-    { "serverPause", "serverPause", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, serverPause),
-       XtRImmediate, (XtPointer) 0},
-    { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
-       XtRImmediate, (XtPointer) False},
-    { "userName", "userName", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, userName),
-       XtRImmediate, (XtPointer) 0},
-    { "egtFormats", "egtFormats", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, egtFormats),
-       XtRImmediate, (XtPointer) 0},
-    { "rewindIndex", "rewindIndex", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, rewindIndex),
-       XtRImmediate, (XtPointer) 0},
-    { "sameColorGames", "sameColorGames", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, sameColorGames),
-       XtRImmediate, (XtPointer) 0},
-    { "smpCores", "smpCores", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, smpCores),
-       XtRImmediate, (XtPointer) 1},
-    { "niceEngines", "niceEngines", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, niceEngines),
-       XtRImmediate, (XtPointer) 0},
-    { "nameOfDebugFile", "nameOfDebugFile", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
-       XtRImmediate, (XtPointer) "xboard.debug"},
-    { "engineDebugOutput", "engineDebugOutput", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, engineComments),
-       XtRImmediate, (XtPointer) 0},
-    { "noGUI", "noGUI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
-       XtRImmediate, (XtPointer) 0},
-    { "firstOptions", "firstOptions", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, firstOptions),
-       XtRImmediate, (XtPointer) "" },
-    { "secondOptions", "secondOptions", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, secondOptions),
-       XtRImmediate, (XtPointer) "" },
-    { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, fenOverride1),
-       XtRImmediate, (XtPointer) 0 },
-    { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, fenOverride2),
-       XtRImmediate, (XtPointer) 0 },
-
-    // [HGM] Winboard_x UCI options
-    { "firstIsUCI", "firstIsUCI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
-       XtRImmediate, (XtPointer) False},
-    { "secondIsUCI", "secondIsUCI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
-       XtRImmediate, (XtPointer) False},
-    { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
-       XtRImmediate, (XtPointer) True},
-    { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
-       XtRImmediate, (XtPointer) True},
-    { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
-       sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
-       XtRImmediate, (XtPointer) False},
-    { "defaultHashSize", "defaultHashSize", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
-       XtRImmediate, (XtPointer) 64},
-    { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
-       XtRImmediate, (XtPointer) 4},
-    { "polyglotDir", "polyglotDir", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, polyglotDir),
-       XtRImmediate, (XtPointer) "." },
-    { "polyglotBook", "polyglotBook", XtRString,
-        sizeof(String), XtOffset(AppDataPtr, polyglotBook),
-       XtRImmediate, (XtPointer) "" },
-    { "defaultPathEGTB", "defaultPathEGTB", XtRString,
-       sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
-       XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
-    { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
-       XtRImmediate, (XtPointer) 0},
-    { "delayAfterQuit", "delayAfterQuit", XtRInt,
-       sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
-       XtRImmediate, (XtPointer) 0},
 };
 
 XrmOptionDescRec shellOptions[] = {
-    { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
-    { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
-    { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
-    { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
-    { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
-    { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
-    { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
-    { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
-    { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
-    { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
-    { "-initString", "initString", XrmoptionSepArg, NULL },
-    { "-firstInitString", "initString", XrmoptionSepArg, NULL },
-    { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
-    { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
-    { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
-    { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
-    { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
-    { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
-    { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
-    { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
-    { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
-    { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
-    { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
-    { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
-    { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
-    { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
-    { "-fh", "firstHost", XrmoptionSepArg, NULL },
-    { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
-    { "-sh", "secondHost", XrmoptionSepArg, NULL },
-    { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
-    { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
-    { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
-    { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
-    { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
-    { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
-    { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
-    { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
-    { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
-    { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
-    { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
-    { "-td", "timeDelay", XrmoptionSepArg, NULL },
-    { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
-    { "-tc", "timeControl", XrmoptionSepArg, NULL },
-    { "-internetChessServerMode", "internetChessServerMode",
-       XrmoptionSepArg, NULL },
-    { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
-    { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
-    { "-internetChessServerHost", "internetChessServerHost",
-       XrmoptionSepArg, NULL },
-    { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
-    { "-internetChessServerPort", "internetChessServerPort",
-       XrmoptionSepArg, NULL },
-    { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
-    { "-internetChessServerCommPort", "internetChessServerCommPort",
-       XrmoptionSepArg, NULL },
-    { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
-    { "-internetChessServerLogonScript", "internetChessServerLogonScript",
-       XrmoptionSepArg, NULL },
-    { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
-    { "-internetChessServerHelper", "internetChessServerHelper",
-       XrmoptionSepArg, NULL },
-    { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
-    { "-internetChessServerInputBox", "internetChessServerInputBox",
-       XrmoptionSepArg, NULL },
-    { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
-    { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
-    { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
-    { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
-    { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
-    { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
-    { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
-    { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
-    { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
-    { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
-    { "-gateway", "gateway", XrmoptionSepArg, NULL },
-    { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
-    { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
-    { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
-    { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
-    { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
-    { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
-    { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
-    { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
-    { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
-    { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
-    { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
-    { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
-    { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
-    { "-blind", "blindfold", XrmoptionNoArg, "True" },
-    { "-xblind", "blindfold", XrmoptionNoArg, "False" },
-    { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
-    { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
-    { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
-    { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
-    { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
-    { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
-    { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
-    { "-mm", "matchMode", XrmoptionNoArg, "True" },
-    { "-xmm", "matchMode", XrmoptionNoArg, "False" },
-    { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
-    { "-mg", "matchGames", XrmoptionSepArg, NULL },
-    { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
-    { "-mono", "monoMode", XrmoptionNoArg, "True" },
-    { "-xmono", "monoMode", XrmoptionNoArg, "False" },
-    { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
-    { "-debug", "debugMode", XrmoptionNoArg, "True" },
-    { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
-    { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
-    { "-clock", "clockMode", XrmoptionNoArg, "True" },
-    { "-xclock", "clockMode", XrmoptionNoArg, "False" },
-    { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
-    { "-size", "boardSize", XrmoptionSepArg, NULL },
-    { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
-    { "-st", "searchTime", XrmoptionSepArg, NULL },
-    { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
-    { "-depth", "searchDepth", XrmoptionSepArg, NULL },
-    { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
-    { "-coords", "showCoords", XrmoptionNoArg, "True" },
-    { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
-#if JAIL
-    { "-showJail", "showJail", XrmoptionSepArg, NULL },
-    { "-jail", "showJail", XrmoptionNoArg, "1" },
-    { "-sidejail", "showJail", XrmoptionNoArg, "2" },
-    { "-xjail", "showJail", XrmoptionNoArg, "0" },
-#endif
-    { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
-    { "-thinking", "showThinking", XrmoptionNoArg, "True" },
-    { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
-    { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
-    { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
-    { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
-    { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
-    { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
-    { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
-    { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
-    { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
-    { "-font", "font", XrmoptionSepArg, NULL },
-    { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
-    { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
-    { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
-    { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
-    { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
-    { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
-    { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
-    { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
-    { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
-    { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
-    { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
-    { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
-    { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
-    { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
-    { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
-    { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
-    { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
-    { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
-    { "-moves", "getMoveList", XrmoptionNoArg, "True" },
-    { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
-#if HIGHDRAG
-    { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
-    { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
-    { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
-#endif
-    { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
-    { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
-    { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
-    { "-premove", "premove", XrmoptionSepArg, NULL },
-    { "-pre", "premove", XrmoptionNoArg, "True" },
-    { "-xpre", "premove", XrmoptionNoArg, "False" },
-    { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
-    { "-legal", "testLegality", XrmoptionNoArg, "True" },
-    { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
-    { "-flipView", "flipView", XrmoptionSepArg, NULL },
-    { "-flip", "flipView", XrmoptionNoArg, "True" },
-    { "-xflip", "flipView", XrmoptionNoArg, "False" },
-    { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
-    { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
-       XrmoptionSepArg, NULL },
-    { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
-    { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
-    { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
-    { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
-    { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
-    { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
-    { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
-    { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
-    { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
-    { "-title", "titleInWindow", XrmoptionNoArg, "True" },
-    { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
-#ifdef ZIPPY
-    { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
-    { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
-    { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
-    { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
-    { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
-    { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
-    { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
-    { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
-    { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
-    { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
-    { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
-    { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
-    { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
-    { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
-    { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
-    { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
-    { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
-    { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
-    { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
-    { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
-    { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
-    { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
-    { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
-    { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
-    { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
-    { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
-    { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
-    { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
-    { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
-    { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
-    { "-zippyShortGame", "zippyShortGame", XrmoptionSepArg, NULL },
-#endif
     { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
     { "-flash", "flashCount", XrmoptionNoArg, "3" },
     { "-xflash", "flashCount", XrmoptionNoArg, "0" },
-    { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
-    { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
-    { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
-    { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
-    { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
-    { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
-    { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
-    { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
-    { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
-    { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
-    { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
-    { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
-    { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
-    { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
-    { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
-    { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
-    { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
-    { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
-    { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
-    { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
-    { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
-    { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
-    { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
-    { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
-    { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
-    { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
-    { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
-    { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
-    { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
-    { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
-    { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
-    { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
-    { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
-    { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
-    { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
-    { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
-    { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
-    { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
-    { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
-    { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
-    { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
-    { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
-    { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
-    { "-animate", "animateMoving", XrmoptionNoArg, "True" },
-    { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
-    { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
-    { "-drag", "animateDragging", XrmoptionNoArg, "True" },
-    { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
-    { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
-    { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
-    { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
-    { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
-    { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
-    { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
-    { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
-    { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
-    { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
-    { "-mode", "initialMode", XrmoptionSepArg, NULL },
-    { "-variant", "variant", XrmoptionSepArg, NULL },
-    { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
-    { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
-    { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
-    { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
-    { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
-    /* [AS,HR] New features */
-    { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
-    { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
-    { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
-    { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
-    { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
-    { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },
-    { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },
-    { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },
-    { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },
-    { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },
-    { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },
-    { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },
-    { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
-    { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
-    { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
-    { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
-    { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },
-    { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },
-    { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },
-    { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },
-    { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },
-    { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },
-    { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },
-    { "-gameListTags", "gameListTags", XrmoptionSepArg, NULL },
-    // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c
-
-    /* [HGM,HR] User-selectable board size */
-    { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
-    { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
-    { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
-
-    /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */
-    { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work
-    { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL },       // requires front-end changes to work
-    { "-allWhite", "allWhite", XrmoptionSepArg, NULL },         // requires front-end changes to work
-    { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL },
-    { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL },
-    { "-testClaims", "testClaims", XrmoptionSepArg, NULL },
-    { "-checkMates", "checkMates", XrmoptionSepArg, NULL },
-    { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL },
-    { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL },
-    { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL },
-    { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },
-    { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
-    { "-userName", "userName", XrmoptionSepArg, NULL },
-    { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" },
-    { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL },
-    { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL },
-    { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL },
-    { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL },
-    { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL },
-    { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL },
-    { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL },
-    { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL },
-    { "-serverPause", "serverPause", XrmoptionSepArg, NULL },
-    { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL },
-    { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL },
-    { "-userName", "userName", XrmoptionSepArg, NULL },
-    { "-smpCores", "smpCores", XrmoptionSepArg, NULL },
-    { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL },
-    { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL },
-    { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL },
-    { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL },
-    { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL },
-    { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
-    { "-debugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
-    { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
-    { "-noGUI", "noGUI", XrmoptionNoArg, "True" },
-    { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL },
-    { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL },
-    { "-firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
-    { "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
 };
 
-
 XtActionsRec boardActions[] = {
     { "DrawPosition", DrawPositionProc },
     { "HandleUserMove", HandleUserMove },
@@ -1789,6 +867,7 @@ XtActionsRec boardActions[] = {
     { "EditPositionProc", EditPositionProc },
     { "TrainingProc", EditPositionProc },
     { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
+    { "EvalGraphProc", EvalGraphProc},       // [HGM] Winboard_x avaluation graph window
     { "ShowGameListProc", ShowGameListProc },
     { "ShowMoveListProc", HistoryShowProc},
     { "EditTagsProc", EditCommentProc },
@@ -1847,6 +926,8 @@ XtActionsRec boardActions[] = {
     { "ShowThinkingProc", ShowThinkingProc },
     { "HideThinkingProc", HideThinkingProc },
     { "TestLegalityProc", TestLegalityProc },
+    { "SaveSettingsProc", SaveSettingsProc },
+    { "SaveOnExitProc", SaveOnExitProc },
     { "InfoProc", InfoProc },
     { "ManProc", ManProc },
     { "HintProc", HintProc },
@@ -1860,13 +941,13 @@ XtActionsRec boardActions[] = {
     { "TagsPopDown", (XtActionProc) TagsPopDown },
     { "ErrorPopDown", (XtActionProc) ErrorPopDown },
     { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
-    { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
     { "FileNamePopDown", (XtActionProc) FileNamePopDown },
     { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
     { "GameListPopDown", (XtActionProc) GameListPopDown },
     { "PromotionPopDown", (XtActionProc) PromotionPopDown },
     { "HistoryPopDown", (XtActionProc) HistoryPopDown },
     { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+    { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
     { "ShufflePopDown", (XtActionProc) ShufflePopDown },
     { "EnginePopDown", (XtActionProc) EnginePopDown },
     { "UciPopDown", (XtActionProc) UciPopDown },
@@ -2162,6 +1243,258 @@ BoardToTop()
   XtPopup(shellWidget, XtGrabNone); /* Raise if lowered  */
 }
 
+//---------------------------------------------------------------------------------------------------------
+// some symbol definitions to provide the proper (= XBoard) context for the code in args.h
+#define XBOARD True
+#define JAWS_ARGS
+#define CW_USEDEFAULT (1<<31)
+#define ICS_TEXT_MENU_SIZE 90
+#define DEBUG_FILE "xboard.debug"
+#define SetCurrentDirectory chdir
+#define GetCurrentDirectory(SIZE, NAME) getcwd(NAME, SIZE)
+#define OPTCHAR "-"
+#define SEPCHAR " "
+
+// these two must some day move to frontend.h, when they are implemented
+Boolean MoveHistoryIsUp();
+Boolean GameListIsUp();
+
+// The option definition and parsing code common to XBoard and WinBoard is collected in this file
+#include "args.h"
+
+// front-end part of option handling
+
+// [HGM] This platform-dependent table provides the location for storing the color info
+extern char *crWhite, * crBlack;
+
+void *
+colorVariable[] = {
+  &appData.whitePieceColor, 
+  &appData.blackPieceColor, 
+  &appData.lightSquareColor,
+  &appData.darkSquareColor, 
+  &appData.highlightSquareColor,
+  &appData.premoveHighlightColor,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  &crWhite,
+  &crBlack,
+  NULL
+};
+
+void
+ParseFont(char *name, int number)
+{ // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
+  switch(number) {
+    case 0: // CLOCK_FONT
+       appData.clockFont = strdup(name);
+      break;
+    case 1: // MESSAGE_FONT
+       appData.font = strdup(name);
+      break;
+    case 2: // COORD_FONT
+       appData.coordFont = strdup(name);
+      break;
+    default:
+      return;
+  }
+}
+
+void
+SetFontDefaults()
+{ // only 2 fonts currently
+  appData.clockFont = CLOCK_FONT_NAME;
+  appData.coordFont = COORD_FONT_NAME;
+  appData.font  =   DEFAULT_FONT_NAME;
+}
+
+void
+CreateFonts()
+{ // no-op, until we identify the code for this already in XBoard and move it here
+}
+
+void
+ParseColor(int n, char *name)
+{ // in XBoard, just copy the color-name string
+  if(colorVariable[n]) *(char**)colorVariable[n] = strdup(name);
+}
+
+void
+ParseTextAttribs(ColorClass cc, char *s)
+{   
+    (&appData.colorShout)[cc] = strdup(s);
+}
+
+void
+ParseBoardSize(void *addr, char *name)
+{
+    appData.boardSize = strdup(name);
+}
+
+void
+LoadAllSounds()
+{ // In XBoard the sound-playing program takes care of obtaining the actual sound
+}
+
+void
+SetCommPortDefaults()
+{ // for now, this is a no-op, as the corresponding option does not exist in XBoard
+}
+
+// [HGM] args: these three cases taken out to stay in front-end
+void
+SaveFontArg(FILE *f, ArgDescriptor *ad)
+{
+  char *name;
+  switch((int)ad->argLoc) {
+    case 0: // CLOCK_FONT
+       name = appData.clockFont;
+      break;
+    case 1: // MESSAGE_FONT
+       name = appData.font;
+      break;
+    case 2: // COORD_FONT
+       name = appData.coordFont;
+      break;
+    default:
+      return;
+  }
+//  Do not save fonts for now, as the saved font would be board-size specific
+//  and not suitable for a re-start at another board size
+//  fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, name); 
+}
+
+void
+ExportSounds()
+{ // nothing to do, as the sounds are at all times represented by their text-string names already
+}
+
+void
+SaveAttribsArg(FILE *f, ArgDescriptor *ad)
+{      // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
+       fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)ad->argLoc]);
+}
+
+void
+SaveColor(FILE *f, ArgDescriptor *ad)
+{      // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
+       if(colorVariable[(int)ad->argLoc])
+       fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)ad->argLoc]);
+}
+
+void
+SaveBoardSize(FILE *f, char *name, void *addr)
+{ // wrapper to shield back-end from BoardSize & sizeInfo
+  fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
+}
+
+void
+ParseCommPortSettings(char *s)
+{ // no such option in XBoard (yet)
+}
+
+extern Widget engineOutputShell;
+extern Widget tagsShell, editTagsShell;
+void
+GetActualPlacement(Widget wg, WindowPlacement *wp)
+{
+  Arg args[16];
+  Dimension w, h;
+  Position x, y;
+  int i;
+
+  if(!wg) return;
+  
+    i = 0;
+    XtSetArg(args[i], XtNx, &x); i++;
+    XtSetArg(args[i], XtNy, &y); i++;
+    XtSetArg(args[i], XtNwidth, &w); i++;
+    XtSetArg(args[i], XtNheight, &h); i++;
+    XtGetValues(wg, args, i);
+    wp->x = x - 4;
+    wp->y = y - 23;
+    wp->height = h;
+    wp->width = w;
+}
+
+void
+GetWindowCoords()
+{ // wrapper to shield use of window handles from back-end (make addressible by number?)
+  // In XBoard this will have to wait until awareness of window parameters is implemented
+  GetActualPlacement(shellWidget, &wpMain);
+  if(EngineOutputIsUp()) GetActualPlacement(engineOutputShell, &wpEngineOutput); else
+  if(MoveHistoryIsUp()) GetActualPlacement(historyShell, &wpMoveHistory);
+  if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
+  if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
+  if(commentShell) GetActualPlacement(commentShell, &wpComment);
+  else             GetActualPlacement(editShell,    &wpComment);
+  if(tagsShell) GetActualPlacement(tagsShell, &wpTags);
+  else      GetActualPlacement(editTagsShell, &wpTags);
+}
+
+void
+PrintCommPortSettings(FILE *f, char *name)
+{ // This option does not exist in XBoard
+}
+
+int
+MySearchPath(char *installDir, char *name, char *fullname)
+{ // just append installDir and name. Perhaps ExpandPath should be used here?
+  name = ExpandPathName(name);
+  if(name && name[0] == '/') strcpy(fullname, name); else {
+    sprintf(fullname, "%s%c%s", installDir, '/', name);
+  }
+  return 1;
+}
+
+int
+MyGetFullPathName(char *name, char *fullname)
+{ // should use ExpandPath?
+  name = ExpandPathName(name);
+  strcpy(fullname, name);
+  return 1;
+}
+
+void
+EnsureOnScreen(int *x, int *y, int minX, int minY)
+{
+  return;
+}
+
+int
+MainWindowUp()
+{ // [HGM] args: allows testing if main window is realized from back-end
+  return xBoardWindow != 0;
+}
+
+void
+PopUpStartupDialog()
+{  // start menu not implemented in XBoard
+}
+char *
+ConvertToLine(int argc, char **argv)
+{
+  static char line[128*1024], buf[1024];
+  int i;
+
+  line[0] = NULLCHAR;
+  for(i=1; i<argc; i++) {
+    if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
+       && argv[i][0] != '{' )
+         sprintf(buf, "{%s} ", argv[i]);
+    else sprintf(buf, "%s ", argv[i]);
+    strcat(line, buf);
+  }
+    line[strlen(line)-1] = NULLCHAR;
+  return line;
+}
+
+//--------------------------------------------------------------------------------------------
+
 #ifdef IDSIZES
   // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
 #else
@@ -2235,9 +1568,82 @@ void InitDrawingSizes(BoardSize boardSize, int flags)
     shellArgs[4].value = shellArgs[2].value = w;
     shellArgs[5].value = shellArgs[3].value = h;
     XtSetValues(shellWidget, &shellArgs[0], 6);
+
+    // [HGM] pieces: tailor piece bitmaps to needs of specific variant
+    // (only for xpm)
+    if(useImages) {
+      for(i=0; i<4; i++) {
+       int p;
+       for(p=0; p<=(int)WhiteKing; p++)
+          xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
+       if(gameInfo.variant == VariantShogi) {
+          xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
+          xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
+          xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
+          xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
+          xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
+       }
+#ifdef GOTHIC
+       if(gameInfo.variant == VariantGothic) {
+          xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
+       }
+#endif
+#if !HAVE_LIBXPM
+       // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
+       for(p=0; p<=(int)WhiteKing; p++)
+          ximMaskPm[p] = ximMaskPm2[p]; // defaults
+       if(gameInfo.variant == VariantShogi) {
+          ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
+          ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
+          ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
+          ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
+          ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
+       }
+#ifdef GOTHIC
+       if(gameInfo.variant == VariantGothic) {
+           ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
+       }
+#endif
+#endif
+      }
+    } else {
+      for(i=0; i<2; i++) {
+       int p;
+       for(p=0; p<=(int)WhiteKing; p++)
+          pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
+       if(gameInfo.variant == VariantShogi) {
+          pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
+          pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
+          pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
+          pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
+          pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
+       }
+#ifdef GOTHIC
+       if(gameInfo.variant == VariantGothic) {
+          pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
+       }
+#endif
+      }
+    }
+#if HAVE_LIBXPM
+    CreateAnimVars();
+#endif
 }
 #endif
 
+void EscapeExpand(char *p, char *q)
+{      // [HGM] initstring: routine to shape up string arguments
+       while(*p++ = *q++) if(p[-1] == '\\')
+           switch(*q++) {
+               case 'n': p[-1] = '\n'; break;
+               case 'r': p[-1] = '\r'; break;
+               case 't': p[-1] = '\t'; break;
+               case '\\': p[-1] = '\\'; break;
+               case 0: *p = 0; return;
+               default: p[-1] = q[-1]; break;
+           }
+}
+
 int
 main(argc, argv)
      int argc;
@@ -2252,55 +1658,18 @@ main(argc, argv)
     char *p;
     XrmDatabase xdb;
     int forceMono = False;
-#define INDIRECTION
-#ifdef INDIRECTION
-    // [HGM] before anything else, expand any indirection files amongst options
-    char *argvCopy[1000]; // 1000 seems enough
-    char newArgs[10000];  // holds actual characters
-    int k = 0;
 
     srandom(time(0)); // [HGM] book: make random truly random
 
-    j = 0;
-    for(i=0; i<argc; i++) {
-       if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
-//fprintf(stderr, "arg %s\n", argv[i]);
-       if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
-           char c;
-           FILE *f = fopen(argv[i]+1, "rb");
-           if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
-           argvCopy[j++] = newArgs + k; // get ready for first argument from file
-           while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
-               if(c == '\n') {
-                   if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
-                   newArgs[k++] = 0;  // terminate current arg
-                   if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
-                   argvCopy[j++] = newArgs + k; // get ready for next
-               } else {
-                   if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
-                   newArgs[k++] = c;
-               }
-           }
-           newArgs[k] = 0;
-           j--;
-           fclose(f);
-       }
-    }
-    argvCopy[j] = NULL;
-    argv = argvCopy;
-    argc = j;
-#if 0
-    if(appData.debugMode,1) { // OK, appData is not initialized here yet...
-       for(i=0; i<argc; i++) fprintf(stderr, "argv[%2d] = '%s'\n", i, argv[i]);
-    }
-#endif
-#endif
-
-
     setbuf(stdout, NULL);
     setbuf(stderr, NULL);
     debugFP = stderr;
 
+    if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
+       printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+       exit(0);
+    }
+
     programName = strrchr(argv[0], '/');
     if (programName == NULL)
       programName = argv[0];
@@ -2309,30 +1678,16 @@ main(argc, argv)
 
 #ifdef ENABLE_NLS
     XtSetLanguageProc(NULL, NULL, NULL);
-    bindtextdomain(PRODUCT, LOCALEDIR);
-    textdomain(PRODUCT);
+    bindtextdomain(PACKAGE, LOCALEDIR);
+    textdomain(PACKAGE);
 #endif
 
     shellWidget =
       XtAppInitialize(&appContext, "XBoard", shellOptions,
                      XtNumber(shellOptions),
                      &argc, argv, xboardResources, NULL, 0);
-    if (argc > 1) {
-       fprintf(stderr, _("%s: unrecognized argument %s\n"),
-               programName, argv[1]);
-       exit(2);
-    }
-
-    if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
-       chessDir = ".";
-    } else {
-       if (chdir(chessDir) != 0) {
-           fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
-           perror(chessDir);
-           exit(1);
-       }
-    }
-
+    appData.boardSize = "";
+    InitAppData(ConvertToLine(argc, argv));
     p = getenv("HOME");
     if (p == NULL) p = "/tmp";
     i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
@@ -2345,6 +1700,28 @@ main(argc, argv)
                              clientResources, XtNumber(clientResources),
                              NULL, 0);
 
+    { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
+       static char buf[MSG_SIZ];
+       EscapeExpand(buf, appData.initString);
+       appData.initString = strdup(buf);
+       EscapeExpand(buf, appData.secondInitString);
+       appData.secondInitString = strdup(buf);
+       EscapeExpand(buf, appData.firstComputerString);
+       appData.firstComputerString = strdup(buf);
+       EscapeExpand(buf, appData.secondComputerString);
+       appData.secondComputerString = strdup(buf);
+    }
+
+    if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
+       chessDir = ".";
+    } else {
+       if (chdir(chessDir) != 0) {
+           fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
+           perror(chessDir);
+           exit(1);
+       }
+    }
+
     if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
        /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
         if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL)  {
@@ -2355,9 +1732,9 @@ main(argc, argv)
     }
 
     /* [HGM,HR] make sure board size is acceptable */
-    if(appData.NrFiles > BOARD_SIZE ||
-       appData.NrRanks > BOARD_SIZE   )
-        DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
+    if(appData.NrFiles > BOARD_FILES ||
+       appData.NrRanks > BOARD_RANKS   )
+        DisplayFatalError(_("Recompile with larger BOARD_RANKS or BOARD_FILES to support this size"), 0, 2);
 
 #if !HIGHDRAG
     /* This feature does not work; animation needs a rewrite */
@@ -2371,19 +1748,6 @@ main(argc, argv)
 
        gameInfo.variant = StringToVariant(appData.variant);
        InitPosition(FALSE);
-#if 0
-    /*
-     * Determine boardSize
-     */
-    gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8
-
-//#ifndef IDSIZE
-    // [HGM] as long as we have not created the possibility to change size while running, start with requested size
-    gameInfo.boardWidth    = appData.NrFiles > 0 ? appData.NrFiles : 8;
-    gameInfo.boardHeight   = appData.NrRanks > 0 ? appData.NrRanks : 8;
-    gameInfo.holdingsWidth = appData.holdingsSize > 0 ? 2 : 0;
-#endif
-
 
 #ifdef IDSIZE
     InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
@@ -2425,6 +1789,7 @@ main(argc, argv)
              szd++;
            }
            if (szd->name == NULL) szd--;
+           appData.boardSize = strdup(szd->name); // [HGM] settings: remember name for saving settings
        } else {
            while (szd->name != NULL &&
                   StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
@@ -2577,6 +1942,20 @@ XBoard square size (hint): %d\n\
     if (forceMono) {
       fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
              programName);
+      
+      if (appData.bitmapDirectory == NULL ||
+             appData.bitmapDirectory[0] == NULLCHAR)
+           appData.bitmapDirectory = DEF_BITMAP_DIR;
+    }
+
+    if (appData.lowTimeWarning && !appData.monoMode) {
+      vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
+      vFrom.size = strlen(appData.lowTimeWarningColor);
+      XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+      if (vTo.addr == NULL) 
+               appData.monoMode = True;
+      else
+               lowTimeWarningColor = *(Pixel *) vTo.addr;
     }
 
     if (appData.monoMode && appData.debugMode) {
@@ -2633,7 +2012,8 @@ XBoard square size (hint): %d\n\
     widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
     XtSetArg(args[0], XtNtop,    XtChainTop);
     XtSetArg(args[1], XtNbottom, XtChainTop);
-    XtSetValues(menuBarWidget, args, 2);
+    XtSetArg(args[2], XtNright,  XtChainLeft);
+    XtSetValues(menuBarWidget, args, 3);
 
     widgetList[j++] = whiteTimerWidget =
       XtCreateWidget("whiteTime", labelWidgetClass,
@@ -2778,6 +2158,12 @@ XBoard square size (hint): %d\n\
 
     XtRealizeWidget(shellWidget);
 
+    if(wpMain.x > 0) {
+      XtSetArg(args[0], XtNx, wpMain.x);
+      XtSetArg(args[1], XtNy, wpMain.y);
+      XtSetValues(shellWidget, args, 2);
+    }
+
     /*
      * Correct the width of the message and title widgets.
      * It is not known why some systems need the extra fudge term.
@@ -2971,6 +2357,10 @@ XBoard square size (hint): %d\n\
        XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
                    args, 1);
     }
+    if (saveSettingsOnExit) {
+       XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Save Settings on Exit"),
+                   args, 1);
+    }
 
     /*
      * Create an icon.
@@ -3039,6 +2429,20 @@ XBoard square size (hint): %d\n\
                      (XtEventHandler) EventProc, NULL);
     /* end why */
 
+    /* [AS] Restore layout */
+    if( wpMoveHistory.visible ) {
+      HistoryPopUp();
+    }
+
+    if( wpEvalGraph.visible ) 
+      {
+       EvalGraphPopUp();
+      };
+    
+    if( wpEngineOutput.visible ) {
+      EngineOutputPopUp();
+    }
+
     InitBackEnd2();
 
     if (errorExitStatus == -1) {
@@ -3049,13 +2453,17 @@ XBoard square size (hint): %d\n\
            if (appData.icsInputBox) ICSInputBoxPopUp();
        }
 
+    #ifdef SIGWINCH
+    signal(SIGWINCH, TermSizeSigHandler);
+    #endif
        signal(SIGINT, IntSigHandler);
        signal(SIGTERM, IntSigHandler);
        if (*appData.cmailGameName != NULLCHAR) {
            signal(SIGUSR1, CmailSigHandler);
        }
     }
-       InitPosition(TRUE);
+    gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
+    InitPosition(TRUE);
 
     XtAppMainLoop(appContext);
     if (appData.debugMode) fclose(debugFP); // [DM] debug
@@ -3068,10 +2476,16 @@ ShutDownFrontEnd()
     if (appData.icsActive && oldICSInteractionTitle != NULL) {
         DisplayIcsInteractionTitle(oldICSInteractionTitle);
     }
+    if (saveSettingsOnExit) SaveSettings(settingsFileName);
     unlink(gameCopyFilename);
     unlink(gamePasteFilename);
 }
 
+RETSIGTYPE TermSizeSigHandler(int sig)
+{
+    update_ics_width();
+}
+
 RETSIGTYPE
 IntSigHandler(sig)
      int sig;
@@ -3143,6 +2557,20 @@ typedef struct {
     Boolean value;
 } Enables;
 
+void
+GreyRevert(grey)
+     Boolean grey;
+{
+    Widget w;
+    if (!menuBarWidget) return;
+    w = XtNameToWidget(menuBarWidget, "menuStep.Revert");
+    if (w == NULL) {
+      DisplayError("menuStep.Revert", 0);
+    } else {
+      XtSetSensitive(w, !grey);
+    }
+}
+
 void
 SetMenuEnables(enab)
      Enables *enab;
@@ -3667,6 +3095,9 @@ void loadXIM(xim, xmask, filename, dest, mask)
     }
 }
 
+
+char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
+
 void CreateXIMPieces()
 {
     int piece, kind;
@@ -3697,13 +3128,14 @@ void CreateXIMPieces()
        }
        fprintf(stderr, _("\nLoading XIMs...\n"));
        /* Load pieces */
-       for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+       for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
            fprintf(stderr, "%d", piece+1);
            for (kind=0; kind<4; kind++) {
                fprintf(stderr, ".");
-               snprintf(buf, sizeof(buf), "%s/%c%s%u.xim",
+               snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
                        ExpandPathName(appData.pixmapDirectory),
-                       ToLower(PieceToChar((ChessSquare)piece)),
+                       piece <= (int) WhiteKing ? "" : "w",
+                       pieceBitmapNames[piece],
                        ximkind[kind], ss);
                ximPieceBitmap[kind][piece] =
                  XGetImage(xDisplay, DefaultRootWindow(xDisplay),
@@ -3712,8 +3144,10 @@ void CreateXIMPieces()
                  fprintf(stderr, _("(File:%s:) "), buf);
                loadXIM(ximPieceBitmap[kind][piece],
                        ximtemp, buf,
-                       &(xpmPieceBitmap[kind][piece]),
-                       &(ximMaskPm[piece%(int)BlackPawn]));
+                       &(xpmPieceBitmap2[kind][piece]),
+                       &(ximMaskPm2[piece]));
+               if(piece <= (int)WhiteKing)
+                   xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
            }
            fprintf(stderr," ");
        }
@@ -3759,14 +3193,6 @@ void CreateXPMPieces()
     static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
     XpmColorSymbol symbols[4];
 
-#if 0
-    /* Apparently some versions of Xpm don't define XpmFormat at all --tpm */
-    if (appData.debugMode) {
-       fprintf(stderr, "XPM Library Version: %d.%d%c\n",
-               XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));
-    }
-#endif
-
     /* The XSynchronize calls were copied from CreatePieces.
        Not sure if needed, but can't hurt */
     XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
@@ -3799,17 +3225,19 @@ void CreateXPMPieces()
          fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
          exit(1);
        }
-       for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+       for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
            for (kind=0; kind<4; kind++) {
 
                if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
                                               pieces->xpm[piece][kind],
-                                              &(xpmPieceBitmap[kind][piece]),
+                                              &(xpmPieceBitmap2[kind][piece]),
                                               NULL, &attr)) != 0) {
                  fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
                          r, buf);
                  exit(1);
                }
+               if(piece <= (int) WhiteKing)
+                   xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
            }
        }
        useImageSqs = 0;
@@ -3820,23 +3248,40 @@ void CreateXPMPieces()
        fprintf(stderr, _("\nLoading XPMs...\n"));
 
        /* Load pieces */
-       for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+       for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
            fprintf(stderr, "%d ", piece+1);
            for (kind=0; kind<4; kind++) {
-             snprintf(buf, sizeof(buf), "%s/%c%s%u.xpm",
+             snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
                        ExpandPathName(appData.pixmapDirectory),
-                       ToLower(PieceToChar((ChessSquare)piece)),
+                       piece > (int) WhiteKing ? "w" : "",
+                       pieceBitmapNames[piece],
                        xpmkind[kind], ss);
                if (appData.debugMode) {
                    fprintf(stderr, _("(File:%s:) "), buf);
                }
                if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
-                                          &(xpmPieceBitmap[kind][piece]),
+                                          &(xpmPieceBitmap2[kind][piece]),
                                           NULL, &attr)) != 0) {
-                   fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
-                           r, buf);
-                   exit(1);
+                   if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
+                     // [HGM] missing: read of unorthodox piece failed; substitute King.
+                     snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
+                               ExpandPathName(appData.pixmapDirectory),
+                               xpmkind[kind], ss);
+                       if (appData.debugMode) {
+                           fprintf(stderr, _("(Replace by File:%s:) "), buf);
+                       }
+                       r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+                                               &(xpmPieceBitmap2[kind][piece]),
+                                               NULL, &attr);
+                   }
+                   if (r != 0) {
+                       fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
+                               r, buf);
+                       exit(1);
+                   }
                }
+               if(piece <= (int) WhiteKing) 
+                   xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
            }
        }
        /* Load light and dark squares */
@@ -3888,10 +3333,13 @@ void CreatePieces()
                                     buffering bug */
 
     for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
-       for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
-           sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
+       for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+           sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+                   pieceBitmapNames[piece],
                    ss, kind == SOLID ? 's' : 'o');
-           ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);
+           ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
+           if(piece <= (int)WhiteKing)
+               pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
        }
     }
 
@@ -3913,11 +3361,14 @@ void CreatePieces()
     while (bib->squareSize != ss && bib->squareSize != 0) bib++;
 
     for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
-       for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
-           sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
+       for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+           sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+                   pieceBitmapNames[piece],
                    ss, kind == SOLID ? 's' : 'o');
-           ReadBitmap(&pieceBitmap[kind][piece], buf,
+           ReadBitmap(&pieceBitmap2[kind][piece], buf,
                       bib->bits[kind][piece], ss, ss);
+           if(piece <= (int)WhiteKing)
+               pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
        }
     }
 
@@ -3943,6 +3394,7 @@ void ReadBitmap(pm, name, bits, wreq, hreq)
        strcat(fullname, name);
        errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
                                  &w, &h, pm, &x_hot, &y_hot);
+    fprintf(stderr, "load %s\n", name);
        if (errcode != BitmapSuccess) {
            switch (errcode) {
              case BitmapOpenFailed:
@@ -3970,14 +3422,7 @@ void ReadBitmap(pm, name, bits, wreq, hreq)
            return;
        }
     }
-    if (bits == NULL) {
-#if 0
-       fprintf(stderr, _("%s: No built-in bitmap for %s; giving up\n"),
-               programName, name);
-       exit(1);
-#endif
-       ; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
-    } else {
+    if (bits != NULL) {
        *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
                                    wreq, hreq);
     }
@@ -4632,17 +4077,6 @@ void DrawSquare(row, column, piece, do_flash)
     DrawFunc drawfunc;
     int flash_delay;
 
-    if(gameInfo.variant == VariantShogi) { // [HGM] shogi: in shogi Q is used for Lance
-       if(piece == WhiteQueen) piece = WhiteLance; else
-       if(piece == BlackQueen) piece = BlackLance;
-    }
-#ifdef GOTHIC
-    else if(gameInfo.variant == VariantGothic) { // [HGM] shogi: in Gothic Chancelor has alternative look
-       if(piece == WhiteMarshall) piece = WhiteSilver; else
-       if(piece == BlackMarshall) piece = BlackSilver;
-    }
-#endif
-
     /* Calculate delay in milliseconds (2-delays per complete flash) */
     flash_delay = 500 / appData.flashRate;
 
@@ -4838,7 +4272,7 @@ static int check_castle_draw(newb, oldb, rrow, rcol)
     return 0;
 }
 
-static int damage[BOARD_SIZE][BOARD_SIZE];
+static int damage[BOARD_RANKS][BOARD_FILES];
 
 /*
  * event handler for redrawing the board
@@ -4969,14 +4403,8 @@ void HandleUserMove(w, event, prms, nprms)
      String *prms;
      Cardinal *nprms;
 {
-    int x, y;
-    Boolean saveAnimate;
-    static int second = 0;
-
     if (w != boardWidget || errorExitStatus != -1) return;
 
-    if (event->type == ButtonPress) ErrorPopDown();
-
     if (promotionUp) {
        if (event->type == ButtonPress) {
            XtPopdown(promotionShell);
@@ -4989,130 +4417,9 @@ void HandleUserMove(w, event, prms, nprms)
        }
     }
 
-    x = EventToSquare(event->xbutton.x, BOARD_WIDTH);
-    y = EventToSquare(event->xbutton.y, BOARD_HEIGHT);
-    if (!flipView && y >= 0) {
-       y = BOARD_HEIGHT - 1 - y;
-    }
-    if (flipView && x >= 0) {
-       x = BOARD_WIDTH - 1 - x;
-    }
-
-    /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
-    if(event->type == ButtonPress
-            && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
-              || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
-              || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
-       return;
-
-    if (fromX == -1) {
-       if (event->type == ButtonPress) {
-           /* First square */
-           if (OKToStartUserMove(x, y)) {
-               fromX = x;
-               fromY = y;
-               second = 0;
-               DragPieceBegin(event->xbutton.x, event->xbutton.y);
-               if (appData.highlightDragging) {
-                   SetHighlights(x, y, -1, -1);
-               }
-           }
-       }
-       return;
-    }
-
-    /* fromX != -1 */
-    if (event->type == ButtonPress && gameMode != EditPosition &&
-       x >= 0 && y >= 0) {
-       ChessSquare fromP;
-       ChessSquare toP;
-
-       /* Check if clicking again on the same color piece */
-       fromP = boards[currentMove][fromY][fromX];
-       toP = boards[currentMove][y][x];
-       if ((WhitePawn <= fromP && fromP < WhiteKing && // [HGM] this test should go, as UserMoveTest now does it.
-            WhitePawn <= toP && toP <= WhiteKing) ||   //       For now I made it less critical by exempting King
-           (BlackPawn <= fromP && fromP < BlackKing && //       moves, to not interfere with FRC castlings.
-            BlackPawn <= toP && toP <= BlackKing)) {
-           /* Clicked again on same color piece -- changed his mind */
-           second = (x == fromX && y == fromY);
-           if (appData.highlightDragging) {
-               SetHighlights(x, y, -1, -1);
-           } else {
-               ClearHighlights();
-           }
-           if (OKToStartUserMove(x, y)) {
-               fromX = x;
-               fromY = y;
-               DragPieceBegin(event->xbutton.x, event->xbutton.y);
-           }
-           return;
-       }
-    }
-
-    if (event->type == ButtonRelease &&        x == fromX && y == fromY) {
-       DragPieceEnd(event->xbutton.x, event->xbutton.y);
-       if (appData.animateDragging) {
-           /* Undo animation damage if any */
-           DrawPosition(FALSE, NULL);
-       }
-       if (second) {
-           /* Second up/down in same square; just abort move */
-           second = 0;
-           fromX = fromY = -1;
-           ClearHighlights();
-           gotPremove = 0;
-           ClearPremoveHighlights();
-       } else {
-           /* First upclick in same square; start click-click mode */
-           SetHighlights(x, y, -1, -1);
-       }
-       return;
-    }
-
-    /* Completed move */
-    toX = x;
-    toY = y;
-    saveAnimate = appData.animate;
-    if (event->type == ButtonPress) {
-       /* Finish clickclick move */
-       if (appData.animate || appData.highlightLastMove) {
-           SetHighlights(fromX, fromY, toX, toY);
-       } else {
-           ClearHighlights();
-       }
-    } else {
-       /* Finish drag move */
-       if (appData.highlightLastMove) {
-           SetHighlights(fromX, fromY, toX, toY);
-       } else {
-           ClearHighlights();
-       }
-       DragPieceEnd(event->xbutton.x, event->xbutton.y);
-       /* Don't animate move and drag both */
-       appData.animate = FALSE;
-    }
-    if (IsPromotion(fromX, fromY, toX, toY)) {
-       if (appData.alwaysPromoteToQueen) {
-           UserMoveEvent(fromX, fromY, toX, toY, 'q');
-           if (!appData.highlightLastMove || gotPremove) ClearHighlights();
-           if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
-           fromX = fromY = -1;
-       } else {
-           SetHighlights(fromX, fromY, toX, toY);
-           PromotionPopUp();
-       }
-    } else {
-       UserMoveEvent(fromX, fromY, toX, toY, NULLCHAR);
-       if (!appData.highlightLastMove || gotPremove) ClearHighlights();
-       if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
-       fromX = fromY = -1;
-    }
-    appData.animate = saveAnimate;
-    if (appData.animate || appData.animateDragging) {
-       /* Undo animation damage if needed */
-       DrawPosition(FALSE, NULL);
-    }
+    // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
+    if(event->type == ButtonPress)   LeftClick(Press,   event->xbutton.x, event->xbutton.y);
+    if(event->type == ButtonRelease) LeftClick(Release, event->xbutton.x, event->xbutton.y);
 }
 
 void AnimateUserMove (Widget w, XEvent * event,
@@ -5166,12 +4473,8 @@ Widget CommentCreate(name, text, mutable, callback, lines)
     XtSetArg(args[j], XtNright, XtChainRight);  j++;
     XtSetArg(args[j], XtNresizable, True);  j++;
     XtSetArg(args[j], XtNwidth, bw_width);  j++; /*force wider than buttons*/
-#if 0
-    XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded);  j++;
-#else
     /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
     XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways);  j++;
-#endif
     XtSetArg(args[j], XtNautoFill, True);  j++;
     XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
     edit =
@@ -5269,6 +4572,14 @@ Widget CommentCreate(name, text, mutable, callback, lines)
 #endif /*!NOTDEF*/
        if (commentY < 0) commentY = 0; /*avoid positioning top offscreen*/
     }
+
+    if(wpComment.width > 0) {
+      commentX = wpComment.x;
+      commentY = wpComment.y;
+      commentW = wpComment.width;
+      commentH = wpComment.height;
+    }
+
     j = 0;
     XtSetArg(args[j], XtNheight, commentH);  j++;
     XtSetArg(args[j], XtNwidth, commentW);  j++;
@@ -5324,12 +4635,8 @@ Widget MiscCreate(name, text, mutable, callback, lines)
     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
     XtSetArg(args[j], XtNright, XtChainRight);  j++;
     XtSetArg(args[j], XtNresizable, True);  j++;
-#if 0
-    XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded);  j++;
-#else
     /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
     XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways);  j++;
-#endif
     XtSetArg(args[j], XtNautoFill, True);  j++;
     XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
     edit =
@@ -5562,37 +4869,6 @@ void CommentPopUp(title, text)
     commentUp = True;
 }
 
-void AnalysisPopUp(title, text)
-     char *title, *text;
-{
-    Arg args[16];
-    int j;
-    Widget edit;
-
-    if (analysisShell == NULL) {
-       analysisShell = MiscCreate(title, text, False, NULL, 4);
-       XtRealizeWidget(analysisShell);
-       CatchDeleteWindow(analysisShell, "AnalysisPopDown");
-
-    } else {
-       edit = XtNameToWidget(analysisShell, "*form.text");
-       j = 0;
-       XtSetArg(args[j], XtNstring, text); j++;
-       XtSetValues(edit, args, j);
-       j = 0;
-       XtSetArg(args[j], XtNiconName, (XtArgVal) title);   j++;
-       XtSetArg(args[j], XtNtitle, (XtArgVal) title);      j++;
-       XtSetValues(analysisShell, args, j);
-    }
-
-    if (!analysisUp) {
-       XtPopup(analysisShell, XtGrabNone);
-    }
-    XSync(xDisplay, False);
-
-    analysisUp = True;
-}
-
 void CommentCallback(w, client_data, call_data)
      Widget w;
      XtPointer client_data, call_data;
@@ -5631,16 +4907,6 @@ void CommentPopDown()
     commentUp = False;
 }
 
-void AnalysisPopDown()
-{
-    if (!analysisUp) return;
-    XtPopdown(analysisShell);
-    XSync(xDisplay, False);
-    analysisUp = False;
-    if (appData.icsEngineAnalyze) ExitAnalyzeMode();    /* [DM] icsEngineAnalyze */
-}
-
-
 void FileNamePopUp(label, def, proc, openMode)
      char *label;
      char *def;
@@ -5796,11 +5062,12 @@ void PromotionPopUp()
                            layoutArgs, XtNumber(layoutArgs));
 
     j = 0;
-    XtSetArg(args[j], XtNlabel, _("Promote pawn to what?")); j++;
+    XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
     XtSetArg(args[j], XtNborderWidth, 0); j++;
     dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
                                   layout, args, j);
 
+  if(gameInfo.variant != VariantShogi) {
     XawDialogAddButton(dialog, _("Queen"), PromotionCallback,
                       (XtPointer) dialog);
     XawDialogAddButton(dialog, _("Rook"), PromotionCallback,
@@ -5814,6 +5081,21 @@ void PromotionPopUp()
       XawDialogAddButton(dialog, _("King"), PromotionCallback,
                         (XtPointer) dialog);
     }
+    if(gameInfo.variant == VariantCapablanca || 
+       gameInfo.variant == VariantGothic || 
+       gameInfo.variant == VariantCapaRandom) {
+      XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
+                        (XtPointer) dialog);
+      XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback,
+                        (XtPointer) dialog);
+    }
+  } else // [HGM] shogi
+  {
+      XawDialogAddButton(dialog, _("Promote"), PromotionCallback,
+                        (XtPointer) dialog);
+      XawDialogAddButton(dialog, _("Defer"), PromotionCallback,
+                        (XtPointer) dialog);
+  }
     XawDialogAddButton(dialog, _("cancel"), PromotionCallback,
                       (XtPointer) dialog);
 
@@ -5868,6 +5150,10 @@ void PromotionCallback(w, client_data, call_data)
        return;
     } else if (strcmp(name, _("Knight")) == 0) {
        promoChar = 'n';
+    } else if (strcmp(name, _("Promote")) == 0) {
+       promoChar = '+';
+    } else if (strcmp(name, _("Defer")) == 0) {
+       promoChar = '=';
     } else {
        promoChar = ToLower(name[0]);
     }
@@ -6048,15 +5334,6 @@ void ModeHighlight()
                    args, 1);
 
        if (appData.showButtonBar) {
-#if 0
-         if (pausing) {
-           XtSetArg(args[0], XtNbackground, buttonForegroundPixel);
-           XtSetArg(args[1], XtNforeground, buttonBackgroundPixel);
-         } else {
-           XtSetArg(args[0], XtNbackground, buttonBackgroundPixel);
-           XtSetArg(args[1], XtNforeground, buttonForegroundPixel);
-         }
-#else
          /* Always toggle, don't set.  Previous code messes up when
             invoked while the button is pressed, as releasing it
             toggles the state again. */
@@ -6069,7 +5346,6 @@ void ModeHighlight()
            XtSetArg(args[0], XtNbackground, oldfg);
            XtSetArg(args[1], XtNforeground, oldbg);
          }
-#endif
          XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
        }
     }
@@ -6102,7 +5378,6 @@ void ResetProc(w, event, prms, nprms)
      Cardinal *nprms;
 {
     ResetGameEvent();
-    AnalysisPopDown();
 }
 
 int LoadGamePopUp(f, gameNumber, title)
@@ -6255,7 +5530,7 @@ SendPositionSelection(Widget w, Atom *selection, Atom *target,
   char *selection_tmp;
 
   if (!selected_fen_position) return False; /* should never happen */
-  if (*target == XA_STRING){
+  if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
     /* note: since no XtSelectionDoneProc was registered, Xt will
      * automatically call XtFree on the value returned.  So have to
      * make a copy of it allocated with XtMalloc */
@@ -6264,9 +5539,22 @@ SendPositionSelection(Widget w, Atom *selection, Atom *target,
 
     *value_return=selection_tmp;
     *length_return=strlen(selection_tmp);
-    *type_return=XA_STRING;
+    *type_return=*target;
     *format_return = 8; /* bits per byte */
     return True;
+  } else if (*target == XA_TARGETS(xDisplay)) {
+    Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+    targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+    targets_tmp[1] = XA_STRING;
+    *value_return = targets_tmp;
+    *type_return = XA_ATOM;
+    *length_return = 2;
+    *format_return = 8 * sizeof(Atom);
+    if (*format_return > 32) {
+      *length_return *= *format_return / 32;
+      *format_return = 32;
+    }
+    return True;
   } else {
     return False;
   }
@@ -6281,20 +5569,25 @@ void CopyPositionProc(w, event, prms, nprms)
   String *prms;
   Cardinal *nprms;
   {
-    int ret;
-
+    /*
+     * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+     * have a notion of a position that is selected but not copied.
+     * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+     */
+    if(gameMode == EditPosition) EditPositionDone(TRUE);
     if (selected_fen_position) free(selected_fen_position);
     selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
     if (!selected_fen_position) return;
-    ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
-                        CurrentTime,
-                        SendPositionSelection,
-                        NULL/* lose_ownership_proc */ ,
-                        NULL/* transfer_done_proc */);
-    if (!ret) {
-      free(selected_fen_position);
-      selected_fen_position=NULL;
-    }
+    XtOwnSelection(menuBarWidget, XA_PRIMARY,
+                  CurrentTime,
+                  SendPositionSelection,
+                  NULL/* lose_ownership_proc */ ,
+                  NULL/* transfer_done_proc */);
+    XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+                  CurrentTime,
+                  SendPositionSelection,
+                  NULL/* lose_ownership_proc */ ,
+                  NULL/* transfer_done_proc */);
   }
 
 /* function called when the data to Paste is ready */
@@ -6317,7 +5610,8 @@ void PastePositionProc(w, event, prms, nprms)
   String *prms;
   Cardinal *nprms;
 {
-    XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
+    XtGetSelectionValue(menuBarWidget, 
+      appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
       /* (XtSelectionCallbackProc) */ PastePositionCB,
       NULL, /* client_data passed to PastePositionCB */
 
@@ -6336,7 +5630,7 @@ SendGameSelection(Widget w, Atom *selection, Atom *target,
 {
   char *selection_tmp;
 
-  if (*target == XA_STRING){
+  if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
     FILE* f = fopen(gameCopyFilename, "r");
     long len;
     size_t count;
@@ -6353,9 +5647,22 @@ SendGameSelection(Widget w, Atom *selection, Atom *target,
     selection_tmp[len] = NULLCHAR;
     *value_return = selection_tmp;
     *length_return = len;
-    *type_return = XA_STRING;
+    *type_return = *target;
     *format_return = 8; /* bits per byte */
     return True;
+  } else if (*target == XA_TARGETS(xDisplay)) {
+    Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+    targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+    targets_tmp[1] = XA_STRING;
+    *value_return = targets_tmp;
+    *type_return = XA_ATOM;
+    *length_return = 2;
+    *format_return = 8 * sizeof(Atom);
+    if (*format_return > 32) {
+      *length_return *= *format_return / 32;
+      *format_return = 32;
+    }
+    return True;
   } else {
     return False;
   }
@@ -6375,11 +5682,21 @@ void CopyGameProc(w, event, prms, nprms)
   ret = SaveGameToFile(gameCopyFilename, FALSE);
   if (!ret) return;
 
-  ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
-                      CurrentTime,
-                      SendGameSelection,
-                      NULL/* lose_ownership_proc */ ,
-                      NULL/* transfer_done_proc */);
+  /*
+   * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+   * have a notion of a game that is selected but not copied.
+   * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+   */
+  XtOwnSelection(menuBarWidget, XA_PRIMARY,
+                CurrentTime,
+                SendGameSelection,
+                NULL/* lose_ownership_proc */ ,
+                NULL/* transfer_done_proc */);
+  XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+                CurrentTime,
+                SendGameSelection,
+                NULL/* lose_ownership_proc */ ,
+                NULL/* transfer_done_proc */);
 }
 
 /* function called when the data to Paste is ready */
@@ -6410,7 +5727,8 @@ void PasteGameProc(w, event, prms, nprms)
   String *prms;
   Cardinal *nprms;
 {
-    XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
+    XtGetSelectionValue(menuBarWidget,
+      appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
       /* (XtSelectionCallbackProc) */ PasteGameCB,
       NULL, /* client_data passed to PasteGameCB */
 
@@ -7309,24 +6627,32 @@ void ShowThinkingProc(w, event, prms, nprms)
      XEvent *event;
      String *prms;
      Cardinal *nprms;
+{
+    appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
+    ShowThinkingEvent();
+}
+
+void HideThinkingProc(w, event, prms, nprms)
+     Widget w;
+     XEvent *event;
+     String *prms;
+     Cardinal *nprms;
 {
     Arg args[16];
 
-    appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
+    appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
     ShowThinkingEvent();
-#if 0
-    // [HGM] thinking: currently no suc menu item; replaced by Hide Thinking (From Human)
-    if (appData.showThinking) {
+
+    if (appData.hideThinkingFromHuman) {
        XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
     } else {
        XtSetArg(args[0], XtNleftBitmap, None);
     }
-    XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
+    XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
                args, 1);
-#endif
 }
 
-void HideThinkingProc(w, event, prms, nprms)
+void SaveOnExitProc(w, event, prms, nprms)
      Widget w;
      XEvent *event;
      String *prms;
@@ -7334,18 +6660,26 @@ void HideThinkingProc(w, event, prms, nprms)
 {
     Arg args[16];
 
-    appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
-    ShowThinkingEvent();
+    saveSettingsOnExit = !saveSettingsOnExit;
 
-    if (appData.hideThinkingFromHuman) {
+    if (saveSettingsOnExit) {
        XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
     } else {
        XtSetArg(args[0], XtNleftBitmap, None);
     }
-    XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
+    XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Save Settings on Exit"),
                args, 1);
 }
 
+void SaveSettingsProc(w, event, prms, nprms)
+     Widget w;
+     XEvent *event;
+     String *prms;
+     Cardinal *nprms;
+{
+     SaveSettings(settingsFileName);
+}
+
 void InfoProc(w, event, prms, nprms)
      Widget w;
      XEvent *event;
@@ -7409,7 +6743,7 @@ void AboutProc(w, event, prms, nprms)
            "Copyright 1991 Digital Equipment Corporation",
            "Enhancements Copyright 1992-2009 Free Software Foundation",
            "Enhancements Copyright 2005 Alessandro Scotti",
-           PRODUCT, " is free software and carries NO WARRANTY;",
+           PACKAGE, " is free software and carries NO WARRANTY;",
            "see the file COPYING for more information.");
     ErrorPopUp(_("About XBoard"), buf, FALSE);
 }
@@ -7457,19 +6791,34 @@ void Iconify(w, event, prms, nprms)
 void DisplayMessage(message, extMessage)
      char *message, *extMessage;
 {
-    char buf[MSG_SIZ];
-    Arg arg;
-
-    if (extMessage) {
-       if (*message) {
-           snprintf(buf, sizeof(buf), "%s  %s", message, extMessage);
-           message = buf;
-       } else {
-           message = extMessage;
-       }
-    }
-    XtSetArg(arg, XtNlabel, message);
-    XtSetValues(messageWidget, &arg, 1);
+  /* display a message in the message widget */
+  
+  char buf[MSG_SIZ];
+  Arg arg;
+  
+  if (extMessage) 
+    {
+      if (*message) 
+       {
+         snprintf(buf, sizeof(buf), "%s  %s", message, extMessage);
+         message = buf;
+       } 
+      else 
+       {
+         message = extMessage;
+       };
+    };
+  
+  /* need to test if messageWidget already exists, since this function
+     can also be called during the startup, if for example a Xresource
+     is not set up correctly */
+  if(messageWidget)
+    {
+      XtSetArg(arg, XtNlabel, message);
+      XtSetValues(messageWidget, &arg, 1);
+    };
+  
+  return;
 }
 
 void DisplayTitle(text)
@@ -7493,7 +6842,7 @@ void DisplayTitle(text)
        strcpy(title, text);
     } else if (appData.icsActive) {
         snprintf(icon, sizeof(icon), "%s", appData.icsHost);
-       snprintf(title, sizeof(title),"%s: %s", programName, appData.icsHost);
+       snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
     } else if (appData.cmailGameName[0] != NULLCHAR) {
         snprintf(icon, sizeof(icon), "%s", "CMail");
        snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
@@ -7537,7 +6886,7 @@ void DisplayError(message, error)
            fprintf(stderr, "%s: %s: %s\n",
                    programName, message, strerror(error));
        }
-       snprintf(buf,sizeof(buf), "%s: %s", message, strerror(error));
+       snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
        message = buf;
     }
     ErrorPopUp(_("Error"), message, FALSE);
@@ -7960,6 +7309,9 @@ void
 ScheduleDelayedEvent(cb, millisec)
      DelayedEventCallback cb; long millisec;
 {
+    if(delayedEventTimerXID && delayedEventCallback == cb)
+       // [HGM] alive: replace, rather than add or flush identical event
+       XtRemoveTimeOut(delayedEventTimerXID);
     delayedEventCallback = cb;
     delayedEventTimerXID =
       XtAppAddTimeOut(appContext, millisec,
@@ -8092,6 +7444,14 @@ DisplayTimerLabel(w, color, timer, highlight)
     char buf[MSG_SIZ];
     Arg args[16];
 
+    /* check for low time warning */
+    Pixel foregroundOrWarningColor = timerForegroundPixel;
+
+    if (timer > 0 &&
+        appData.lowTimeWarning && 
+        (timer / 1000) < appData.icsAlarmTime)
+      foregroundOrWarningColor = lowTimeWarningColor;
+
     if (appData.clockMode) {
        sprintf(buf, "%s: %s", color, TimeString(timer));
        XtSetArg(args[0], XtNlabel, buf);
@@ -8101,11 +7461,12 @@ DisplayTimerLabel(w, color, timer, highlight)
     }
 
     if (highlight) {
-       XtSetArg(args[1], XtNbackground, timerForegroundPixel);
+
+       XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
        XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
     } else {
        XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
-       XtSetArg(args[2], XtNforeground, timerForegroundPixel);
+       XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
     }
 
     XtSetValues(w, args, 3);
@@ -8180,8 +7541,11 @@ int StartChildProcess(cmdLine, dir, pr)
     strcpy(buf, cmdLine);
     p = buf;
     for (;;) {
+       while(*p == ' ') p++;
        argv[i++] = p;
-       p = strchr(p, ' ');
+       if(*p == '"' || *p == '\'')
+            p = strchr(++argv[i-1], *p);
+       else p = strchr(p, ' ');
        if (p == NULL) break;
        *p++ = NULLCHAR;
     }
@@ -8283,7 +7647,7 @@ int OpenTelnet(host, port, pr)
     if (port[0] == NULLCHAR) {
       snprintf(cmdLine, sizeof(cmdLine), "%s %s", appData.telnetProgram, host);
     } else {
-      snprintf(cmdLine,sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
+      snprintf(cmdLine, sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
     }
     return StartChildProcess(cmdLine, "", pr);
 }
@@ -8503,11 +7867,33 @@ int OutputToProcess(pr, message, count, outError)
      int count;
      int *outError;
 {
+    static int line = 0;
     ChildProc *cp = (ChildProc *) pr;
     int outCount;
 
     if (pr == NoProc)
-      outCount = fwrite(message, 1, count, stdout);
+    {
+        if (appData.noJoin || !appData.useInternalWrap)
+            outCount = fwrite(message, 1, count, stdout);
+        else
+        {
+            int width = get_term_width();
+            int len = wrap(NULL, message, count, width, &line);
+            char *msg = malloc(len);
+            int dbgchk;
+
+            if (!msg)
+                outCount = fwrite(message, 1, count, stdout);
+            else
+            {
+                dbgchk = wrap(msg, message, count, width, &line);
+                if (dbgchk != len && appData.debugMode)
+                    fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
+                outCount = fwrite(msg, 1, dbgchk, stdout);
+                free(msg);
+            }
+        }
+    }
     else
       outCount = write(cp->fdTo, message, count);
 
@@ -8567,6 +7953,8 @@ int OutputToProcessDelayed(pr, message, count, outError, msdelay)
        and dark squares, and all pieces must use the same
        background square colors/images.                */
 
+static int xpmDone = 0;
+
 static void
 CreateAnimMasks (pieceDepth)
      int pieceDepth;
@@ -8597,6 +7985,7 @@ CreateAnimMasks (pieceDepth)
 
   for (piece = WhitePawn; piece <= BlackKing; piece++) {
     /* Begin with empty mask */
+    if(!xpmDone) // [HGM] pieces: keep using existing
     xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
                                 squareSize, squareSize, 1);
     XSetFunction(xDisplay, maskGC, GXclear);
@@ -8680,11 +8069,11 @@ InitAnimState (anim, info)
 static void
 CreateAnimVars ()
 {
-  static int done = 0;
+  static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
   XWindowAttributes info;
 
-  if (done) return;
-  done = 1;
+  if (xpmDone && gameInfo.variant == old) return;
+  if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
   XGetWindowAttributes(xDisplay, xBoardWindow, &info);
 
   InitAnimState(&game, &info);
@@ -8693,6 +8082,7 @@ CreateAnimVars ()
   /* For XPM pieces, we need bitmaps to use as masks. */
   if (useImages)
     CreateAnimMasks(info.depth);
+   xpmDone = 1;
 }
 
 #ifndef HAVE_USLEEP
@@ -8723,12 +8113,7 @@ FrameDelay (time)
     delay.it_interval.tv_usec =
       delay.it_value.tv_usec = (time % 1000) * 1000;
     setitimer(ITIMER_REAL, &delay, NULL);
-#if 0
-    /* Ugh -- busy-wait! --tpm */
-    while (frameWaiting);
-#else
     while (frameWaiting) pause();
-#endif
     delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;
     delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;
     setitimer(ITIMER_REAL, &delay, NULL);
@@ -8918,7 +8303,7 @@ SelectGCMask(piece, clip, outline, mask)
 #if HAVE_LIBXPM
       *mask = xpmMask[piece];
 #else
-      *mask = ximMaskPm[piece%(int)BlackPawn];
+      *mask = ximMaskPm[piece];
 #endif
   } else {
       *mask = *pieceToSolid(piece);
@@ -8967,7 +8352,7 @@ OverlayPiece(piece, clip, outline,  dest)
       kind = 0;
     else
       kind = 2;
-    XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
+    XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
              dest, clip,
              0, 0, squareSize, squareSize,
              0, 0);
@@ -9111,6 +8496,10 @@ AnimateMove(board, fromX, fromY, toX, toY)
   if (!appData.animate || appData.blindfold)
     return;
 
+  if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing || 
+     board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing) 
+       return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
+
   if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
   piece = board[fromY][fromX];
   if (piece >= EmptySquare) return;
@@ -9154,7 +8543,7 @@ AnimateMove(board, fromX, fromY, toX, toY)
   damage[toY][toX] = True;
 }
 
-static void
+void
 DragPieceBegin(x, y)
      int x; int y;
 {
@@ -9173,19 +8562,10 @@ DragPieceBegin(x, y)
     ScreenSquare(boardX, boardY, &corner, &color);
     player.startSquare  = corner;
     player.startColor   = color;
-#if 0
-    /* Start from exactly where the piece is.  This can be confusing
-       if you start dragging far from the center of the square; most
-       or all of the piece can be over a different square from the one
-       the mouse pointer is in. */
-    player.mouseDelta.x = x - corner.x;
-    player.mouseDelta.y = y - corner.y;
-#else
     /* As soon as we start dragging, the piece will jump slightly to
        be centered over the mouse pointer. */
     player.mouseDelta.x = squareSize/2;
     player.mouseDelta.y = squareSize/2;
-#endif
     /* Initialise animation */
     player.dragPiece = PieceForSquare(boardX, boardY);
     /* Sanity check */
@@ -9233,7 +8613,7 @@ DragPieceMove(x, y)
 #endif
 }
 
-static void
+void
 DragPieceEnd(x, y)
      int x; int y;
 {
@@ -9280,10 +8660,37 @@ DrawDragPiece ()
   damage[player.startBoardY][player.startBoardX] = TRUE;
 }
 
-void
-SetProgramStats( FrontEndProgramStats * stats )
+#include <sys/ioctl.h>
+int get_term_width()
+{
+    int fd, default_width;
+
+    fd = STDIN_FILENO;
+    default_width = 79; // this is FICS default anyway...
+
+#if !defined(TIOCGWINSZ) && defined(TIOCGSIZE)
+    struct ttysize win;
+    if (!ioctl(fd, TIOCGSIZE, &win))
+        default_width = win.ts_cols;
+#elif defined(TIOCGWINSZ)
+    struct winsize win;
+    if (!ioctl(fd, TIOCGWINSZ, &win))
+        default_width = win.ws_col;
+#endif
+    return default_width;
+}
+
+void update_ics_width()
+{
+    static int old_width = 0;
+    int new_width = get_term_width();
+
+    if (old_width != new_width)
+       ics_printf("set width %d\n", new_width);
+    old_width = new_width;
+}
+
+void NotifyFrontendLogin()
 {
-  // [HR] TODO
-  // [HGM] done, but perhaps backend should call this directly?
-    EngineOutputUpdate( stats );
+    update_ics_width();
 }