* xboard.c -- X front end for XBoard
*
* Copyright 1991 by Digital Equipment Corporation, Maynard,
- * Massachusetts.
+ * Massachusetts.
*
* Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
- * 2007, 2008, 2009 Free Software Foundation, Inc.
+ * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
*
* The following terms apply to Digital Equipment Corporation's copyright
* interest in XBoard:
*------------------------------------------------------------------------
** See the file ChangeLog for a revision history. */
+#define HIGHDRAG 1
+
#include "config.h"
#include <stdio.h>
# endif
#endif
+
+# if HAVE_LIBREADLINE /* add gnu-readline support */
+#include <readline/readline.h>
+#include <readline/history.h>
+# endif
+
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#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>
#include "frontend.h"
#include "backend.h"
+#include "backendz.h"
#include "moves.h"
#include "xboard.h"
#include "childio.h"
// 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__
} Menu;
int main P((int argc, char **argv));
+FILE * XsraSelFile P((Widget w, char *prompt, char *ok, char *cancel, char *failed,
+ char *init_path, char *mode, int (*show_entry)(), char **name_return));
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));
+void CreateXPMBoard P((char *s, int n));
void CreatePieces P((void));
void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb));
String *prms, Cardinal *nprms));
void AnimateUserMove P((Widget w, XEvent * event,
String * params, Cardinal * nParams));
+void HandlePV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void SelectPV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void StopPV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
void WhiteClock P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void BlackClock P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void XDrawPosition P((Widget w, /*Boolean*/int repaint,
Board board));
+void CommentClick P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
void CommentPopUp P((char *title, char *label));
void CommentPopDown P((void));
void CommentCallback P((Widget w, XtPointer client_data,
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));
void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void UpKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void DownKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void StopObservingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void StopExaminingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
+void UploadProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void AnnotateProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void TruncateGameProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void RetractMoveProc 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));
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));
void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void GameListOptionsPopUp P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void GameListOptionsPopDown P(());
void ShufflePopDown P(());
void EnginePopDown P(());
void UciPopDown P(());
void TimeControlPopDown P(());
void NewVariantPopDown P(());
void SettingsPopDown P(());
+void update_ics_width P(());
+int get_term_width P(());
+int CopyMemoProc P(());
+
+# if HAVE_LIBREADLINE /* add gnu-readline support */
+static void ReadlineCompleteHandler P((char *));
+# endif
+
/*
* XBoard depends on Xt R4 or higher
*/
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;
+int hOffset; // [HGM] dual
+XSegment secondSegments[BOARD_RANKS + BOARD_FILES + 2];
+XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
Font clockFontID, coordFontID, countFontID;
XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
char *fileOpenMode;
char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
+# if HAVE_LIBREADLINE /* gnu readline support */
+static char* readline_buffer;
+static int readline_complete=0;
+extern int sending_ICS_login;
+extern int sending_ICS_password;
+#endif
+
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,
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 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;
+Pixmap xpmBoardBitmap[2];
+int useImages, useImageSqs, useTexture, textureW[2], textureH[2];
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 */
{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},
{"----", NothingProc},
{N_("Stop Observing"), StopObservingProc},
{N_("Stop Examining"), StopExaminingProc},
+ {N_("Upload to Examine"), UploadProc},
{"----", NothingProc},
{N_("Adjudicate to White"), AdjuWhiteProc},
{N_("Adjudicate to Black"), AdjuBlackProc},
{N_("Back to Start"), ToStartProc},
{N_("Forward to End"), ToEndProc},
{N_("Revert"), RevertProc},
+ {N_("Annotate"), AnnotateProc},
{N_("Truncate Game"), TruncateGameProc},
{"----", NothingProc},
{N_("Move Now"), MoveNowProc},
{N_("Engine #1 Settings ..."), FirstSettingsProc},
{N_("Engine #2 Settings ..."), SecondSettingsProc},
{N_("Time Control ..."), TimeControlProc},
+ {N_("Game List ..."), GameListOptionsPopUp},
{"----", NothingProc},
{N_("Always Queen"), AlwaysQueenProc},
{N_("Animate Dragging"), AnimateDraggingProc},
{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}
};
#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_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ 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_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ 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, WhiteAlfil,
- WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
+ WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
PromotePiece, DemotePiece, EmptySquare, ClearBoard },
{ BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
- BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
+ BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
PromotePiece, DemotePiece, EmptySquare, ClearBoard },
};
};
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 */
-#if 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 },
- { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
- XtRString, COLOR_LOWTIMEWARNING },
- { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
- XtRImmediate, (XtPointer) False },
- {"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},
- { "adjudicateDrawMoves", "adjudicateDrawMoves", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, adjudicateDrawMoves),
- 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) 1},
- { "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},
- { "keepAlive", "keepAlive", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, keepAlive),
- 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" },
- { "-lowTimeWarningColor", "lowTimeWarningColor", XrmoptionSepArg, NULL },
- { "-lowTimeWarning", "lowTimeWarning", XrmoptionSepArg, NULL },
- /* [AS,HR] New features */
- { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
- { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
- { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
- { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
- { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
- { "-adjudicateDrawMoves", "adjudicateDrawMoves", 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 },
- { "-keepAlive", "keepAlive", XrmoptionSepArg, NULL },
};
-
XtActionsRec boardActions[] = {
{ "DrawPosition", DrawPositionProc },
{ "HandleUserMove", HandleUserMove },
{ "AnimateUserMove", AnimateUserMove },
+ { "HandlePV", HandlePV },
+ { "SelectPV", SelectPV },
+ { "StopPV", StopPV },
{ "FileNameAction", FileNameAction },
{ "AskQuestionProc", AskQuestionProc },
{ "AskQuestionReplyAction", AskQuestionReplyAction },
{ "BlackClock", BlackClock },
{ "Iconify", Iconify },
{ "ResetProc", ResetProc },
+ { "NewVariantProc", NewVariantProc },
{ "LoadGameProc", LoadGameProc },
{ "LoadNextGameProc", LoadNextGameProc },
{ "LoadPrevGameProc", LoadPrevGameProc },
{ "LoadSelectedProc", LoadSelectedProc },
+ { "SetFilterProc", SetFilterProc },
{ "ReloadGameProc", ReloadGameProc },
{ "LoadPositionProc", LoadPositionProc },
{ "LoadNextPositionProc", LoadNextPositionProc },
{ "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 },
{ "AdjuBlackProc", AdjuBlackProc },
{ "AdjuDrawProc", AdjuDrawProc },
{ "EnterKeyProc", EnterKeyProc },
+ { "UpKeyProc", UpKeyProc },
+ { "DownKeyProc", DownKeyProc },
{ "StopObservingProc", StopObservingProc },
{ "StopExaminingProc", StopExaminingProc },
+ { "UploadProc", UploadProc },
{ "BackwardProc", BackwardProc },
{ "ForwardProc", ForwardProc },
{ "ToStartProc", ToStartProc },
{ "ToEndProc", ToEndProc },
{ "RevertProc", RevertProc },
+ { "AnnotateProc", AnnotateProc },
{ "TruncateGameProc", TruncateGameProc },
{ "MoveNowProc", MoveNowProc },
{ "RetractMoveProc", RetractMoveProc },
+ { "EngineMenuProc", (XtActionProc) EngineMenuProc },
+ { "UciMenuProc", (XtActionProc) UciMenuProc },
+ { "TimeControlProc", (XtActionProc) TimeControlProc },
{ "AlwaysQueenProc", AlwaysQueenProc },
{ "AnimateDraggingProc", AnimateDraggingProc },
{ "AnimateMovingProc", AnimateMovingProc },
{ "ShowThinkingProc", ShowThinkingProc },
{ "HideThinkingProc", HideThinkingProc },
{ "TestLegalityProc", TestLegalityProc },
+ { "SaveSettingsProc", SaveSettingsProc },
+ { "SaveOnExitProc", SaveOnExitProc },
{ "InfoProc", InfoProc },
{ "ManProc", ManProc },
{ "HintProc", HintProc },
{ "AboutProc", AboutProc },
{ "DebugProc", DebugProc },
{ "NothingProc", NothingProc },
+ { "CommentClick", (XtActionProc) CommentClick },
{ "CommentPopDown", (XtActionProc) CommentPopDown },
{ "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
{ "TagsPopDown", (XtActionProc) TagsPopDown },
{ "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
- { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
{ "FileNamePopDown", (XtActionProc) FileNamePopDown },
{ "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
+ { "GameListOptionsPopDown", (XtActionProc) GameListOptionsPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
{ "HistoryPopDown", (XtActionProc) HistoryPopDown },
{ "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+ { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
{ "ShufflePopDown", (XtActionProc) ShufflePopDown },
{ "EnginePopDown", (XtActionProc) EnginePopDown },
{ "UciPopDown", (XtActionProc) UciPopDown },
{ "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
{ "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
{ "SettingsPopDown", (XtActionProc) SettingsPopDown },
+ { "CopyMemoProc", (XtActionProc) CopyMemoProc },
};
char globalTranslations[] =
- ":<Key>R: ResignProc() \n \
- :<Key>r: ResetProc() \n \
- :<Key>g: LoadGameProc() \n \
- :<Key>N: LoadNextGameProc() \n \
- :<Key>P: LoadPrevGameProc() \n \
- :<Key>Q: QuitProc() \n \
- :<Key>F: ToEndProc() \n \
- :<Key>f: ForwardProc() \n \
- :<Key>B: ToStartProc() \n \
- :<Key>b: BackwardProc() \n \
- :<Key>p: PauseProc() \n \
- :<Key>d: DrawProc() \n \
- :<Key>t: CallFlagProc() \n \
- :<Key>i: Iconify() \n \
- :<Key>c: Iconify() \n \
- :<Key>v: FlipViewProc() \n \
- <KeyDown>Control_L: BackwardProc() \n \
- <KeyUp>Control_L: ForwardProc() \n \
- <KeyDown>Control_R: BackwardProc() \n \
- <KeyUp>Control_R: ForwardProc() \n \
+ ":<Key>F9: ResignProc() \n \
+ :Ctrl<Key>n: ResetProc() \n \
+ :Meta<Key>V: NewVariantProc() \n \
+ :Ctrl<Key>o: LoadGameProc() \n \
+ :Meta<Key>Next: LoadNextGameProc() \n \
+ :Meta<Key>Prior: LoadPrevGameProc() \n \
+ :Ctrl<Key>s: SaveGameProc() \n \
+ :Ctrl<Key>c: CopyGameProc() \n \
+ :Ctrl<Key>v: PasteGameProc() \n \
+ :Ctrl<Key>O: LoadPositionProc() \n \
+ :Shift Meta<Key>Next: LoadNextPositionProc() \n \
+ :Shift Meta<Key>Prior: LoadPrevPositionProc() \n \
+ :Ctrl<Key>S: SavePositionProc() \n \
+ :Ctrl<Key>C: CopyPositionProc() \n \
+ :Ctrl<Key>V: PastePositionProc() \n \
+ :Ctrl<Key>q: QuitProc() \n \
+ :Ctrl<Key>w: MachineWhiteProc() \n \
+ :Ctrl<Key>b: MachineBlackProc() \n \
+ :Ctrl<Key>t: TwoMachinesProc() \n \
+ :Ctrl<Key>a: AnalysisModeProc() \n \
+ :Ctrl<Key>f: AnalyzeFileProc() \n \
+ :Ctrl<Key>e: EditGameProc() \n \
+ :Ctrl<Key>E: EditPositionProc() \n \
+ :Meta<Key>O: EngineOutputProc() \n \
+ :Meta<Key>E: EvalGraphProc() \n \
+ :Meta<Key>G: ShowGameListProc() \n \
+ :Meta<Key>H: ShowMoveListProc() \n \
+ :<Key>Pause: PauseProc() \n \
+ :<Key>F3: AcceptProc() \n \
+ :<Key>F4: DeclineProc() \n \
+ :<Key>F12: RematchProc() \n \
+ :<Key>F5: CallFlagProc() \n \
+ :<Key>F6: DrawProc() \n \
+ :<Key>F7: AdjournProc() \n \
+ :<Key>F8: AbortProc() \n \
+ :<Key>F10: StopObservingProc() \n \
+ :<Key>F11: StopExaminingProc() \n \
+ :Meta Ctrl<Key>F12: DebugProc() \n \
+ :Meta<Key>End: ToEndProc() \n \
+ :Meta<Key>Right: ForwardProc() \n \
+ :Meta<Key>Home: ToStartProc() \n \
+ :Meta<Key>Left: BackwardProc() \n \
+ :Ctrl<Key>m: MoveNowProc() \n \
+ :Ctrl<Key>x: RetractMoveProc() \n \
+ :Meta<Key>J: EngineMenuProc() \n \
+ :Meta<Key>U: UciMenuProc() \n \
+ :Meta<Key>T: TimeControlProc() \n \
+ :Ctrl<Key>Q: AlwaysQueenProc() \n \
+ :Ctrl<Key>F: AutoflagProc() \n \
+ :Ctrl<Key>A: AnimateMovingProc() \n \
+ :Ctrl<Key>P: PonderNextMoveProc() \n \
+ :Ctrl<Key>L: TestLegalityProc() \n \
+ :Ctrl<Key>H: HideThinkingProc() \n \
+ :<Key>-: Iconify() \n \
+ :<Key>F1: ManProc() \n \
+ :<Key>F2: FlipViewProc() \n \
+ <KeyDown>.: BackwardProc() \n \
+ <KeyUp>.: ForwardProc() \n \
Shift<Key>1: AskQuestionProc(\"Direct command\",\
\"Send to chess program:\",,1) \n \
Shift<Key>2: AskQuestionProc(\"Direct command\",\
\"Send to second chess program:\",,2) \n";
char boardTranslations[] =
- "<Btn1Down>: HandleUserMove() \n \
- <Btn1Up>: HandleUserMove() \n \
+ "<Btn1Down>: HandleUserMove(0) \n \
+ Shift<Btn1Up>: HandleUserMove(1) \n \
+ <Btn1Up>: HandleUserMove(0) \n \
<Btn1Motion>: AnimateUserMove() \n \
+ <Btn3Motion>: HandlePV() \n \
+ <Btn3Up>: PieceMenuPopup(menuB) \n \
Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
PieceMenuPopup(menuB) \n \
Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
char blackTranslations[] = "<BtnDown>: BlackClock()\n";
char ICSInputTranslations[] =
+ "<Key>Up: UpKeyProc() \n "
+ "<Key>Down: DownKeyProc() \n "
"<Key>Return: EnterKeyProc() \n";
+// [HGM] vari: another hideous kludge: call extend-end first so we can be sure select-start works,
+// as the widget is destroyed before the up-click can call extend-end
+char commentTranslations[] = "<Btn3Down>: extend-end() select-start() CommentClick() \n";
+
String xboardResources[] = {
"*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
"*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
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 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,
+ &appData.lowTimeWarningColor,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &crWhite,
+ &crBlack,
+ NULL
+};
+
+// [HGM] font: keep a font for each square size, even non-stndard ones
+#define NUM_SIZES 18
+#define MAX_SIZE 130
+Boolean fontSet[NUM_FONTS], fontValid[NUM_FONTS][MAX_SIZE];
+char *fontTable[NUM_FONTS][MAX_SIZE];
+
+void
+ParseFont(char *name, int number)
+{ // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
+ int size;
+ if(sscanf(name, "size%d:", &size)) {
+ // [HGM] font: font is meant for specific boardSize (likely from settings file);
+ // defer processing it until we know if it matches our board size
+ if(size >= 0 && size<MAX_SIZE) { // for now, fixed limit
+ fontTable[number][size] = strdup(strchr(name, ':')+1);
+ fontValid[number][size] = True;
+ }
+ return;
+ }
+ 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;
+ }
+ fontSet[number] = True; // [HGM] font: indicate a font was specified (not from settings file)
+}
+
+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;
+ int i, n = (int)ad->argLoc;
+ switch(n) {
+ 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;
+ }
+ for(i=0; i<NUM_SIZES; i++) // [HGM] font: current font becomes standard for current size
+ if(sizeDefaults[i].squareSize == squareSize) { // only for standard sizes!
+ fontTable[n][squareSize] = strdup(name);
+ fontValid[n][squareSize] = True;
+ break;
+ }
+ for(i=0; i<MAX_SIZE; i++) if(fontValid[n][i]) // [HGM] font: store all standard fonts
+ fprintf(f, OPTCHAR "%s" SEPCHAR "size%d:%s\n", ad->argName, i, fontTable[n][i]);
+}
+
+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] == '/')
+ safeStrCpy(fullname, name, MSG_SIZ );
+ else {
+ sprintf(fullname, "%s%c%s", installDir, '/', name);
+ }
+ return 1;
+}
+
+int
+MyGetFullPathName(char *name, char *fullname)
+{ // should use ExpandPath?
+ name = ExpandPathName(name);
+ safeStrCpy(fullname, name, MSG_SIZ );
+ 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] != '{' )
+ snprintf(buf, sizeof(buf)/sizeof(buf[0]), "{%s} ", argv[i]);
+ else
+ snprintf(buf, sizeof(buf)/sizeof(buf[0]), "%s ", argv[i]);
+ strncat(line, buf, 128*1024 - strlen(line) - 1 );
+ }
+
+ line[strlen(line)-1] = NULLCHAR;
+ return line;
+}
+
+//--------------------------------------------------------------------------------------------
+
+extern Boolean twoBoards, partnerUp;
+
#ifdef IDSIZES
// eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
#else
shellArgs[1].value = (XtArgVal) &h;
XtGetValues(shellWidget, shellArgs, 2);
- shellArgs[4].value = 2*w; shellArgs[2].value = 10;
+ shellArgs[4].value = 3*w; shellArgs[2].value = 10;
shellArgs[5].value = 2*h; shellArgs[3].value = 10;
XtSetValues(shellWidget, &shellArgs[2], 4);
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
CreateGrid();
+ hOffset = boardWidth + 10;
+ for(i=0; i<BOARD_WIDTH+BOARD_HEIGHT+2; i++) { // [HGM] dual: grid for second board
+ secondSegments[i] = gridSegments[i];
+ secondSegments[i].x1 += hOffset;
+ secondSegments[i].x2 += hOffset;
+ }
XtSetArg(args[0], XtNwidth, boardWidth);
XtSetArg(args[1], XtNheight, boardHeight);
/*
* Inhibit shell resizing.
*/
- shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
+ shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + twoBoards*hOffset; // [HGM] dual
shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
shellArgs[4].value = shellArgs[2].value = w;
shellArgs[5].value = shellArgs[3].value = h;
}
#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;
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 HAVE_LIBREADLINE
+ /* install gnu-readline handler */
+ rl_callback_handler_install("> ", ReadlineCompleteHandler);
+ rl_readline_name="XBoard";
+# endif
+
+ 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)
XtAppInitialize(&appContext, "XBoard", shellOptions,
XtNumber(shellOptions),
&argc, argv, xboardResources, NULL, 0);
- if (argc > 1) {
- fprintf(stderr, _("%s: unrecognized argument %s\n"),
- programName, argv[1]);
- fprintf(stderr, "Recognized options:\n");
- for(i = 0; i < XtNumber(shellOptions); i++) {
- j = fprintf(stderr, " %s%s", shellOptions[i].option,
- (shellOptions[i].argKind == XrmoptionSepArg
- ? " ARG" : ""));
- if (i++ < XtNumber(shellOptions)) {
- fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
- shellOptions[i].option,
- (shellOptions[i].argKind == XrmoptionSepArg
- ? " ARG" : ""));
- } else {
- fprintf(stderr, "\n");
- }
- }
- exit(2);
- }
-
+ appData.boardSize = "";
+ InitAppData(ConvertToLine(argc, argv));
p = getenv("HOME");
if (p == NULL) p = "/tmp";
i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
}
/* [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 */
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
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++;
fontPxlSize = szd->fontPxlSize;
smallLayout = szd->smallLayout;
tinyLayout = szd->tinyLayout;
+ // [HGM] font: use defaults from settings file if available and not overruled
}
+ if(!fontSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
+ appData.clockFont = fontTable[CLOCK_FONT][squareSize];
+ if(!fontSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
+ appData.font = fontTable[MESSAGE_FONT][squareSize];
+ if(!fontSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
+ appData.coordFont = fontTable[COORD_FONT][squareSize];
/* Now, using squareSize as a hint, find a good XPM/XIM set size */
if (strlen(appData.pixmapDirectory) > 0) {
fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
}
}
+ if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
/* [HR] height treated separately (hacked) */
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
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;
vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
vFrom.size = strlen(appData.lowTimeWarningColor);
XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
- if (vTo.addr == NULL)
+ if (vTo.addr == NULL)
appData.monoMode = True;
else
lowTimeWarningColor = *(Pixel *) vTo.addr;
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,
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.
XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
args, 1);
}
+ if (saveSettingsOnExit) {
+ XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Save Settings on Exit"),
+ args, 1);
+ }
/*
* Create an icon.
CreatePieces();
} else {
CreateXPMPieces();
+ CreateXPMBoard(appData.liteBackTextureFile, 1);
+ CreateXPMBoard(appData.darkBackTextureFile, 0);
}
#else
CreateXIMPieces();
/* Why is the following needed on some versions of X instead
* of a translation? */
- XtAddEventHandler(boardWidget, ExposureMask, False,
+ XtAddEventHandler(boardWidget, ExposureMask|PointerMotionMask, False,
(XtEventHandler) EventProc, NULL);
/* end why */
+ /* [AS] Restore layout */
+ if( wpMoveHistory.visible ) {
+ HistoryPopUp();
+ }
+
+ if( wpEvalGraph.visible )
+ {
+ EvalGraphPopUp();
+ };
+
+ if( wpEngineOutput.visible ) {
+ EngineOutputPopUp();
+ }
+
InitBackEnd2();
if (errorExitStatus == -1) {
if (appData.icsInputBox) ICSInputBoxPopUp();
}
+ #ifdef SIGWINCH
+ signal(SIGWINCH, TermSizeSigHandler);
+ #endif
signal(SIGINT, IntSigHandler);
signal(SIGTERM, IntSigHandler);
if (*appData.cmailGameName != NULLCHAR) {
}
gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
InitPosition(TRUE);
+ XtSetKeyboardFocus(shellWidget, formWidget);
XtAppMainLoop(appContext);
if (appData.debugMode) fclose(debugFP); // [DM] debug
if (appData.icsActive && oldICSInteractionTitle != NULL) {
DisplayIcsInteractionTitle(oldICSInteractionTitle);
}
+ if (saveSettingsOnExit) SaveSettings(settingsFileName);
unlink(gameCopyFilename);
unlink(gamePasteFilename);
+
+# if HAVE_LIBREADLINE
+ /* remove gnu-readline handler. */
+ rl_callback_handler_remove();
+#endif
+
+ return;
+}
+
+RETSIGTYPE TermSizeSigHandler(int sig)
+{
+ update_ics_width();
}
RETSIGTYPE
void
ICSInitScript()
{
- FILE *f;
- char buf[MSG_SIZ];
- char *p;
+ /* try to open the icsLogon script, either in the location given
+ * or in the users HOME directory
+ */
- f = fopen(appData.icsLogon, "r");
- if (f == NULL) {
- p = getenv("HOME");
- if (p != NULL) {
- strcpy(buf, p);
- strcat(buf, "/");
- strcat(buf, appData.icsLogon);
- f = fopen(buf, "r");
+ FILE *f;
+ char buf[MSG_SIZ];
+ char *homedir;
+
+ f = fopen(appData.icsLogon, "r");
+ if (f == NULL)
+ {
+ homedir = getenv("HOME");
+ if (homedir != NULL)
+ {
+ safeStrCpy(buf, homedir, sizeof(buf)/sizeof(buf[0]) );
+ strncat(buf, "/", MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, appData.icsLogon, MSG_SIZ - strlen(buf) - 1);
+ f = fopen(buf, "r");
}
}
- if (f != NULL)
- ProcessICSInitScript(f);
+
+ if (f != NULL)
+ ProcessICSInitScript(f);
+ else
+ printf("Warning: Couldn't open icsLogon file (checked %s and %s).\n", appData.icsLogon, buf);
+
+ return;
}
void
} 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);
+ }
+ w = XtNameToWidget(menuBarWidget, "menuStep.Annotate");
+ if (w == NULL) {
+ DisplayError("menuStep.Annotate", 0);
+ } else {
+ XtSetSensitive(w, !grey);
+ }
+}
+
+void
SetMenuEnables(enab)
Enables *enab;
{
{ "menuOptions.Hide Thinking", False },
{ "menuOptions.Ponder Next Move", False },
#endif
+ { "menuStep.Annotate", False },
{ NULL, False }
};
{ "menuMode.ICS Input Box", False },
{ "Action", False },
{ "menuStep.Revert", False },
+ { "menuStep.Annotate", False },
{ "menuStep.Move Now", False },
{ "menuStep.Retract Move", False },
{ "menuOptions.Auto Comment", False },
{ "menuAction.Adjourn", False },
{ "menuAction.Stop Examining", False },
{ "menuAction.Stop Observing", False },
+ { "menuAction.Upload to Examine", False },
{ "menuStep.Revert", False },
+ { "menuStep.Annotate", False },
{ "menuOptions.Auto Comment", False },
{ "menuOptions.Auto Observe", False },
{ "menuOptions.Auto Raise Board", False },
{
SetMenuEnables(icsEnables);
-#ifdef ZIPPY
+#if ZIPPY
if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
#endif
}
}
+// [HGM] code borrowed from winboard.c (which should thus go to backend.c!)
+#define HISTORY_SIZE 64\r
+static char *history[HISTORY_SIZE];\r
+int histIn = 0, histP = 0;\r
+\r
+void\r
+SaveInHistory(char *cmd)\r
+{\r
+ if (history[histIn] != NULL) {\r
+ free(history[histIn]);\r
+ history[histIn] = NULL;\r
+ }\r
+ if (*cmd == NULLCHAR) return;\r
+ history[histIn] = StrSave(cmd);\r
+ histIn = (histIn + 1) % HISTORY_SIZE;\r
+ if (history[histIn] != NULL) {\r
+ free(history[histIn]);\r
+ history[histIn] = NULL;\r
+ }\r
+ histP = histIn;\r
+}\r
+\r
+char *\r
+PrevInHistory(char *cmd)\r
+{\r
+ int newhp;\r
+ if (histP == histIn) {\r
+ if (history[histIn] != NULL) free(history[histIn]);\r
+ history[histIn] = StrSave(cmd);\r
+ }\r
+ newhp = (histP - 1 + HISTORY_SIZE) % HISTORY_SIZE;\r
+ if (newhp == histIn || history[newhp] == NULL) return NULL;\r
+ histP = newhp;\r
+ return history[histP];\r
+}\r
+\r
+char *\r
+NextInHistory()\r
+{\r
+ if (histP == histIn) return NULL;\r
+ histP = (histP + 1) % HISTORY_SIZE;\r
+ return history[histP]; \r
+}
+// end of borrowed code\r
+\r
#define Abs(n) ((n)<0 ? -(n) : (n))
/*
* The return value should be freed with XtFree when no
* longer needed.
*/
-char *FindFont(pattern, targetPxlSize)
+char *
+FindFont(pattern, targetPxlSize)
char *pattern;
int targetPxlSize;
{
XFontStruct **fnt_list;
base_fnt_lst = calloc(1, strlen(pattern) + 3);
- sprintf(strInt, "%d", targetPxlSize);
+ snprintf(strInt, sizeof(strInt)/sizeof(strInt[0]), "%d", targetPxlSize);
p = strstr(pattern, "--");
strncpy(base_fnt_lst, pattern, p - pattern + 2);
strcat(base_fnt_lst, strInt);
while (isdigit(*scalableTail)) scalableTail++;
sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
} else {
- p = (char *) XtMalloc(strlen(best) + 1);
- strcpy(p, best);
+ p = (char *) XtMalloc(strlen(best) + 2);
+ safeStrCpy(p, best, strlen(best)+1 );
}
if (appData.debugMode) {
fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
}
#if HAVE_LIBXPM
+void CreateXPMBoard(char *s, int kind)
+{
+ XpmAttributes attr;
+ attr.valuemask = 0;
+ if(s == NULL || *s == 0 || *s == '*') return;
+ if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
+ useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
+ }
+}
+
void CreateXPMPieces()
{
int piece, kind, r;
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 */
exit(1);
}
}
- if(piece <= (int) WhiteKing)
+ if(piece <= (int) WhiteKing)
xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
}
}
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
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(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
+ snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
+ ss, kind == SOLID ? 's' : 'o');
+ ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
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(&pieceBitmap2[kind][piece], buf,
- bib->bits[kind][piece], ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
+ snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
+ ss, kind == SOLID ? 's' : 'o');
+ ReadBitmap(&pieceBitmap2[kind][piece], buf,
+ bib->bits[kind][piece], ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
char msg[MSG_SIZ], fullname[MSG_SIZ];
if (*appData.bitmapDirectory != NULLCHAR) {
- strcpy(fullname, appData.bitmapDirectory);
- strcat(fullname, "/");
- strcat(fullname, name);
- errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
- &w, &h, pm, &x_hot, &y_hot);
- fprintf(stderr, "load %s\n", name);
+ safeStrCpy(fullname, appData.bitmapDirectory, sizeof(fullname)/sizeof(fullname[0]) );
+ strncat(fullname, "/", MSG_SIZ - strlen(fullname) - 1);
+ strncat(fullname, name, MSG_SIZ - strlen(fullname) - 1);
+ 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:
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);
}
formWidget, args, j);
while (mb->name != NULL) {
- strcpy(menuName, "menu");
- strcat(menuName, mb->name);
+ safeStrCpy(menuName, "menu", sizeof(menuName)/sizeof(menuName[0]) );
+ strncat(menuName, mb->name, MSG_SIZ - strlen(menuName) - 1);
j = 0;
XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;
if (tinyLayout) {
String *params;
Cardinal *num_params;
{
- String whichMenu;
- if (event->type != ButtonPress) return;
- if (errorUp) ErrorPopDown();
- switch (gameMode) {
- case EditPosition:
- case IcsExamining:
- whichMenu = params[0];
- break;
- case IcsPlayingWhite:
- case IcsPlayingBlack:
- case EditGame:
- case MachinePlaysWhite:
- case MachinePlaysBlack:
- if (appData.testLegality &&
- gameInfo.variant != VariantBughouse &&
- gameInfo.variant != VariantCrazyhouse) return;
- SetupDropMenu();
- whichMenu = "menuD";
- break;
- default:
- return;
- }
-
- if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_WIDTH)) < 0) ||
- ((pmFromY = EventToSquare(event->xbutton.y, BOARD_HEIGHT)) < 0)) {
- pmFromX = pmFromY = -1;
- return;
+ String whichMenu; int menuNr;
+ if (event->type == ButtonRelease)
+ menuNr = RightClick(Release, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
+ else if (event->type == ButtonPress)
+ menuNr = RightClick(Press, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
+ switch(menuNr) {
+ case 0: whichMenu = params[0]; break;
+ case 1: SetupDropMenu(); whichMenu = "menuD"; break;
+ case 2:
+ case -1: if (errorUp) ErrorPopDown();
+ default: return;
}
- if (flipView)
- pmFromX = BOARD_WIDTH - 1 - pmFromX;
- else
- pmFromY = BOARD_HEIGHT - 1 - pmFromY;
-
XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
}
if (hi1X >= 0 && hi1Y >= 0) {
drawHighlight(hi1X, hi1Y, lineGC);
}
+ } // [HGM] first erase both, then draw new!
+ if (hi2X != toX || hi2Y != toY) {
+ if (hi2X >= 0 && hi2Y >= 0) {
+ drawHighlight(hi2X, hi2Y, lineGC);
+ }
+ }
+ if (hi1X != fromX || hi1Y != fromY) {
if (fromX >= 0 && fromY >= 0) {
drawHighlight(fromX, fromY, highlineGC);
}
}
if (hi2X != toX || hi2Y != toY) {
- if (hi2X >= 0 && hi2Y >= 0) {
- drawHighlight(hi2X, hi2Y, lineGC);
- }
if (toX >= 0 && toY >= 0) {
drawHighlight(toX, toY, highlineGC);
}
SetPremoveHighlights(-1, -1, -1, -1);
}
-static void BlankSquare(x, y, color, piece, dest)
- int x, y, color;
+static int CutOutSquare(x, y, x0, y0, kind)
+ int x, y, *x0, *y0, kind;
+{
+ int W = BOARD_WIDTH, H = BOARD_HEIGHT;
+ int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
+ *x0 = 0; *y0 = 0;
+ if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
+ if(textureW[kind] < W*squareSize)
+ *x0 = (textureW[kind] - squareSize) * nx/(W-1);
+ else
+ *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
+ if(textureH[kind] < H*squareSize)
+ *y0 = (textureH[kind] - squareSize) * ny/(H-1);
+ else
+ *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
+ return 1;
+}
+
+static void BlankSquare(x, y, color, piece, dest, fac)
+ int x, y, color, fac;
ChessSquare piece;
Drawable dest;
-{
+{ // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
+ int x0, y0;
+ if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
+ XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
+ squareSize, squareSize, x*fac, y*fac);
+ } else
if (useImages && useImageSqs) {
Pixmap pm;
switch (color) {
break;
}
XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
+ squareSize, squareSize, x*fac, y*fac);
} else {
GC gc;
switch (color) {
gc = jailSquareGC;
break;
}
- XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);
+ XFillRectangle(xDisplay, dest, gc, x*fac, y*fac, squareSize, squareSize);
}
}
int square_color, x, y;
Drawable dest;
{
- int kind;
+ int kind, p = piece;
switch (square_color) {
case 1: /* light */
}
break;
}
+ if(appData.upsideDown && flipView) kind ^= 2; // swap white and black pieces
+ if(useTexture & square_color+1) {
+ BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+ XSetClipMask(xDisplay, wlPieceGC, xpmMask[p]);
+ XSetClipOrigin(xDisplay, wlPieceGC, x, y);
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece], dest, wlPieceGC, 0, 0, squareSize, squareSize, x, y);
+ XSetClipMask(xDisplay, wlPieceGC, None);
+ XSetClipOrigin(xDisplay, wlPieceGC, 0, 0);
+ } else
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, wlPieceGC, 0, 0,
squareSize, squareSize, x, y);
(squareSize + lineGap);
}
+ if(twoBoards && partnerUp) x += hOffset; // [HGM] dual: draw second board
+
square_color = SquareColor(row, column);
if ( // [HGM] holdings: blank out area between board and holdings
column == BOARD_LEFT-1 || column == BOARD_RGHT
|| (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
|| (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
- BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
+ BlankSquare(x, y, 2, EmptySquare, xBoardWindow, 1);
// [HGM] print piece counts next to holdings
string[1] = NULLCHAR;
}
} else {
if (piece == EmptySquare || appData.blindfold) {
- BlankSquare(x, y, square_color, piece, xBoardWindow);
+ BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
} else {
drawfunc = ChooseDrawFunc();
if (do_flash && appData.flashCount > 0) {
XSync(xDisplay, False);
do_flash_delay(flash_delay);
- BlankSquare(x, y, square_color, piece, xBoardWindow);
+ BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
XSync(xDisplay, False);
do_flash_delay(flash_delay);
}
x + 2, y + font_ascent + 1, string, 1);
}
}
+ if(!partnerUp && marker[row][column]) {
+ XFillArc(xDisplay, xBoardWindow, marker[row][column] == 2 ? prelineGC : highlineGC,
+ x + squareSize/4, y+squareSize/4, squareSize/2, squareSize/2, 0, 64*360);
+ }
}
case Expose:
if (event->xexpose.count > 0) return; /* no clipping is done */
XDrawPosition(widget, True, NULL);
+ if(twoBoards) { // [HGM] dual: draw other board in other orientation
+ flipView = !flipView; partnerUp = !partnerUp;
+ XDrawPosition(widget, True, NULL);
+ flipView = !flipView; partnerUp = !partnerUp;
+ }
break;
+ case MotionNotify:
+ if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;\r
default:
return;
}
return 0;
}
-static int damage[BOARD_SIZE][BOARD_SIZE];
+// [HGM] seekgraph: some low-level drawing routines cloned from xevalgraph
+void DrawSeekAxis( int x, int y, int xTo, int yTo )
+{
+ XDrawLine(xDisplay, xBoardWindow, lineGC, x, y, xTo, yTo);
+}
+
+void DrawSeekBackground( int left, int top, int right, int bottom )
+{
+ XFillRectangle(xDisplay, xBoardWindow, lightSquareGC, left, top, right-left, bottom-top);
+}
+
+void DrawSeekText(char *buf, int x, int y)
+{
+ XDrawString(xDisplay, xBoardWindow, coordGC, x, y+4, buf, strlen(buf));
+}
+
+void DrawSeekDot(int x, int y, int colorNr)
+{
+ int square = colorNr & 0x80;
+ GC color;
+ colorNr &= 0x7F;
+ color = colorNr == 0 ? prelineGC : colorNr == 1 ? darkSquareGC : highlineGC;
+ if(square)
+ XFillRectangle(xDisplay, xBoardWindow, color,
+ x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
+ else
+ XFillArc(xDisplay, xBoardWindow, color,
+ x-squareSize/8, y-squareSize/8, squareSize/4, squareSize/4, 0, 64*360);
+}
+
+static int damage[2][BOARD_RANKS][BOARD_FILES];
/*
* event handler for redrawing the board
{
int i, j, do_flash;
static int lastFlipView = 0;
- static int lastBoardValid = 0;
- static Board lastBoard;
+ static int lastBoardValid[2] = {0, 0};
+ static Board lastBoard[2];
Arg args[16];
int rrow, rcol;
+ int nr = twoBoards*partnerUp;
+
+ if(DrawSeekGraph()) return; // [HGM] seekgraph: suppress any drawing if seek graph up
if (board == NULL) {
- if (!lastBoardValid) return;
- board = lastBoard;
+ if (!lastBoardValid[nr]) return;
+ board = lastBoard[nr];
}
- if (!lastBoardValid || lastFlipView != flipView) {
+ if (!lastBoardValid[nr] || (nr == 0 && lastFlipView != flipView)) {
XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
args, 1);
* but this causes a very distracting flicker.
*/
- if (!repaint && lastBoardValid && lastFlipView == flipView) {
+ if (!repaint && lastBoardValid[nr] && (nr == 1 || lastFlipView == flipView)) {
/* If too much changes (begin observing new game, etc.), don't
do flashing */
- do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
+ do_flash = too_many_diffs(board, lastBoard[nr]) ? 0 : 1;
/* Special check for castling so we don't flash both the king
and the rook (just flash the king). */
if (do_flash) {
- if (check_castle_draw(board, lastBoard, &rrow, &rcol)) {
+ if (check_castle_draw(board, lastBoard[nr], &rrow, &rcol)) {
/* Draw rook with NO flashing. King will be drawn flashing later */
DrawSquare(rrow, rcol, board[rrow][rcol], 0);
- lastBoard[rrow][rcol] = board[rrow][rcol];
+ lastBoard[nr][rrow][rcol] = board[rrow][rcol];
}
}
is flashing on its new square */
for (i = 0; i < BOARD_HEIGHT; i++)
for (j = 0; j < BOARD_WIDTH; j++)
- if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
- || damage[i][j]) {
+ if ((board[i][j] != lastBoard[nr][i][j] && board[i][j] == EmptySquare)
+ || damage[nr][i][j]) {
DrawSquare(i, j, board[i][j], 0);
- damage[i][j] = False;
+ damage[nr][i][j] = False;
}
/* Second pass -- Draw piece(s) in new position and flash them */
for (i = 0; i < BOARD_HEIGHT; i++)
for (j = 0; j < BOARD_WIDTH; j++)
- if (board[i][j] != lastBoard[i][j]) {
+ if (board[i][j] != lastBoard[nr][i][j]) {
DrawSquare(i, j, board[i][j], do_flash);
}
} else {
if (lineGap > 0)
XDrawSegments(xDisplay, xBoardWindow, lineGC,
+ twoBoards & partnerUp ? secondSegments : // [HGM] dual
gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
for (i = 0; i < BOARD_HEIGHT; i++)
for (j = 0; j < BOARD_WIDTH; j++) {
DrawSquare(i, j, board[i][j], 0);
- damage[i][j] = False;
+ damage[nr][i][j] = False;
}
}
- CopyBoard(lastBoard, board);
- lastBoardValid = 1;
+ CopyBoard(lastBoard[nr], board);
+ lastBoardValid[nr] = 1;
+ if(nr == 0) { // [HGM] dual: no highlights on second board yet
lastFlipView = flipView;
/* Draw highlights */
if (hi2X >= 0 && hi2Y >= 0) {
drawHighlight(hi2X, hi2Y, highlineGC);
}
-
+ }
/* If piece being dragged around board, must redraw that too */
DrawDragPiece();
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(nprms) shiftKey = !strcmp(prms[0], "1");
if (promotionUp) {
if (event->type == ButtonPress) {
}
}
- 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;
- int frc;
-
- /* Check if clicking again on the same color piece */
- fromP = boards[currentMove][fromY][fromX];
- toP = boards[currentMove][y][x];
- frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
- if ((WhitePawn <= fromP && fromP <= WhiteKing && // [HGM] this test should go, as UserMoveTest now does it.
- WhitePawn <= toP && toP <= WhiteKing &&
- !(fromP == WhiteKing && toP == WhiteRook && frc)) ||
- (BlackPawn <= fromP && fromP <= BlackKing &&
- BlackPawn <= toP && toP <= BlackKing &&
- !(fromP == BlackKing && toP == BlackRook && frc))) {
- /* 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,
DragPieceMove(event->xmotion.x, event->xmotion.y);
}
+void HandlePV (Widget w, XEvent * event,
+ String * params, Cardinal * nParams)
+{ // [HGM] pv: walk PV
+ MovePV(event->xmotion.x, event->xmotion.y, lineGap + BOARD_HEIGHT * (squareSize + lineGap));
+}
+
Widget CommentCreate(name, text, mutable, callback, lines)
char *name, *text;
int /*Boolean*/ mutable;
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 =
XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);
+ XtOverrideTranslations(edit, XtParseTranslationTable(commentTranslations));
if (mutable) {
j = 0;
#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++;
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 =
static int savedIndex; /* gross that this is global */
+void CommentClick (Widget w, XEvent * event, String * params, Cardinal * nParams)
+{
+ String val;
+ XawTextPosition index, dummy;
+ Arg arg;
+
+ XawTextGetSelectionPos(w, &index, &dummy);
+ XtSetArg(arg, XtNstring, &val);
+ XtGetValues(w, &arg, 1);
+ ReplaceComment(savedIndex, val);
+ if(savedIndex != currentMove) ToNrEvent(savedIndex);
+ LoadVariation( index, val ); // [HGM] also does the actual moving to it, now
+}
+
void EditCommentPopUp(index, title, text)
int index;
char *title, *text;
j = 0;
XtSetArg(args[j], XtNstring, &val); j++;
XtGetValues(edit, args, j);
+ SaveInHistory(val);
SendMultiLineToICS(val);
XtCallActionProc(edit, "select-all", NULL, NULL, 0);
XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
int j;
Widget edit;
+ savedIndex = currentMove; // [HGM] vari
if (commentShell == NULL) {
commentShell =
CommentCreate(title, text, False, CommentCallback, 4);
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;
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;
FileProc proc;
char *openMode;
{
- Arg args[16];
- Widget popup, layout, dialog, edit;
- Window root, child;
- int x, y, i;
- int win_x, win_y;
- unsigned int mask;
-
fileProc = proc; /* I can't see a way not */
fileOpenMode = openMode; /* to use globals here */
-
- i = 0;
- XtSetArg(args[i], XtNresizable, True); i++;
- XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
- XtSetArg(args[i], XtNtitle, XtNewString(_("File name prompt"))); i++;
- fileNameShell = popup =
- XtCreatePopupShell("File name prompt", transientShellWidgetClass,
- shellWidget, args, i);
-
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,
- layoutArgs, XtNumber(layoutArgs));
-
- i = 0;
- XtSetArg(args[i], XtNlabel, label); i++;
- XtSetArg(args[i], XtNvalue, def); i++;
- XtSetArg(args[i], XtNborderWidth, 0); i++;
- dialog = XtCreateManagedWidget("fileName", dialogWidgetClass,
- layout, args, i);
-
- XawDialogAddButton(dialog, _("ok"), FileNameCallback, (XtPointer) dialog);
- XawDialogAddButton(dialog, _("cancel"), FileNameCallback,
- (XtPointer) dialog);
-
- XtRealizeWidget(popup);
- CatchDeleteWindow(popup, "FileNamePopDown");
-
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,
- &x, &y, &win_x, &win_y, &mask);
-
- XtSetArg(args[0], XtNx, x - 10);
- XtSetArg(args[1], XtNy, y - 30);
- XtSetValues(popup, args, 2);
-
- XtPopup(popup, XtGrabExclusive);
- filenameUp = True;
-
- edit = XtNameToWidget(dialog, "*value");
- XtSetKeyboardFocus(popup, edit);
+ { // [HGM] use file-selector dialog stolen from Ghostview
+ char *name;
+ int index; // this is not supported yet
+ FILE *f;
+ if(f = XsraSelFile(shellWidget, label, NULL, NULL, "could not open: ",
+ def, openMode, NULL, &name))
+ (void) (*fileProc)(f, index=0, name);
+ }
}
void FileNamePopDown()
name = XawDialogGetValueString(w = XtParent(w));
if ((name != NULL) && (*name != NULLCHAR)) {
- strcpy(buf, name);
+ safeStrCpy(buf, name, sizeof(buf)/sizeof(buf[0]) );
XtPopdown(w = XtParent(XtParent(w)));
XtDestroyWidget(w);
filenameUp = False;
XawDialogAddButton(dialog, _("King"), PromotionCallback,
(XtPointer) dialog);
}
- if(gameInfo.variant == VariantCapablanca ||
- gameInfo.variant == VariantGothic ||
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
gameInfo.variant == VariantCapaRandom) {
XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
(XtPointer) dialog);
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. */
XtSetArg(args[0], XtNbackground, oldfg);
XtSetArg(args[1], XtNforeground, oldbg);
}
-#endif
XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
}
}
Cardinal *nprms;
{
ResetGameEvent();
- AnalysisPopDown();
}
int LoadGamePopUp(f, gameNumber, title)
}
/* this variable is shared between CopyPositionProc and SendPositionSelection */
-static char *selected_fen_position=NULL;
+char *selected_fen_position=NULL;
-static Boolean
+Boolean
SendPositionSelection(Widget w, Atom *selection, Atom *target,
Atom *type_return, XtPointer *value_return,
unsigned long *length_return, int *format_return)
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 */
selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
- strcpy(selection_tmp, selected_fen_position);
+ safeStrCpy(selection_tmp, selected_fen_position, sizeof(selection_tmp)/sizeof(selection_tmp[0]) );
*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;
}
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 */
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 */
{
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;
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;
}
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 */
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 */
/* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
if (appData.icsActive) {
if (gameMode != IcsObserving) {
- sprintf(buf,_("You are not observing a game"));
+ snprintf(buf, MSG_SIZ, _("You are not observing a game"));
DisplayError(buf, 0);
/* secure check */
if (appData.icsEngineAnalyze) {
ICSInputSendText();
}
+void UpKeyProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{ // [HGM] input: let up-arrow recall previous line from history
+ Widget edit;
+ int j;
+ Arg args[16];
+ String val;
+ XawTextBlock t;
+
+ if (!ICSInputBoxUp) return;
+ edit = XtNameToWidget(ICSInputShell, "*form.text");
+ j = 0;
+ XtSetArg(args[j], XtNstring, &val); j++;
+ XtGetValues(edit, args, j);
+ val = PrevInHistory(val);
+ XtCallActionProc(edit, "select-all", NULL, NULL, 0);
+ XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
+ if(val) {
+ t.ptr = val; t.firstPos = 0; t.length = strlen(val); t.format = XawFmt8Bit;
+ XawTextReplace(edit, 0, 0, &t);
+ XawTextSetInsertionPoint(edit, 9999);
+ }
+}
+
+void DownKeyProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{ // [HGM] input: let down-arrow recall next line from history
+ Widget edit;
+ String val;
+ XawTextBlock t;
+
+ if (!ICSInputBoxUp) return;
+ edit = XtNameToWidget(ICSInputShell, "*form.text");
+ val = NextInHistory();
+ XtCallActionProc(edit, "select-all", NULL, NULL, 0);
+ XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
+ if(val) {
+ t.ptr = val; t.firstPos = 0; t.length = strlen(val); t.format = XawFmt8Bit;
+ XawTextReplace(edit, 0, 0, &t);
+ XawTextSetInsertionPoint(edit, 9999);
+ }
+}
+
void StopObservingProc(w, event, prms, nprms)
Widget w;
XEvent *event;
StopExaminingEvent();
}
+void UploadProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UploadGameEvent();
+}
+
void ForwardProc(w, event, prms, nprms)
Widget w;
String *prms;
Cardinal *nprms;
{
- RevertEvent();
+ RevertEvent(False);
+}
+
+void AnnotateProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ RevertEvent(True);
}
void TruncateGameProc(w, event, prms, nprms)
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;
{
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;
void DisplayMessage(message, extMessage)
char *message, *extMessage;
{
- char buf[MSG_SIZ];
- Arg arg;
+ /* display a message in the message widget */
- if (extMessage) {
- if (*message) {
- snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
- message = buf;
- } else {
- message = extMessage;
+ char buf[MSG_SIZ];
+ Arg arg;
+
+ if (extMessage)
+ {
+ if (*message)
+ {
+ snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
+ message = buf;
}
- }
- XtSetArg(arg, XtNlabel, message);
- XtSetValues(messageWidget, &arg, 1);
+ 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)
}
if (*text != NULLCHAR) {
- strcpy(icon, text);
- strcpy(title, text);
+ safeStrCpy(icon, text, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, text, sizeof(title)/sizeof(title[0]) );
} else if (appData.icsActive) {
snprintf(icon, sizeof(icon), "%s", appData.icsHost);
snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
#ifdef GOTHIC
// [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
} else if (gameInfo.variant == VariantGothic) {
- strcpy(icon, programName);
- strcpy(title, GOTHIC);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, GOTHIC, sizeof(title)/sizeof(title[0]) );
#endif
#ifdef FALCON
} else if (gameInfo.variant == VariantFalcon) {
- strcpy(icon, programName);
- strcpy(title, FALCON);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, FALCON, sizeof(title)/sizeof(title[0]) );
#endif
} else if (appData.noChessProgram) {
- strcpy(icon, programName);
- strcpy(title, programName);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, programName, sizeof(title)/sizeof(title[0]) );
} else {
- strcpy(icon, first.tidy);
+ safeStrCpy(icon, first.tidy, sizeof(icon)/sizeof(icon[0]) );
snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
}
i = 0;
}
-void DisplayError(message, error)
+void
+DisplayError(message, error)
String message;
int error;
{
String reply;
reply = XawDialogGetValueString(w = XtParent(w));
- strcpy(buf, pendingReplyPrefix);
- if (*buf) strcat(buf, " ");
- strcat(buf, reply);
- strcat(buf, "\n");
+ safeStrCpy(buf, pendingReplyPrefix, sizeof(buf)/sizeof(buf[0]) );
+ if (*buf) strncat(buf, " ", MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, reply, MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, "\n", MSG_SIZ - strlen(buf) - 1);
OutputToProcess(pendingReplyPR, buf, strlen(buf), &err);
AskQuestionPopDown();
int win_x, win_y;
unsigned int mask;
- strcpy(pendingReplyPrefix, replyPrefix);
+ safeStrCpy(pendingReplyPrefix, replyPrefix, sizeof(pendingReplyPrefix)/sizeof(pendingReplyPrefix[0]) );
pendingReplyPR = pr;
i = 0;
if (textColors[(int)cc].bg > 0) {
if (textColors[(int)cc].fg > 0) {
- sprintf(buf, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
- textColors[(int)cc].fg, textColors[(int)cc].bg);
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
+ textColors[(int)cc].fg, textColors[(int)cc].bg);
} else {
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
- textColors[(int)cc].bg);
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%dm", textColors[(int)cc].attr,
+ textColors[(int)cc].bg);
}
} else {
if (textColors[(int)cc].fg > 0) {
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%dm", textColors[(int)cc].attr,
textColors[(int)cc].fg);
} else {
- sprintf(buf, "\033[0;%dm", textColors[(int)cc].attr);
+ snprintf(buf, MSG_SIZ, "\033[0;%dm", textColors[(int)cc].attr);
}
}
count = strlen(buf);
return getpwuid(getuid())->pw_name;
}
-static char *ExpandPathName(path)
+static char *
+ExpandPathName(path)
char *path;
{
- static char static_buf[2000];
- char *d, *s, buf[2000];
+ static char static_buf[4*MSG_SIZ];
+ char *d, *s, buf[4*MSG_SIZ];
struct passwd *pwd;
s = path;
if (*s == '~') {
if (*(s+1) == '/') {
- strcpy(d, getpwuid(getuid())->pw_dir);
- strcat(d, s+1);
+ safeStrCpy(d, getpwuid(getuid())->pw_dir, 4*MSG_SIZ );
+ strcat(d, s+1);
}
else {
- strcpy(buf, s+1);
- *strchr(buf, '/') = 0;
- pwd = getpwnam(buf);
- if (!pwd)
- {
- fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
- buf, path);
- return NULL;
- }
- strcpy(d, pwd->pw_dir);
- strcat(d, strchr(s+1, '/'));
+ safeStrCpy(buf, s+1, sizeof(buf)/sizeof(buf[0]) );
+ *strchr(buf, '/') = 0;
+ pwd = getpwnam(buf);
+ if (!pwd)
+ {
+ fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
+ buf, path);
+ return NULL;
+ }
+ safeStrCpy(d, pwd->pw_dir, 4*MSG_SIZ );
+ strcat(d, strchr(s+1, '/'));
}
}
else
- strcpy(d, s);
+ safeStrCpy(d, s, 4*MSG_SIZ );
return static_buf;
}
Pixel foregroundOrWarningColor = timerForegroundPixel;
if (timer > 0 &&
- appData.lowTimeWarning &&
+ appData.lowTimeWarning &&
(timer / 1000) < appData.icsAlarmTime)
foregroundOrWarningColor = lowTimeWarningColor;
if (appData.clockMode) {
- sprintf(buf, "%s: %s", color, TimeString(timer));
- XtSetArg(args[0], XtNlabel, buf);
+ snprintf(buf, MSG_SIZ, "%s: %s", color, TimeString(timer));
+ XtSetArg(args[0], XtNlabel, buf);
} else {
- sprintf(buf, "%s ", color);
- XtSetArg(args[0], XtNlabel, buf);
+ snprintf(buf, MSG_SIZ, "%s ", color);
+ XtSetArg(args[0], XtNlabel, buf);
}
if (highlight) {
most simple-minded way possible.
*/
i = 0;
- strcpy(buf, cmdLine);
+ safeStrCpy(buf, cmdLine, sizeof(buf)/sizeof(buf[0]) );
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;
}
}
q = is->buf;
while (p < is->unused) {
- *q++ = *p++;
+ *q++ = *p++;
}
is->unused = q;
} else {
- count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
- if (count == -1)
- error = errno;
- else
- error = 0;
- (is->func)(is, is->closure, is->buf, count, error);
+# if HAVE_LIBREADLINE
+ /* check if input is from stdin, if yes, use gnu-readline */
+ if( is->fd==fileno(stdin) )
+ {
+ /* to clear the line */
+ printf("\r \r");
+
+ /* read from stdin */
+ rl_callback_read_char();
+
+ /* redisplay the current line, check special case for login and password */
+ if(sending_ICS_password)
+ {
+ int i; char buf[MSG_SIZ];
+
+ bzero(buf,MSG_SIZ);
+
+ /* blank the password */
+ count = strlen(rl_line_buffer);
+ if(count>MSG_SIZ-1)
+ {
+ printf("PROBLEM with readline\n");
+ count=MSG_SIZ;
+ }
+ for(i=0;i<count;i++)
+ buf[i]='*';
+ i++;
+ buf[i]='\0';
+ printf("\rpassword: %s",buf);
+ }
+ else if (sending_ICS_login)
+ {
+ /* show login prompt */
+ count = strlen(rl_line_buffer);
+ printf("\rlogin: %s",rl_line_buffer);
+ }
+ else
+ rl_reset_line_state();
+
+ if(readline_complete)
+ {
+ /* copy into XBoards buffer */
+ count = strlen(readline_buffer);
+ if (count>INPUT_SOURCE_BUF_SIZE-1)
+ {
+ printf("PROBLEM with readline\n");
+ count = INPUT_SOURCE_BUF_SIZE;
+ };
+ strncpy(is->buf,readline_buffer,count);
+ is->buf[count]='\n';count++;
+
+ /* reset gnu-readline state */
+ free(readline_buffer);
+ readline_buffer=NULL;
+ readline_complete=0;
+
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+
+ /* are we done with the password? */
+ if(sending_ICS_password)
+ sending_ICS_password=0;
+ if(sending_ICS_login)
+ sending_ICS_login=0;
+ }
+ }
+ else
+ {
+ /* input not from stdin, use default method */
+ count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+ };
+#else /* no readline support */
+ count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+#endif
+
}
}
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);
+ }
+ }
+
+# if HAVE_LIBREADLINE
+ /* readline support */
+ if(strlen(rl_line_buffer))
+ printf("\n> %s",rl_line_buffer);
+#endif
+
+ }
else
outCount = write(cp->fdTo, message, count);
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);
kind = 0;
else
kind = 2;
+ if(appData.upsideDown && flipView) kind ^= 2;
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, clip,
0, 0, squareSize, squareSize,
Pixmap mask;
/* The old buffer is initialised with the start square (empty) */
- BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
+ BlankSquare(start->x, start->y, startColor, EmptySquare, anim->saveBuf, 0);
anim->prevFrame = *start;
/* The piece will be drawn using its own bitmap as a matte */
if (!appData.animate || appData.blindfold)
return;
- if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
- board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
+ 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;
FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
/* Be sure end square is redrawn */
- damage[toY][toX] = True;
+ damage[0][toY][toX] = True;
}
-static void
+void
DragPieceBegin(x, y)
int x; int 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 */
XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
corner.x, corner.y, squareSize, squareSize,
0, 0); // [HGM] zh: unstack in stead of grab
- damage[boardY][boardX] = True;
+ damage[0][boardY][boardX] = True;
} else {
player.dragActive = False;
}
corner.x = x - player.mouseDelta.x;
corner.y = y - player.mouseDelta.y;
AnimationFrame(&player, &corner, player.dragPiece);
-#if HIGHDRAG
+#if HIGHDRAG*0
if (appData.highlightDragging) {
int boardX, boardY;
BoardSquare(x, y, &boardX, &boardY);
#endif
}
-static void
+void
DragPieceEnd(x, y)
int x; int y;
{
EndAnimation(&player, &corner);
/* Be sure end square is redrawn */
- damage[boardY][boardX] = True;
+ damage[0][boardY][boardX] = True;
/* This prevents weird things happening with fast successive
clicks which on my Sun at least can cause motion events
it's being dragged around the board. So we erase the square
that the piece is on and draw it at the last known drag point. */
BlankSquare(player.startSquare.x, player.startSquare.y,
- player.startColor, EmptySquare, xBoardWindow);
+ player.startColor, EmptySquare, xBoardWindow, 1);
AnimationFrame(&player, &player.prevFrame, player.dragPiece);
- damage[player.startBoardY][player.startBoardX] = TRUE;
+ damage[0][player.startBoardY][player.startBoardX] = TRUE;
+}
+
+#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
-SetProgramStats( FrontEndProgramStats * stats )
+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()
+{
+ update_ics_width();
+}
+
+# if HAVE_LIBREADLINE
+static void
+ReadlineCompleteHandler(char* ptr)
{
- // [HR] TODO
- // [HGM] done, but perhaps backend should call this directly?
- EngineOutputUpdate( stats );
+ /* make gnu-readline keep the history */
+ readline_buffer = ptr;
+ readline_complete = 1;
+
+ if (ptr && *ptr && !sending_ICS_password && !sending_ICS_login)
+ add_history(ptr);
+
+ return;
}
+#endif