*------------------------------------------------------------------------
** See the file ChangeLog for a revision history. */
+#define HIGHDRAG 1
+
#include "config.h"
#include <stdio.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>
// 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__
int main P((int argc, char **argv));
RETSIGTYPE CmailSigHandler P((int sig));
RETSIGTYPE IntSigHandler P((int sig));
+RETSIGTYPE TermSizeSigHandler P((int sig));
void CreateGCs P((void));
void CreateXIMPieces P((void));
void CreateXPMPieces P((void));
void CreatePieces P((void));
void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb));
-Widget CreateButtonBar P ((MenuItem *mi));
char *FindFont P((char *pattern, int targetPxlSize));
void PieceMenuPopup P((Widget w, XEvent *event,
String *params, Cardinal *num_params));
static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
int EventToSquare P((int x, int limit));
void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
-void HandleUserMove P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void AnimateUserMove 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 HandlePV 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,
XtPointer call_data));
void ICSInputBoxPopUp P((void));
void ICSInputBoxPopDown P((void));
-void FileNamePopUp P((char *label, char *def,
- FileProc proc, char *openMode));
-void FileNamePopDown P((void));
-void FileNameCallback P((Widget w, XtPointer client_data,
- XtPointer call_data));
-void FileNameAction P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void AskQuestionReplyAction P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
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 EditCommentCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
-void LoadPositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void CopyPositionProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void PastePositionProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void SavePositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
-void AnalyzeModeProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void AnalyzeFileProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void EditPositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EditCommentProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void IcsInputBoxProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutocommProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutobsProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void FlashMovesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void QuietPlayProc 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 AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ErrorPopDown P((void));
static char *ExpandPathName P((char *path));
static void CreateAnimVars P((void));
-void DragPieceBegin P((int x, int y));
static void DragPieceMove P((int x, int y));
-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 NewVariantPopDown P(());
void SettingsPopDown P(());
void SetMenuEnables P((Enables *enab));
-
+void update_ics_width P(());
+int get_term_width P(());
+int CopyMemoProc P(());
/*
* XBoard depends on Xt R4 or higher
*/
int xtVersion = XtSpecificationRelease;
int xScreen;
-Display *xDisplay;
+
Window xBoardWindow;
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
jailSquareColor, highlightSquareColor, premoveHighlightColor;
bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC,
wjPieceGC, bjPieceGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
+Widget layoutWidget, formWidget, boardWidget, messageWidget,
whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
- menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
+ menuBarWidget, editShell, errorShell, analysisShell,
ICSInputShell, fileNameShell, askQuestionShell;
+
+Widget evalGraphShell, gameListShell;
+//XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+//XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
+
Font clockFontID, coordFontID, countFontID;
XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
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
MenuItem fileMenu[] = {
{N_("New Shuffle Game ..."), ShuffleMenuProc},
{N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
- {"----", NothingProc},
- {N_("Save Game"), SaveGameProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
+ // {N_("Save Game"), SaveGameProc},
+ // {"----", NothingProc},
{N_("Copy Game"), CopyGameProc},
{N_("Paste Game"), PasteGameProc},
- {"----", NothingProc},
- {N_("Load Position"), LoadPositionProc},
- {N_("Load Next Position"), LoadNextPositionProc},
- {N_("Load Previous Position"), LoadPrevPositionProc},
- {N_("Reload Same Position"), ReloadPositionProc},
- {N_("Save Position"), SavePositionProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
+ // {N_("Load Position"), LoadPositionProc},
+ // {N_("Load Next Position"), LoadNextPositionProc},
+ // {N_("Load Previous Position"), LoadPrevPositionProc},
+ // {N_("Reload Same Position"), ReloadPositionProc},
+ // {N_("Save Position"), SavePositionProc},
+ // {"----", NothingProc},
{N_("Copy Position"), CopyPositionProc},
{N_("Paste Position"), PastePositionProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
{N_("Mail Move"), MailMoveProc},
{N_("Reload CMail Message"), ReloadCmailMsgProc},
- {"----", NothingProc},
+ // {"----", NothingProc},
{NULL, NULL}
};
// {N_("Machine White"), MachineWhiteProc},
// {N_("Machine Black"), MachineBlackProc},
// {N_("Two Machines"), TwoMachinesProc},
- {N_("Analysis Mode"), AnalyzeModeProc},
- {N_("Analyze File"), AnalyzeFileProc },
+ // {N_("Analysis Mode"), AnalyzeModeProc},
+ // {N_("Analyze File"), AnalyzeFileProc },
// {N_("ICS Client"), IcsClientProc},
- {N_("Edit Game"), EditGameProc},
- {N_("Edit Position"), EditPositionProc},
- {N_("Training"), TrainingProc},
- {"----", NothingProc},
+ // {N_("Edit Game"), EditGameProc},
+ // {N_("Edit Position"), EditPositionProc},
+ // {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
- {"----", NothingProc},
- {N_("Edit Tags"), EditTagsProc},
+ // {"----", NothingProc},
+ // {N_("Edit Tags"), EditTagsProc},
{N_("Edit Comment"), EditCommentProc},
{N_("ICS Input Box"), IcsInputBoxProc},
{NULL, NULL}
{N_("Engine #2 Settings ..."), SecondSettingsProc},
{N_("Time Control ..."), TimeControlProc},
{"----", NothingProc},
- {N_("Always Queen"), AlwaysQueenProc},
- {N_("Animate Dragging"), AnimateDraggingProc},
- {N_("Animate Moving"), AnimateMovingProc},
- {N_("Auto Comment"), AutocommProc},
- {N_("Auto Flag"), AutoflagProc},
- {N_("Auto Flip View"), AutoflipProc},
- {N_("Auto Observe"), AutobsProc},
- {N_("Auto Raise Board"), AutoraiseProc},
- {N_("Auto Save"), AutosaveProc},
- {N_("Blindfold"), BlindfoldProc},
- {N_("Flash Moves"), FlashMovesProc},
+ // {N_("Always Queen"), AlwaysQueenProc},
+ // {N_("Animate Dragging"), AnimateDraggingProc},
+ // {N_("Animate Moving"), AnimateMovingProc},
+ // {N_("Auto Comment"), AutocommProc},
+ // {N_("Auto Flag"), AutoflagProc},
+ // {N_("Auto Flip View"), AutoflipProc},
+ // {N_("Auto Observe"), AutobsProc},
+ // {N_("Auto Raise Board"), AutoraiseProc},
+ // {N_("Auto Save"), AutosaveProc},
+ // {N_("Blindfold"), BlindfoldProc},
+ // {N_("Flash Moves"), FlashMovesProc},
// {N_("Get Move List"), GetMoveListProc},
-#if HIGHDRAG
- {N_("Highlight Dragging"), HighlightDraggingProc},
-#endif
- {N_("Highlight Last Move"), HighlightLastMoveProc},
- {N_("Move Sound"), MoveSoundProc},
- {N_("ICS Alarm"), IcsAlarmProc},
- {N_("Old Save Style"), OldSaveStyleProc},
- {N_("Periodic Updates"), PeriodicUpdatesProc},
- {N_("Ponder Next Move"), PonderNextMoveProc},
- {N_("Popup Exit Message"), PopupExitMessageProc},
- {N_("Popup Move Errors"), PopupMoveErrorsProc},
- {N_("Premove"), PremoveProc},
- {N_("Quiet Play"), QuietPlayProc},
+ //#if HIGHDRAG
+ // {N_("Highlight Dragging"), HighlightDraggingProc},
+ //#endif
+ // {N_("Highlight Last Move"), HighlightLastMoveProc},
+ // {N_("Move Sound"), MoveSoundProc},
+ // {N_("ICS Alarm"), IcsAlarmProc},
+ // {N_("Old Save Style"), OldSaveStyleProc},
+ // {N_("Periodic Updates"), PeriodicUpdatesProc},
+ // {N_("Ponder Next Move"), PonderNextMoveProc},
+ // {N_("Popup Exit Message"), PopupExitMessageProc},
+ // {N_("Popup Move Errors"), PopupMoveErrorsProc},
+ // {N_("Premove"), PremoveProc},
+ // {N_("Quiet Play"), QuietPlayProc},
// {N_("Hide Thinking"), HideThinkingProc},
- {N_("Test Legality"), TestLegalityProc},
+ // {N_("Test Legality"), TestLegalityProc},
+ // {N_("Show Coords"), ShowCoordsProc},
+ {"----", NothingProc},
+ {N_("Save Settings Now"), SaveSettingsProc},
+ {N_("Save Settings on Exit"), SaveOnExitProc},
{NULL, NULL}
};
{NULL, NULL}
};
-#define PAUSE_BUTTON N_("P")
-MenuItem buttonBar[] = {
- // {"<<", ToStartProc},
- // {"<", BackwardProc},
- // {PAUSE_BUTTON, PauseProc},
- // {">", ForwardProc},
- // {">>", ToEndProc},
- {NULL, NULL}
-};
-
#define PIECE_MENU_SIZE 18
String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
{ N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
};
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},
- { "forceIllegalMoves", "forceIllegalMoves", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, forceIllegal),
- XtRImmediate, (XtPointer) False},
};
-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 },
- { "-forceIllegalMoves", "forceIllegalMoves", XrmoptionNoArg, "True" },
-};
-
-
XtActionsRec boardActions[] = {
- { "HandleUserMove", HandleUserMove },
+ // { "HandleUserMove", HandleUserMove },
{ "AnimateUserMove", AnimateUserMove },
- { "FileNameAction", FileNameAction },
+ // { "FileNameAction", FileNameAction },
+ { "HandlePV", HandlePV },
+ { "UnLoadPV", UnLoadPV },
{ "AskQuestionProc", AskQuestionProc },
{ "AskQuestionReplyAction", AskQuestionReplyAction },
{ "PieceMenuPopup", PieceMenuPopup },
- { "WhiteClock", WhiteClock },
- { "BlackClock", BlackClock },
+ // { "WhiteClock", WhiteClock },
+ // { "BlackClock", BlackClock },
{ "Iconify", Iconify },
{ "LoadSelectedProc", LoadSelectedProc },
- { "LoadPositionProc", LoadPositionProc },
- { "LoadNextPositionProc", LoadNextPositionProc },
- { "LoadPrevPositionProc", LoadPrevPositionProc },
- { "ReloadPositionProc", ReloadPositionProc },
+ // { "LoadPositionProc", LoadPositionProc },
+ // { "LoadNextPositionProc", LoadNextPositionProc },
+ // { "LoadPrevPositionProc", LoadPrevPositionProc },
+ // { "ReloadPositionProc", ReloadPositionProc },
{ "CopyPositionProc", CopyPositionProc },
{ "PastePositionProc", PastePositionProc },
{ "CopyGameProc", CopyGameProc },
{ "PasteGameProc", PasteGameProc },
- { "SaveGameProc", SaveGameProc },
- { "SavePositionProc", SavePositionProc },
+ // { "SaveGameProc", SaveGameProc },
+ // { "SavePositionProc", SavePositionProc },
{ "MailMoveProc", MailMoveProc },
{ "ReloadCmailMsgProc", ReloadCmailMsgProc },
// { "MachineWhiteProc", MachineWhiteProc },
// { "MachineBlackProc", MachineBlackProc },
- { "AnalysisModeProc", AnalyzeModeProc },
- { "AnalyzeFileProc", AnalyzeFileProc },
+ // { "AnalysisModeProc", AnalyzeModeProc },
+ // { "AnalyzeFileProc", AnalyzeFileProc },
// { "TwoMachinesProc", TwoMachinesProc },
// { "IcsClientProc", IcsClientProc },
- { "EditGameProc", EditGameProc },
- { "EditPositionProc", EditPositionProc },
- { "TrainingProc", EditPositionProc },
+ // { "EditGameProc", EditGameProc },
+ // { "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 },
+ // { "EditTagsProc", EditCommentProc },
{ "EditCommentProc", EditCommentProc },
- { "IcsAlarmProc", IcsAlarmProc },
+ // { "IcsAlarmProc", IcsAlarmProc },
{ "IcsInputBoxProc", IcsInputBoxProc },
// { "AcceptProc", AcceptProc },
// { "DeclineProc", DeclineProc },
// { "TruncateGameProc", TruncateGameProc },
// { "MoveNowProc", MoveNowProc },
// { "RetractMoveProc", RetractMoveProc },
- { "AlwaysQueenProc", AlwaysQueenProc },
- { "AnimateDraggingProc", AnimateDraggingProc },
- { "AnimateMovingProc", AnimateMovingProc },
- { "AutoflagProc", AutoflagProc },
- { "AutoflipProc", AutoflipProc },
- { "AutobsProc", AutobsProc },
- { "AutoraiseProc", AutoraiseProc },
- { "AutosaveProc", AutosaveProc },
- { "BlindfoldProc", BlindfoldProc },
- { "FlashMovesProc", FlashMovesProc },
+ // { "AlwaysQueenProc", AlwaysQueenProc },
+ // { "AnimateDraggingProc", AnimateDraggingProc },
+ // { "AnimateMovingProc", AnimateMovingProc },
+ // { "AutoflagProc", AutoflagProc },
+ // { "AutoflipProc", AutoflipProc },
+ // { "AutobsProc", AutobsProc },
+ // { "AutoraiseProc", AutoraiseProc },
+ // { "AutosaveProc", AutosaveProc },
+ // { "BlindfoldProc", BlindfoldProc },
+ // { "FlashMovesProc", FlashMovesProc },
// { "FlipViewProc", FlipViewProc },
// { "GetMoveListProc", GetMoveListProc },
#if HIGHDRAG
- { "HighlightDraggingProc", HighlightDraggingProc },
+ // { "HighlightDraggingProc", HighlightDraggingProc },
#endif
- { "HighlightLastMoveProc", HighlightLastMoveProc },
- { "IcsAlarmProc", IcsAlarmProc },
- { "MoveSoundProc", MoveSoundProc },
- { "OldSaveStyleProc", OldSaveStyleProc },
- { "PeriodicUpdatesProc", PeriodicUpdatesProc },
- { "PonderNextMoveProc", PonderNextMoveProc },
- { "PopupExitMessageProc", PopupExitMessageProc },
- { "PopupMoveErrorsProc", PopupMoveErrorsProc },
- { "PremoveProc", PremoveProc },
- { "QuietPlayProc", QuietPlayProc },
+ // { "HighlightLastMoveProc", HighlightLastMoveProc },
+ // { "IcsAlarmProc", IcsAlarmProc },
+ // { "MoveSoundProc", MoveSoundProc },
+ // { "OldSaveStyleProc", OldSaveStyleProc },
+ // { "PeriodicUpdatesProc", PeriodicUpdatesProc },
+ // { "PonderNextMoveProc", PonderNextMoveProc },
+ // { "PopupExitMessageProc", PopupExitMessageProc },
+ // { "PopupMoveErrorsProc", PopupMoveErrorsProc },
+ // { "PremoveProc", PremoveProc },
+ // { "QuietPlayProc", QuietPlayProc },
// { "ShowThinkingProc", ShowThinkingProc },
// { "HideThinkingProc", HideThinkingProc },
- { "TestLegalityProc", TestLegalityProc },
- // { "InfoProc", InfoProc },
- // { "ManProc", ManProc },
- // { "HintProc", HintProc },
- // { "BookProc", BookProc },
+ // { "TestLegalityProc", TestLegalityProc },
+ { "SaveSettingsProc", SaveSettingsProc },
+ { "SaveOnExitProc", SaveOnExitProc },
+// { "InfoProc", InfoProc },
+// { "ManProc", ManProc },
+// { "HintProc", HintProc },
+// { "BookProc", BookProc },
{ "AboutGameProc", AboutGameProc },
{ "DebugProc", DebugProc },
{ "NothingProc", NothingProc },
{ "TagsPopDown", (XtActionProc) TagsPopDown },
{ "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
- { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
- { "FileNamePopDown", (XtActionProc) FileNamePopDown },
+ // { "FileNamePopDown", (XtActionProc) FileNamePopDown },
{ "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
// { "HistoryPopDown", (XtActionProc) HistoryPopDown },
{ "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+ { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
{ "ShufflePopDown", (XtActionProc) ShufflePopDown },
{ "EnginePopDown", (XtActionProc) EnginePopDown },
{ "UciPopDown", (XtActionProc) UciPopDown },
{ "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 \
+// 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 \
+// <Btn1Motion>: AnimateUserMove() \n \
+// <Btn3Motion>: HandlePV() \n \
+// <Btn3Up>: UnLoadPV() \n \
+// Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
+// PieceMenuPopup(menuB) \n \
+// Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
+// PieceMenuPopup(menuW) \n \
+// Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
+// PieceMenuPopup(menuW) \n \
+// Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
+// PieceMenuPopup(menuB) \n";
+//
+//char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
+//char blackTranslations[] = "<BtnDown>: BlackClock()\n";
char ICSInputTranslations[] =
"<Key>Return: EnterKeyProc() \n";
String xboardResources[] = {
- "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
+ // "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
"*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
"*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
NULL
}
-/* Arrange to catch delete-window events */
-Atom wm_delete_window;
void
-CatchDeleteWindow(Widget w, String procname)
+BoardToTop()
{
- char buf[MSG_SIZ];
- XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
- snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
- XtAugmentTranslations(w, XtParseTranslationTable(buf));
+ /* this should raise the board to the top */
+ gtk_window_present(GTK_WINDOW(GUI_Window));
+ return;
}
+//---------------------------------------------------------------------------------------------------------
+// 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
+};
+
void
-BoardToTop()
+ParseFont(char *name, int number)
+{ // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
+ switch(number) {
+ case 0: // CLOCK_FONT
+ appData.clockFont = strdup(name);
+ break;
+ case 1: // MESSAGE_FONT
+ appData.font = strdup(name);
+ break;
+ case 2: // COORD_FONT
+ appData.coordFont = strdup(name);
+ break;
+ default:
+ return;
+ }
+}
+
+void
+SetFontDefaults()
+{ // only 2 fonts currently
+ appData.clockFont = CLOCK_FONT_NAME;
+ appData.coordFont = COORD_FONT_NAME;
+ appData.font = DEFAULT_FONT_NAME;
+}
+
+void
+CreateFonts()
+{ // no-op, until we identify the code for this already in XBoard and move it here
+}
+
+void
+ParseColor(int n, char *name)
+{ // in XBoard, just copy the color-name string
+ if(colorVariable[n]) *(char**)colorVariable[n] = strdup(name);
+}
+
+void
+ParseTextAttribs(ColorClass cc, char *s)
+{
+ (&appData.colorShout)[cc] = strdup(s);
+}
+
+void
+ParseBoardSize(void *addr, char *name)
+{
+ appData.boardSize = strdup(name);
+}
+
+void
+LoadAllSounds()
+{ // In XBoard the sound-playing program takes care of obtaining the actual sound
+}
+
+void
+SetCommPortDefaults()
+{ // for now, this is a no-op, as the corresponding option does not exist in XBoard
+}
+
+// [HGM] args: these three cases taken out to stay in front-end
+void
+SaveFontArg(FILE *f, ArgDescriptor *ad)
+{
+ char *name;
+ switch((int)ad->argLoc) {
+ case 0: // CLOCK_FONT
+ name = appData.clockFont;
+ break;
+ case 1: // MESSAGE_FONT
+ name = appData.font;
+ break;
+ case 2: // COORD_FONT
+ name = appData.coordFont;
+ break;
+ default:
+ return;
+ }
+// Do not save fonts for now, as the saved font would be board-size specific
+// and not suitable for a re-start at another board size
+// fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, name);
+}
+
+void
+ExportSounds()
+{ // nothing to do, as the sounds are at all times represented by their text-string names already
+}
+
+void
+SaveAttribsArg(FILE *f, ArgDescriptor *ad)
+{ // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)ad->argLoc]);
+}
+
+void
+SaveColor(FILE *f, ArgDescriptor *ad)
+{ // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
+ if(colorVariable[(int)ad->argLoc])
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)ad->argLoc]);
+}
+
+void
+SaveBoardSize(FILE *f, char *name, void *addr)
+{ // wrapper to shield back-end from BoardSize & sizeInfo
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
+}
+
+void
+ParseCommPortSettings(char *s)
+{ // no such option in XBoard (yet)
+}
+
+extern Widget engineOutputShell;
+extern Widget tagsShell, editTagsShell;
+
+void
+GetActualPlacement(Widget wg, WindowPlacement *wp)
+{
+ Arg args[16];
+ Dimension w, h;
+ Position x, y;
+ int i;
+
+ if(!wg) return;
+
+ i = 0;
+ XtSetArg(args[i], XtNx, &x); i++;
+ XtSetArg(args[i], XtNy, &y); i++;
+ XtSetArg(args[i], XtNwidth, &w); i++;
+ XtSetArg(args[i], XtNheight, &h); i++;
+ XtGetValues(wg, args, i);
+ wp->x = x - 4;
+ wp->y = y - 23;
+ wp->height = h;
+ wp->width = w;
+}
+
+void
+GetWindowCoords()
+{ // wrapper to shield use of window handles from back-end (make addressible by number?)
+ // In XBoard this will have to wait until awareness of window parameters is implemented
+
+ // GetActualPlacement(shellWidget, &wpMain);
+ if(EngineOutputIsUp()) GetActualPlacement(engineOutputShell, &wpEngineOutput); else
+// if(MoveHistoryIsUp()) GetActualPlacement(historyShell, &wpMoveHistory);
+ if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
+ if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
+ if(commentShell) GetActualPlacement(commentShell, &wpComment);
+ else GetActualPlacement(editShell, &wpComment);
+ if(tagsShell) GetActualPlacement(tagsShell, &wpTags);
+ else GetActualPlacement(editTagsShell, &wpTags);
+}
+
+void
+PrintCommPortSettings(FILE *f, char *name)
+{ // This option does not exist in XBoard
+}
+
+int
+MySearchPath(char *installDir, char *name, char *fullname)
+{ // just append installDir and name. Perhaps ExpandPath should be used here?
+ name = ExpandPathName(name);
+ if(name && name[0] == '/') strcpy(fullname, name); else {
+ sprintf(fullname, "%s%c%s", installDir, '/', name);
+ }
+ return 1;
+}
+
+int
+MyGetFullPathName(char *name, char *fullname)
+{ // should use ExpandPath?
+ name = ExpandPathName(name);
+ strcpy(fullname, name);
+ return 1;
+}
+
+void
+EnsureOnScreen(int *x, int *y, int minX, int minY)
{
- /* this should raise the board to the top */
- gtk_window_present(GTK_WINDOW(GUI_Window));
return;
}
+int
+MainWindowUp()
+{ // [HGM] args: allows testing if main window is realized from back-end
+ return xBoardWindow != 0;
+}
+
+void
+PopUpStartupDialog()
+{ // start menu not implemented in XBoard
+}
+char *
+ConvertToLine(int argc, char **argv)
+{
+ static char line[128*1024], buf[1024];
+ int i;
+
+ line[0] = NULLCHAR;
+ for(i=1; i<argc; i++) {
+ if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
+ && argv[i][0] != '{' )
+ sprintf(buf, "{%s} ", argv[i]);
+ else sprintf(buf, "%s ", argv[i]);
+ strcat(line, buf);
+ }
+ line[strlen(line)-1] = NULLCHAR;
+ return line;
+}
+
+//--------------------------------------------------------------------------------------------
+
+#ifdef IDSIZES
+ // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
+#else
+
#define BoardSize int
void InitDrawingSizes(BoardSize boardSize, int flags)
{ // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
CreateAnimVars();
#endif
}
+#endif
void EscapeExpand(char *p, char *q)
{ // [HGM] initstring: routine to shape up string arguments
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;
-#endif
-
setbuf(stdout, NULL);
setbuf(stderr, NULL);
debugFP = stderr;
+ if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
+ printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+ exit(0);
+ }
+
programName = strrchr(argv[0], '/');
if (programName == NULL)
programName = argv[0];
textdomain(PACKAGE);
#endif
- shellWidget =
- XtAppInitialize(&appContext, "XBoard", shellOptions,
- XtNumber(shellOptions),
- &argc, argv, xboardResources, NULL, 0);
-
/* set up GTK */
gtk_init (&argc, &argv);
GUI_Window = GTK_WIDGET (gtk_builder_get_object (builder, "MainWindow"));
if(!GUI_Window) printf("Error: gtk_builder didn't work!\n");
+ GUI_Aspect = GTK_WIDGET (gtk_builder_get_object (builder, "Aspectframe"));
+ if(!GUI_Aspect) printf("Error: gtk_builder didn't work!\n");
+
GUI_History = GTK_WIDGET (gtk_builder_get_object (builder, "MoveHistory"));
if(!GUI_History) printf("Error: gtk_builder didn't work!\n");
+ GUI_GameList = GTK_WIDGET (gtk_builder_get_object (builder, "GameList"));
+ if(!GUI_GameList) printf("Error: gtk_builder didn't work!\n");
+
GUI_Menubar = GTK_WIDGET (gtk_builder_get_object (builder, "MenuBar"));
if(!GUI_Menubar) printf("Error: gtk_builder didn't work!\n");
GUI_Timer = GTK_WIDGET (gtk_builder_get_object (builder, "Timer"));
LIST_MoveHistory = GTK_LIST_STORE (gtk_builder_get_object (builder, "MoveHistoryStore"));
if(!LIST_MoveHistory) printf("Error: gtk_builder didn't work!\n");
+ LIST_GameList = GTK_LIST_STORE (gtk_builder_get_object (builder, "GameListStore"));
+ if(!LIST_GameList) printf("Error: gtk_builder didn't work!\n");
+
+ /* EditTags window */
+ GUI_EditTags = GTK_WIDGET (gtk_builder_get_object (builder, "EditTags"));
+ if(!GUI_EditTags) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_EditTagsTextArea = GTK_WIDGET (gtk_builder_get_object (builder, "EditTagsTextArea"));
+ if(!GUI_EditTagsTextArea) printf("Error: gtk_builder didn't work!\n");
+
gtk_builder_connect_signals (builder, NULL);
/* end parse glade file */
- 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++)
- {
- /* print first column */
- j = fprintf(stderr, " %s%s", shellOptions[i].option,
- (shellOptions[i].argKind == XrmoptionSepArg
- ? " ARG" : ""));
- /* print second column and end line */
- 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";
snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
- XtGetApplicationResources(shellWidget, (XtPointer) &appData,
- clientResources, XtNumber(clientResources),
- NULL, 0);
+// XtGetApplicationResources(shellWidget, (XtPointer) &appData,
+// clientResources, XtNumber(clientResources),
+// NULL, 0);
{ // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
static char buf[MSG_SIZ];
setbuf(debugFP, NULL);
}
- /* [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 !HIGHDRAG
/* This feature does not work; animation needs a rewrite */
#endif
InitBackEnd1();
- xDisplay = XtDisplay(shellWidget);
- xScreen = DefaultScreen(xDisplay);
- wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
-
gameInfo.variant = StringToVariant(appData.variant);
InitPosition(FALSE);
- /* calc board size */
- if (isdigit(appData.boardSize[0]))
- {
- i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
- &lineGap, &clockFontPxlSize, &coordFontPxlSize,
- &fontPxlSize, &smallLayout, &tinyLayout);
- if (i == 0)
- {
- fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
- programName, appData.boardSize);
- exit(2);
- }
- if (i < 7)
- {
- /* Find some defaults; use the nearest known size */
- SizeDefaults *szd, *nearest;
- int distance = 99999;
- nearest = szd = sizeDefaults;
- while (szd->name != NULL)
- {
- if (abs(szd->squareSize - squareSize) < distance)
- {
- nearest = szd;
- distance = abs(szd->squareSize - squareSize);
- if (distance == 0) break;
- }
- szd++;
- };
- if (i < 2) lineGap = nearest->lineGap;
- if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
- if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
- if (i < 5) fontPxlSize = nearest->fontPxlSize;
- if (i < 6) smallLayout = nearest->smallLayout;
- if (i < 7) tinyLayout = nearest->tinyLayout;
- }
- }
- else
- {
- SizeDefaults *szd = sizeDefaults;
- if (*appData.boardSize == NULLCHAR)
- {
- while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize
- || DisplayHeight(xDisplay, xScreen) < szd->minScreenSize)
- {
- szd++;
- }
- if (szd->name == NULL) szd--;
- }
- else
- {
- while (szd->name != NULL
- && StrCaseCmp(szd->name, appData.boardSize) != 0)
- szd++;
- if (szd->name == NULL)
- {
- fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
- programName, appData.boardSize);
- exit(2);
- }
- }
- squareSize = szd->squareSize;
- lineGap = szd->lineGap;
- clockFontPxlSize = szd->clockFontPxlSize;
- coordFontPxlSize = szd->coordFontPxlSize;
- fontPxlSize = szd->fontPxlSize;
- smallLayout = szd->smallLayout;
- tinyLayout = szd->tinyLayout;
- }
- /* end figuring out what size to use */
+
+ squareSize = 40;
+ lineGap = 1;
+ clockFontPxlSize = 20;
+ coordFontPxlSize = 20;
+ fontPxlSize = 20;
+ smallLayout = 16;
+ tinyLayout = 10;
+
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
/*
* Determine what fonts to use.
*/
- appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
- clockFontID = XLoadFont(xDisplay, appData.clockFont);
- clockFontStruct = XQueryFont(xDisplay, clockFontID);
- appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
- coordFontID = XLoadFont(xDisplay, appData.coordFont);
- coordFontStruct = XQueryFont(xDisplay, coordFontID);
- appData.font = FindFont(appData.font, fontPxlSize);
- countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
- countFontStruct = XQueryFont(xDisplay, countFontID);
+// appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
+// clockFontID = XLoadFont(xDisplay, appData.clockFont);
+// clockFontStruct = XQueryFont(xDisplay, clockFontID);
+// appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
+// coordFontID = XLoadFont(xDisplay, appData.coordFont);
+// coordFontStruct = XQueryFont(xDisplay, coordFontID);
+// appData.font = FindFont(appData.font, fontPxlSize);
+// countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
+// countFontStruct = XQueryFont(xDisplay, countFontID);
// appData.font = FindFont(appData.font, fontPxlSize);
- xdb = XtDatabase(xDisplay);
- XrmPutStringResource(&xdb, "*font", appData.font);
+// xdb = XtDatabase(xDisplay);
+// XrmPutStringResource(&xdb, "*font", appData.font);
/*
* Detect if there are not enough colors available and adapt.
*/
- if (DefaultDepth(xDisplay, xScreen) <= 2) {
- appData.monoMode = True;
- }
+// if (DefaultDepth(xDisplay, xScreen) <= 2) {
+// appData.monoMode = True;
+// }
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.lightSquareColor;
vFrom.size = strlen(appData.lightSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.darkSquareColor;
vFrom.size = strlen(appData.darkSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.whitePieceColor;
vFrom.size = strlen(appData.whitePieceColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.blackPieceColor;
vFrom.size = strlen(appData.blackPieceColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.highlightSquareColor;
vFrom.size = strlen(appData.highlightSquareColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (!appData.monoMode) {
vFrom.addr = (caddr_t) appData.premoveHighlightColor;
vFrom.size = strlen(appData.premoveHighlightColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL) {
appData.monoMode = True;
forceMono = True;
if (appData.lowTimeWarning && !appData.monoMode) {
vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
vFrom.size = strlen(appData.lowTimeWarningColor);
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ // XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
if (vTo.addr == NULL)
appData.monoMode = True;
else
lowTimeWarningColor = *(Pixel *) vTo.addr;
}
- if (appData.monoMode && appData.debugMode) {
- fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
- (unsigned long) XWhitePixel(xDisplay, xScreen),
- (unsigned long) XBlackPixel(xDisplay, xScreen));
- }
-
if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
/* TODO hide button bar if requested */
}
- /*
- * gtk set properties of widgets
- */
-
- /* set board size */
- gtk_widget_set_size_request(GTK_WIDGET(GUI_Board),
- boardWidth,boardHeight);
-
- /* end gtk set properties of widgets */
if (appData.titleInWindow)
{
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Show Coords")),TRUE);
if (appData.showThinking)
- gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Show Thinking")),TRUE);
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Hide Thinking")),TRUE);
if (appData.testLegality)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Test Legality")),TRUE);
+ // TODO: add
+ // if (saveSettingsOnExit) {
+ // XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Save Settings on Exit"),
+ // args, 1);
+ // }
+
+
/* end setting check boxes */
/* load square colors */
/* realize window */
gtk_widget_show (GUI_Window);
- /* do resizing to a fixed aspect ratio */
- {
- GtkRequisition w;
- int totalh=boardHeight;
- float ratio;
-
- gtk_widget_size_request(GTK_WIDGET(GUI_Menubar), &w);
- totalh += w.height;
-
- gtk_widget_size_request(GTK_WIDGET(GUI_Timer), &w);
- totalh += w.height;
-
- gtk_widget_size_request(GTK_WIDGET(GUI_Buttonbar), &w);
- totalh += w.height;
-
- ratio = (totalh)/(boardWidth) ;
- GUI_SetAspectRatio(ratio);
- }
-
+ /* recalc boardsize */
CreateGCs();
CreatePieces();
CreatePieceMenus();
if (appData.icsInputBox) ICSInputBoxPopUp();
}
+ #ifdef SIGWINCH
+ signal(SIGWINCH, TermSizeSigHandler);
+ #endif
signal(SIGINT, IntSigHandler);
signal(SIGTERM, IntSigHandler);
if (*appData.cmailGameName != NULLCHAR) {
if (appData.icsActive && oldICSInteractionTitle != NULL) {
DisplayIcsInteractionTitle(oldICSInteractionTitle);
}
+ if (saveSettingsOnExit) SaveSettings(settingsFileName);
unlink(gameCopyFilename);
unlink(gamePasteFilename);
}
+RETSIGTYPE TermSizeSigHandler(int sig)
+{
+ update_ics_width();
+}
+
RETSIGTYPE
IntSigHandler(sig)
int sig;
}
void
+GreyRevert(grey)
+ Boolean grey;
+{
+ Widget w;
+ if (!menuBarWidget) return;
+ w = XtNameToWidget(menuBarWidget, "menuStep.Revert");
+ if (w == NULL) {
+ DisplayError("menuStep.Revert", 0);
+ } else {
+ XtSetSensitive(w, !grey);
+ }
+}
+
+void
SetMenuEnables(enab)
Enables *enab;
{
nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
#else
- fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
- if (nfonts < 1) {
- fprintf(stderr, _("%s: no fonts match pattern %s\n"),
- programName, pattern);
- exit(2);
- }
+// fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
+// if (nfonts < 1) {
+// fprintf(stderr, _("%s: no fonts match pattern %s\n"),
+// programName, pattern);
+// exit(2);
+// }
#endif
best = fonts[0];
#ifdef ENABLE_NLS
if (missing_count > 0)
XFreeStringList(missing_list);
- XFreeFontSet(xDisplay, fntSet);
+ // XFreeFontSet(xDisplay, fntSet);
#else
XFreeFontNames(fonts);
#endif
void CreateGCs()
{
- XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
- | GCBackground | GCFunction | GCPlaneMask;
- XGCValues gc_values;
- GC copyInvertedGC;
-
- gc_values.plane_mask = AllPlanes;
- gc_values.line_width = lineGap;
- gc_values.line_style = LineSolid;
- gc_values.function = GXcopy;
-
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);
- gc_values.background = XWhitePixel(xDisplay, xScreen);
- coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
- XSetFont(xDisplay, coordGC, coordFontID);
-
- if (appData.monoMode) {
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);
- gc_values.background = XBlackPixel(xDisplay, xScreen);
- lightSquareGC = wbPieceGC
- = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);
- gc_values.background = XWhitePixel(xDisplay, xScreen);
- darkSquareGC = bwPieceGC
- = XtGetGC(shellWidget, value_mask, &gc_values);
-
- if (DefaultDepth(xDisplay, xScreen) == 1) {
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
- gc_values.function = GXcopyInverted;
- copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);
- gc_values.function = GXcopy;
- if (XBlackPixel(xDisplay, xScreen) == 1) {
- bwPieceGC = darkSquareGC;
- wbPieceGC = copyInvertedGC;
- } else {
- bwPieceGC = copyInvertedGC;
- wbPieceGC = lightSquareGC;
- }
- }
- } else {
- gc_values.foreground = lightSquareColor;
- gc_values.background = darkSquareColor;
- lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = darkSquareColor;
- gc_values.background = lightSquareColor;
- darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = jailSquareColor;
- gc_values.background = jailSquareColor;
- jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = darkSquareColor;
- wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = lightSquareColor;
- wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = whitePieceColor;
- gc_values.background = jailSquareColor;
- wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = darkSquareColor;
- bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = lightSquareColor;
- blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = blackPieceColor;
- gc_values.background = jailSquareColor;
- bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
- }
+ /* GCs are not needed anymore for GTK just left them in here for the moment, since there is a lot of X-code still around that's wants them*/
+ return;
}
void CreatePieces()
{
- /* order of pieces
- WhitePawn, WhiteKnight, WhiteBishop, WhiteRook, WhiteQueen, WhiteKing,
- BlackPawn, BlackKnight, BlackBishop, BlackRook, BlackQueen, BlackKing,
- */
int i;
+ /* free if used
+ for(i=0;i<MAXPIECES;i++)
+ {
+ if(SVGpieces[i])
+ {
+ g_free(SVGpieces[i]);
+ SVGpieces[i]=NULL;
+ }
+ }
+ */
+
+ /* reload these */
+ SVGLightSquare = load_pixbuf("svg/LightSquare.svg",squareSize);
+ SVGDarkSquare = load_pixbuf("svg/DarkSquare.svg",squareSize);
+ SVGNeutralSquare = load_pixbuf("svg/NeutralSquare.svg",squareSize);
+
+
/* get some defaults going */
for(i=WhitePawn; i<DemotePiece+1; i++)
SVGpieces[i] = load_pixbuf("svg/NeutralSquare.svg",squareSize);
-
SVGpieces[WhitePawn] = load_pixbuf("svg/WhitePawn.svg",squareSize);
SVGpieces[WhiteKnight] = load_pixbuf("svg/WhiteKnight.svg",squareSize);
SVGpieces[WhiteBishop] = load_pixbuf("svg/WhiteBishop.svg",squareSize);
return menuBar;
}
-Widget CreateButtonBar(mi)
- MenuItem *mi;
-{
- int j;
- Widget button, buttonBar;
- Arg args[16];
-
- j = 0;
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
- if (tinyLayout) {
- XtSetArg(args[j], XtNhSpace, 0); j++;
- }
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- XtSetArg(args[j], XtNvSpace, 0); j++;
- buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,
- formWidget, args, j);
-
- while (mi->string != NULL) {
- j = 0;
- if (tinyLayout) {
- XtSetArg(args[j], XtNinternalWidth, 2); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- }
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
- button = XtCreateManagedWidget(mi->string, commandWidgetClass,
- buttonBar, args, j);
- XtAddCallback(button, XtNcallback,
- (XtCallbackProc) MenuBarSelect,
- (caddr_t) mi->proc);
- mi++;
- }
- return buttonBar;
-}
Widget
CreatePieceMenu(name, color)
Cardinal *num_params;
{
String whichMenu;
+
+ if (event->type != ButtonRelease) UnLoadPV(); // [HGM] pv
if (event->type != ButtonPress) return;
if (errorUp) ErrorPopDown();
switch (gameMode) {
case IcsExamining:
whichMenu = params[0];
break;
+ case IcsObserving:
+ if(!appData.icsEngineAnalyze) return;
case IcsPlayingWhite:
case IcsPlayingBlack:
- case EditGame:
+ if(!appData.zippyPlay) goto noZip;
+ case AnalyzeMode:
+ case AnalyzeFile:
case MachinePlaysWhite:
case MachinePlaysBlack:
- if (appData.testLegality &&
+ case TwoMachinesPlay: // [HGM] pv: use for showing PV
+ if (!appData.dropMenu) {
+ LoadPV(event->xbutton.x, event->xbutton.y);
+ return;
+ }
+ if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
+ gameMode == AnalyzeFile || gameMode == IcsObserving) return;
+ case EditGame:
+ noZip:
+ if (!appData.dropMenu || appData.testLegality &&
gameInfo.variant != VariantBughouse &&
gameInfo.variant != VariantCrazyhouse) return;
SetupDropMenu();
DropMenuEvent(piece, pmFromX, pmFromY);
}
-void WhiteClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetWhiteToPlayEvent();
- } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {
- CallFlagEvent();
- }
-}
-
-void BlackClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetBlackToPlayEvent();
- } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {
- CallFlagEvent();
- }
-}
-
-
/*
* If the user selects on a border boundary, return -1; if off the board,
* return -2. Otherwise map the event coordinate to the square.
return 0;
}
-static int damage[BOARD_SIZE][BOARD_SIZE];
+static int damage[BOARD_RANKS][BOARD_FILES];
/*
* event handler for redrawing the board
return;
}
-/*
- * event handler for parsing user moves
- */
-// [HGM] This routine will need quite some reworking. Although the backend still supports the old
-// way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform
-// it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it
-// should be made to use the new way, of calling UserMoveTest early to determine the legality of the
-// move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),
-// and at the end FinishMove() to perform the move after optional promotion popups.
-// For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.
-void HandleUserMove(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- int x, y;
- Boolean saveAnimate;
- static int second = 0, promotionChoice = 0;
- ChessMove moveType;
-
- if (w != boardWidget || errorExitStatus != -1) return;
-
- 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;
- }
-
- if(promotionChoice) { // we are waiting for a click to indicate promotion piece
- if(event->type == ButtonRelease) return; // ignore upclick of click-click destination
- promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
- if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
- if(gameInfo.holdingsWidth &&
- (WhiteOnMove(currentMove)
- ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
- : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
- // click in right holdings, for determining promotion piece
- ChessSquare p = boards[currentMove][y][x];
- if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
- if(p != EmptySquare) {
- FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
- fromX = fromY = -1;
- return;
- }
- }
- DrawPosition(FALSE, boards[currentMove]);
- return;
- }
- if (event->type == ButtonPress) ErrorPopDown();
-
- if (promotionUp) {
- if (event->type == ButtonPress) {
-// XtPopdown(promotionShell);
-// XtDestroyWidget(promotionShell);
- promotionUp = False;
- ClearHighlights();
- fromX = fromY = -1;
- } else {
- return;
- }
- }
-
- /* [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, prepare to drag */
- 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 == ButtonRelease && x == fromX && y == fromY) {
- /* Click on single square in stead of drag-drop */
- 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;
- }
-
- moveType = UserMoveTest(fromX, fromY, x, y, NULLCHAR, event->type == ButtonRelease);
-
- if (moveType == Comment) { // kludge for indicating capture-own on Press
- /* Clicked again on same color piece -- changed his mind */
- /* note that re-clicking same square always hits same color piece */
- 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(moveType == AmbiguousMove) { // kludge to indicate edit-position move
- fromX = fromY = -1;
- ClearHighlights();
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- DrawPosition(FALSE, boards[currentMove]);
- return;
- }
-
- /* Complete move; (x,y) is now different from (fromX, fromY) on both Press and Release */
- 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 (moveType == WhitePromotionKnight || moveType == BlackPromotionKnight ||
- (moveType == WhitePromotionQueen || moveType == BlackPromotionQueen) &&
- appData.alwaysPromoteToQueen) { // promotion, but no choice
- FinishMove(moveType, fromX, fromY, toX, toY, 'q');
- } else
- if (moveType == WhitePromotionQueen || moveType == BlackPromotionQueen ) {
- SetHighlights(fromX, fromY, toX, toY);
- if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
- // [HGM] super: promotion to captured piece selected from holdings
- ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
- promotionChoice = TRUE;
- // kludge follows to temporarily execute move on display, without promoting yet
- boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
- boards[currentMove][toY][toX] = p;
- DrawPosition(FALSE, boards[currentMove]);
- boards[currentMove][fromY][fromX] = p; // take back, but display stays
- boards[currentMove][toY][toX] = q;
- DisplayMessage("Click in holdings to choose piece", "");
- return;
- }
- PromotionPopUp();
- goto skipClearingFrom; // the skipped stuff is done asynchronously by PromotionCallback
- } else
- if(moveType != ImpossibleMove) { // valid move, but no promotion
- FinishMove(moveType, fromX, fromY, toX, toY, NULLCHAR);
- } else { // invalid move; could have set premove
- ClearHighlights();
- }
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
- fromX = fromY = -1;
-skipClearingFrom:
- appData.animate = saveAnimate;
- if (appData.animate || appData.animateDragging) {
- /* Undo animation damage if needed */
- DrawPosition(FALSE, NULL);
- }
-}
-
void AnimateUserMove (Widget w, XEvent * event,
String * params, Cardinal * nParams)
{
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;
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
#if TOPLEVEL
- shell =
- XtCreatePopupShell(name, topLevelShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, topLevelShellWidgetClass,
+// shellWidget, args, j);
#else
- shell =
- XtCreatePopupShell(name, transientShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, transientShellWidgetClass,
+// shellWidget, args, j);
#endif
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, shell,
commentH = pw_height + (lines - 1) * ew_height;
commentW = bw_width - 16;
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
#ifdef NOTDEF
/* This code seems to tickle an X bug if it is executed too soon
after xboard starts up. The coordinates get transformed as if
the main window was positioned at (0, 0).
*/
- XtTranslateCoords(shellWidget,
- (bw_width - commentW) / 2, 0 - commentH / 2,
- &commentX, &commentY);
+// XtTranslateCoords(shellWidget,
+// (bw_width - commentW) / 2, 0 - commentH / 2,
+// &commentX, &commentY);
#else /*!NOTDEF*/
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
- RootWindowOfScreen(XtScreen(shellWidget)),
- (bw_width - commentW) / 2, 0 - commentH / 2,
- &xx, &yy, &junk);
+// XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
+// RootWindowOfScreen(XtScreen(shellWidget)),
+// (bw_width - commentW) / 2, 0 - commentH / 2,
+// &xx, &yy, &junk);
commentX = xx;
commentY = yy;
#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++;
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
#if TOPLEVEL
- shell =
- XtCreatePopupShell(name, topLevelShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, topLevelShellWidgetClass,
+// shellWidget, args, j);
#else
- shell =
- XtCreatePopupShell(name, transientShellWidgetClass,
- shellWidget, args, j);
+// shell =
+// XtCreatePopupShell(name, transientShellWidgetClass,
+// shellWidget, args, j);
#endif
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, shell,
h = pw_height + (lines - 1) * ew_height;
w = bw_width - 16;
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
#ifdef NOTDEF
/* This code seems to tickle an X bug if it is executed too soon
after xboard starts up. The coordinates get transformed as if
the main window was positioned at (0, 0).
*/
- XtTranslateCoords(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);
+// XtTranslateCoords(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);
#else /*!NOTDEF*/
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
- RootWindowOfScreen(XtScreen(shellWidget)),
- (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);
+// XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
+// RootWindowOfScreen(XtScreen(shellWidget)),
+// (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);
#endif /*!NOTDEF*/
x = xx;
y = yy;
editShell =
CommentCreate(title, text, True, EditCommentCallback, 4);
XtRealizeWidget(editShell);
- CatchDeleteWindow(editShell, "EditCommentPopDown");
+ // CatchDeleteWindow(editShell, "EditCommentPopDown");
} else {
edit = XtNameToWidget(editShell, "*form.text");
j = 0;
edit = XtNameToWidget(ICSInputShell, "*form.text");
XtOverrideTranslations(edit, tr);
XtRealizeWidget(ICSInputShell);
- CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
+ // CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
} else {
edit = XtNameToWidget(ICSInputShell, "*form.text");
commentShell =
CommentCreate(title, text, False, CommentCallback, 4);
XtRealizeWidget(commentShell);
- CatchDeleteWindow(commentShell, "CommentPopDown");
+ // CatchDeleteWindow(commentShell, "CommentPopDown");
} else {
edit = XtNameToWidget(commentShell, "*form.text");
j = 0;
}
XtPopup(commentShell, XtGrabNone);
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
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;
XtSetArg(args[j], XtNheight, &commentH); j++;
XtGetValues(commentShell, args, j);
XtPopdown(commentShell);
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
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);
-}
-
-void FileNamePopDown()
-{
- if (!filenameUp) return;
- XtPopdown(fileNameShell);
- XtDestroyWidget(fileNameShell);
- filenameUp = False;
- ModeHighlight();
-}
-
-void FileNameCallback(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
-{
- String name;
- Arg args[16];
-
- XtSetArg(args[0], XtNlabel, &name);
- XtGetValues(w, args, 1);
-
- if (strcmp(name, _("cancel")) == 0) {
- FileNamePopDown();
- return;
- }
-
- FileNameAction(w, NULL, NULL, NULL);
-}
-
-void FileNameAction(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- String name;
- FILE *f;
- char *p, *fullname;
- int index;
-
- name = XawDialogGetValueString(w = XtParent(w));
-
- if ((name != NULL) && (*name != NULLCHAR)) {
- strcpy(buf, name);
- XtPopdown(w = XtParent(XtParent(w)));
- XtDestroyWidget(w);
- filenameUp = False;
-
- p = strrchr(buf, ' ');
- if (p == NULL) {
- index = 0;
- } else {
- *p++ = NULLCHAR;
- index = atoi(p);
- }
- fullname = ExpandPathName(buf);
- if (!fullname) {
- ErrorPopUp(_("Error"), _("Can't open file"), FALSE);
- }
- else {
- f = fopen(fullname, fileOpenMode);
- if (f == NULL) {
- DisplayError(_("Failed to open file"), errno);
- } else {
- (void) (*fileProc)(f, index, buf);
- }
- }
- ModeHighlight();
- return;
- }
-
- XtPopdown(w = XtParent(XtParent(w)));
- XtDestroyWidget(w);
- filenameUp = False;
- ModeHighlight();
-}
-
void PromotionPopUp()
{
Arg args[16];
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
- promotionShell =
- XtCreatePopupShell("Promotion", transientShellWidgetClass,
- shellWidget, args, j);
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
- layoutArgs, XtNumber(layoutArgs));
-
+// promotionShell =
+// XtCreatePopupShell("Promotion", transientShellWidgetClass,
+// shellWidget, args, j);
+// layout =
+// XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
+// layoutArgs, XtNumber(layoutArgs));
+//
j = 0;
XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
XtSetArg(args[j], XtNborderWidth, 0); j++;
(XtPointer) dialog);
XtRealizeWidget(promotionShell);
- CatchDeleteWindow(promotionShell, "PromotionPopDown");
+ // CatchDeleteWindow(promotionShell, "PromotionPopDown");
j = 0;
XtSetArg(args[j], XtNwidth, &pw_width); j++;
promoChar = ToLower(name[0]);
}
- FinishMove(NormalMove, fromX, fromY, toX, toY, promoChar);
+ UserMoveEvent(fromX, fromY, toX, toY, promoChar);
if (!appData.highlightLastMove || gotPremove) ClearHighlights();
if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
}
}
- wname = ModeToWidgetName(oldmode);
- if(wname)
- gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, wname)),True);
+ // probably not needed anymore
+// wname = ModeToWidgetName(oldmode);
+// if(wname)
+// gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, wname)),True);
oldmode = gameMode;
else if (!ListEmpty(&gameList)
&& ((ListGame *) gameList.tailPred)->number > 1)
{
+ /* we need an answer which game to load, so let's make it modal for a while*/
+ gtk_window_set_modal(GTK_WINDOW(GUI_GameList) , TRUE);
GameListPopUp(f, title);
+ gtk_window_set_modal(GTK_WINDOW(GUI_GameList) , FALSE);
+
return TRUE;
};
return LoadGame(f, gameNumber, title, FALSE);
}
-
-void LoadNextPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(1);
-}
-
-void LoadPrevPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(-1);
-}
-
-void ReloadPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(0);
-}
-
-void LoadPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
- Reset(FALSE, TRUE);
- }
- FileNamePopUp(_("Load position file name?"), "", LoadPosition, "rb");
-}
-
-void SaveGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- FileNamePopUp(_("Save game file name?"),
- DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),
- SaveGame, "a");
-}
-
-void SavePositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- FileNamePopUp(_("Save position file name?"),
- DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),
- SavePosition, "a");
-}
-
void ReloadCmailMsgProc(w, event, prms, nprms)
Widget w;
XEvent *event;
}
/* 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){
- /* 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);
-
- *value_return=selection_tmp;
- *length_return=strlen(selection_tmp);
- *type_return=XA_STRING;
- *format_return = 8; /* bits per byte */
- return True;
- } else {
- return False;
- }
+// 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);
+//
+// *value_return=selection_tmp;
+// *length_return=strlen(selection_tmp);
+// *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;
+// }
}
/* note: when called from menu all parameters are NULL, so no clue what the
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,
- /* (XtSelectionCallbackProc) */ PastePositionCB,
- NULL, /* client_data passed to PastePositionCB */
-
- /* better to use the time field from the event that triggered the
- * call to this function, but that isn't trivial to get
- */
- CurrentTime
- );
+// XtGetSelectionValue(menuBarWidget,
+// appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+// /* (XtSelectionCallbackProc) */ PastePositionCB,
+// NULL, /* client_data passed to PastePositionCB */
+//
+// /* better to use the time field from the event that triggered the
+// * call to this function, but that isn't trivial to get
+// */
+// CurrentTime
+// );
return;
}
{
char *selection_tmp;
- if (*target == XA_STRING){
- FILE* f = fopen(gameCopyFilename, "r");
- long len;
- size_t count;
- if (f == NULL) return False;
- fseek(f, 0, 2);
- len = ftell(f);
- rewind(f);
- selection_tmp = XtMalloc(len + 1);
- count = fread(selection_tmp, 1, len, f);
- if (len != count) {
- XtFree(selection_tmp);
- return False;
- }
- selection_tmp[len] = NULLCHAR;
- *value_return = selection_tmp;
- *length_return = len;
- *type_return = XA_STRING;
- *format_return = 8; /* bits per byte */
- return True;
- } else {
- return False;
- }
+// if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
+// FILE* f = fopen(gameCopyFilename, "r");
+// long len;
+// size_t count;
+// if (f == NULL) return False;
+// fseek(f, 0, 2);
+// len = ftell(f);
+// rewind(f);
+// selection_tmp = XtMalloc(len + 1);
+// count = fread(selection_tmp, 1, len, f);
+// if (len != count) {
+// XtFree(selection_tmp);
+// return False;
+// }
+// selection_tmp[len] = NULLCHAR;
+// *value_return = selection_tmp;
+// *length_return = len;
+// *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;
+// }
}
/* note: when called from menu all parameters are NULL, so no clue what the
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,
- /* (XtSelectionCallbackProc) */ PasteGameCB,
- NULL, /* client_data passed to PasteGameCB */
-
- /* better to use the time field from the event that triggered the
- * call to this function, but that isn't trivial to get
- */
- CurrentTime
- );
- return;
-}
-
-
-void AutoSaveGame()
-{
- SaveGameProc(NULL, NULL, NULL, NULL);
+// XtGetSelectionValue(menuBarWidget,
+// appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+// /* (XtSelectionCallbackProc) */ PasteGameCB,
+// NULL, /* client_data passed to PasteGameCB */
+//
+// /* better to use the time field from the event that triggered the
+// * call to this function, but that isn't trivial to get
+// */
+// CurrentTime
+// );
+// return;
}
-void AnalyzeModeProc(w, event, prms, nprms)
+void SaveOnExitProc(w, event, prms, nprms)
Widget w;
XEvent *event;
String *prms;
Cardinal *nprms;
{
- char buf[MSG_SIZ];
-
- if (!first.analysisSupport) {
- snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
- DisplayError(buf, 0);
- return;
- }
- /* [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"));
- DisplayError(buf, 0);
- /* secure check */
- if (appData.icsEngineAnalyze) {
- if (appData.debugMode)
- fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
- ExitAnalyzeMode();
- ModeHighlight();
- }
- return;
- }
- /* if enable, use want disable icsEngineAnalyze */
- if (appData.icsEngineAnalyze) {
- ExitAnalyzeMode();
- ModeHighlight();
- return;
- }
- appData.icsEngineAnalyze = TRUE;
- if (appData.debugMode)
- fprintf(debugFP, _("ICS engine analyze starting... \n"));
- }
- if (!appData.showThinking)
- ShowThinkingProc(NULL,NULL);
+ Arg args[16];
- AnalyzeModeEvent();
-}
+ saveSettingsOnExit = !saveSettingsOnExit;
-void AnalyzeFileProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (!first.analysisSupport) {
- char buf[MSG_SIZ];
- snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
- DisplayError(buf, 0);
- return;
+ if (saveSettingsOnExit) {
+ XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ } else {
+ XtSetArg(args[0], XtNleftBitmap, None);
}
- Reset(FALSE, TRUE);
-
- if (!appData.showThinking)
- ShowThinkingProc(NULL,NULL);
-
- AnalyzeFileEvent();
- FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
- AnalysisPeriodicEvent(1);
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Save Settings on Exit"),
+ args, 1);
}
-
-void EditGameProc(w, event, prms, nprms)
+void SaveSettingsProc(w, event, prms, nprms)
Widget w;
XEvent *event;
String *prms;
Cardinal *nprms;
{
- EditGameEvent();
+ SaveSettings(settingsFileName);
}
-void EditPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- EditPositionEvent();
-}
-void TrainingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
+void AutoSaveGame()
{
- TrainingEvent();
+ SaveGameProc(NULL, NULL);
+ return;
}
+
void EditCommentProc(w, event, prms, nprms)
Widget w;
XEvent *event;
ICSInputSendText();
}
-void AlwaysQueenProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;
-
- if (appData.alwaysPromoteToQueen) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
- args, 1);
-}
-
-void AnimateDraggingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.animateDragging = !appData.animateDragging;
-
- if (appData.animateDragging) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- CreateAnimVars();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Dragging"),
- args, 1);
-}
-
-void AnimateMovingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.animate = !appData.animate;
-
- if (appData.animate) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- CreateAnimVars();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
- args, 1);
-}
-
-void AutocommProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoComment = !appData.autoComment;
-
- if (appData.autoComment) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
- args, 1);
-}
-
-
-void AutoflagProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoCallFlag = !appData.autoCallFlag;
-
- if (appData.autoCallFlag) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
- args, 1);
-}
-
-void AutoflipProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoFlipView = !appData.autoFlipView;
-
- if (appData.autoFlipView) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),
- args, 1);
-}
-
-void AutobsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoObserve = !appData.autoObserve;
-
- if (appData.autoObserve) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
- args, 1);
-}
-
-void AutoraiseProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoRaiseBoard = !appData.autoRaiseBoard;
-
- if (appData.autoRaiseBoard) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Raise Board"),
- args, 1);
-}
-
-void AutosaveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoSaveGames = !appData.autoSaveGames;
-
- if (appData.autoSaveGames) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
-}
-
-void BlindfoldProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.blindfold = !appData.blindfold;
-
- if (appData.blindfold) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Blindfold"),
- args, 1);
-
- DrawPosition(True, NULL);
-}
-
-void TestLegalityProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.testLegality = !appData.testLegality;
-
- if (appData.testLegality) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Test Legality"),
- args, 1);
-}
-
-
-void FlashMovesProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- if (appData.flashCount == 0) {
- appData.flashCount = 3;
- } else {
- appData.flashCount = -appData.flashCount;
- }
-
- if (appData.flashCount > 0) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flash Moves"),
- args, 1);
-}
-
-#if HIGHDRAG
-void HighlightDraggingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.highlightDragging = !appData.highlightDragging;
-
- if (appData.highlightDragging) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Dragging"), args, 1);
-}
-#endif
-
-void HighlightLastMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.highlightLastMove = !appData.highlightLastMove;
-
- if (appData.highlightLastMove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Last Move"), args, 1);
-}
-
-void IcsAlarmProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.icsAlarm = !appData.icsAlarm;
-
- if (appData.icsAlarm) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.ICS Alarm"), args, 1);
-}
-
-void MoveSoundProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.ringBellAfterMoves = !appData.ringBellAfterMoves;
-
- if (appData.ringBellAfterMoves) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
- args, 1);
-}
-
-
-void OldSaveStyleProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.oldSaveStyle = !appData.oldSaveStyle;
-
- if (appData.oldSaveStyle) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Old Save Style"),
- args, 1);
-}
-
-void PeriodicUpdatesProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- PeriodicUpdatesEvent(!appData.periodicUpdates);
-
- if (appData.periodicUpdates) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Periodic Updates"),
- args, 1);
-}
-
-void PonderNextMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- PonderNextMoveEvent(!appData.ponderNextMove);
-
- if (appData.ponderNextMove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Ponder Next Move"),
- args, 1);
-}
-
-void PopupExitMessageProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.popupExitMessage = !appData.popupExitMessage;
-
- if (appData.popupExitMessage) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Popup Exit Message"), args, 1);
-}
-
-void PopupMoveErrorsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.popupMoveErrors = !appData.popupMoveErrors;
-
- if (appData.popupMoveErrors) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Popup Move Errors"),
- args, 1);
-}
-
-void PremoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.premove = !appData.premove;
-
- if (appData.premove) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Premove"), args, 1);
-}
-
-void QuietPlayProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.quietPlay = !appData.quietPlay;
-
- if (appData.quietPlay) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Quiet Play"),
- args, 1);
-}
void DebugProc(w, event, prms, nprms)
Widget w;
{
Arg args[16];
- fromX = fromY = -1;
- XtSetArg(args[0], XtNiconic, True);
- XtSetValues(shellWidget, args, 1);
+// fromX = fromY = -1;
+// XtSetArg(args[0], XtNiconic, True);
+// XtSetValues(shellWidget, args, 1);
}
void DisplayMessage(message, extMessage)
Window root, parent, *children;
unsigned int nchildren;
int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
- for (;;) {
- if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
- if (!XQueryTree(xDisplay, win, &root, &parent,
- &children, &nchildren)) break;
- if (children) XFree((void *)children);
- if (parent == root || parent == 0) break;
- win = parent;
- }
+// for (;;) {
+// if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
+// if (!XQueryTree(xDisplay, win, &root, &parent,
+// &children, &nchildren)) break;
+// if (children) XFree((void *)children);
+// if (parent == root || parent == 0) break;
+// win = parent;
+// }
XSetErrorHandler(oldHandler);
}
if (oldICSInteractionTitle == NULL) {
i = 0;
XtSetArg(args[i], XtNresizable, True); i++;
XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
- askQuestionShell = popup =
- XtCreatePopupShell(title, transientShellWidgetClass,
- shellWidget, args, i);
-
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,
- layoutArgs, XtNumber(layoutArgs));
-
+// askQuestionShell = popup =
+// XtCreatePopupShell(title, transientShellWidgetClass,
+// shellWidget, args, i);
+//
+// layout =
+// XtCreateManagedWidget(layoutName, formWidgetClass, popup,
+// layoutArgs, XtNumber(layoutArgs));
+//
i = 0;
XtSetArg(args[i], XtNlabel, question); i++;
XtSetArg(args[i], XtNvalue, ""); i++;
(XtPointer) dialog);
XtRealizeWidget(popup);
- CatchDeleteWindow(popup, "AskQuestionPopDown");
-
- 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);
+ // CatchDeleteWindow(popup, "AskQuestionPopDown");
- XtPopup(popup, XtGrabExclusive);
- askQuestionUp = True;
-
- edit = XtNameToWidget(dialog, "*value");
- XtSetKeyboardFocus(popup, edit);
+// 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);
+// askQuestionUp = True;
+//
+// edit = XtNameToWidget(dialog, "*value");
+// XtSetKeyboardFocus(popup, edit);
}
strcpy(buf, cmdLine);
p = buf;
for (;;) {
+ while(*p == ' ') p++;
argv[i++] = p;
- p = strchr(p, ' ');
+ if(*p == '"' || *p == '\'')
+ p = strchr(++argv[i-1], *p);
+ else p = strchr(p, ' ');
if (p == NULL) break;
*p++ = NULLCHAR;
}
//
/* TODO: will this work on windows?*/
- printf("DEBUG: fd=%d %d\n",is->fd,is);
channel = g_io_channel_unix_new(is->fd);
g_io_channel_set_close_on_unref (channel, TRUE);
int count;
int *outError;
{
+ static int line = 0;
ChildProc *cp = (ChildProc *) pr;
int outCount;
if (pr == NoProc)
- outCount = fwrite(message, 1, count, stdout);
+ {
+ if (appData.noJoin || !appData.useInternalWrap)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ int width = get_term_width();
+ int len = wrap(NULL, message, count, width, &line);
+ char *msg = malloc(len);
+ int dbgchk;
+
+ if (!msg)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ dbgchk = wrap(msg, message, count, width, &line);
+ if (dbgchk != len && appData.debugMode)
+ fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
+ outCount = fwrite(msg, 1, dbgchk, stdout);
+ free(msg);
+ }
+ }
+ }
else
outCount = write(cp->fdTo, message, count);
return;
/* Need a bitmap just to get a GC with right depth */
- buf = XCreatePixmap(xDisplay, xBoardWindow,
- 8, 8, 1);
+// buf = XCreatePixmap(xDisplay, xBoardWindow,
+// 8, 8, 1);
values.foreground = 1;
values.background = 0;
/* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, buf,
- GCForeground | GCBackground, &values);
- XFreePixmap(xDisplay, buf);
-
- buf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, pieceDepth);
- values.foreground = XBlackPixel(xDisplay, xScreen);
- values.background = XWhitePixel(xDisplay, xScreen);
- bufGC = XCreateGC(xDisplay, buf,
- GCForeground | GCBackground, &values);
-
+// maskGC = XCreateGC(xDisplay, buf,
+// GCForeground | GCBackground, &values);
+// XFreePixmap(xDisplay, buf);
+//
+// buf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, pieceDepth);
+// values.foreground = XBlackPixel(xDisplay, xScreen);
+// values.background = XWhitePixel(xDisplay, xScreen);
+// bufGC = XCreateGC(xDisplay, buf,
+// GCForeground | GCBackground, &values);
+//
for (piece = WhitePawn; piece <= BlackKing; piece++) {
/* Begin with empty mask */
- if(!xpmDone) // [HGM] pieces: keep using existing
- xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, 1);
- XSetFunction(xDisplay, maskGC, GXclear);
- XFillRectangle(xDisplay, xpmMask[piece], maskGC,
- 0, 0, squareSize, squareSize);
-
+// if(!xpmDone) // [HGM] pieces: keep using existing
+// xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, 1);
+// XSetFunction(xDisplay, maskGC, GXclear);
+// XFillRectangle(xDisplay, xpmMask[piece], maskGC,
+// 0, 0, squareSize, squareSize);
+//
/* Take a copy of the piece */
if (White(piece))
kind = 0;
else
kind = 2;
- XSetFunction(xDisplay, bufGC, GXcopy);
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
- buf, bufGC,
- 0, 0, squareSize, squareSize, 0, 0);
+// XSetFunction(xDisplay, bufGC, GXcopy);
+// XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
+// buf, bufGC,
+// 0, 0, squareSize, squareSize, 0, 0);
/* XOR the background (light) over the piece */
- XSetFunction(xDisplay, bufGC, GXxor);
- if (useImageSqs)
- XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
- 0, 0, squareSize, squareSize, 0, 0);
- else {
- XSetForeground(xDisplay, bufGC, lightSquareColor);
- XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
- }
+// XSetFunction(xDisplay, bufGC, GXxor);
+// if (useImageSqs)
+// XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
+// 0, 0, squareSize, squareSize, 0, 0);
+// else {
+// XSetForeground(xDisplay, bufGC, lightSquareColor);
+// XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
+// }
/* We now have an inverted piece image with the background
erased. Construct mask by just selecting all the non-zero
pixels - no need to reconstruct the original image. */
- XSetFunction(xDisplay, maskGC, GXor);
+ // XSetFunction(xDisplay, maskGC, GXor);
plane = 1;
/* Might be quicker to download an XImage and create bitmap
data from it rather than this N copies per piece, but it
only takes a fraction of a second and there is a much
longer delay for loading the pieces. */
- for (n = 0; n < pieceDepth; n ++) {
- XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
- 0, 0, squareSize, squareSize,
- 0, 0, plane);
- plane = plane << 1;
- }
+// for (n = 0; n < pieceDepth; n ++) {
+// XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
+// 0, 0, squareSize, squareSize,
+// 0, 0, plane);
+// plane = plane << 1;
+// }
}
/* Clean up */
- XFreePixmap(xDisplay, buf);
- XFreeGC(xDisplay, bufGC);
- XFreeGC(xDisplay, maskGC);
+// XFreePixmap(xDisplay, buf);
+// XFreeGC(xDisplay, bufGC);
+// XFreeGC(xDisplay, maskGC);
}
static void
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);
damage[player.startBoardY][player.startBoardX] = TRUE;
}
-void
-SetProgramStats( FrontEndProgramStats * stats )
+#include <sys/ioctl.h>
+int get_term_width()
+{
+ int fd, default_width;
+
+ fd = STDIN_FILENO;
+ default_width = 79; // this is FICS default anyway...
+
+#if !defined(TIOCGWINSZ) && defined(TIOCGSIZE)
+ struct ttysize win;
+ if (!ioctl(fd, TIOCGSIZE, &win))
+ default_width = win.ts_cols;
+#elif defined(TIOCGWINSZ)
+ struct winsize win;
+ if (!ioctl(fd, TIOCGWINSZ, &win))
+ default_width = win.ws_col;
+#endif
+ return default_width;
+}
+
+void update_ics_width()
+{
+ static int old_width = 0;
+ int new_width = get_term_width();
+
+ if (old_width != new_width)
+ ics_printf("set width %d\n", new_width);
+ old_width = new_width;
+}
+
+void NotifyFrontendLogin()
{
- // [HR] TODO
- // [HGM] done, but perhaps backend should call this directly?
- EngineOutputUpdate( stats );
+ update_ics_width();
}