X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=xboard.c;h=343e0e636a03852e455237af5ec76fa62f3d79ec;hb=4626ea070c35a9c59ae231280f96e215dfc9205f;hp=096e3cb4f09d89129a7dd40cf79f629beeb050a5;hpb=91d173f87bb4ada0141b435a5c4c7601bc2863b7;p=xboard.git diff --git a/xboard.c b/xboard.c index 096e3cb..343e0e6 100644 --- a/xboard.c +++ b/xboard.c @@ -49,6 +49,8 @@ *------------------------------------------------------------------------ ** See the file ChangeLog for a revision history. */ +#define HIGHDRAG 1 + #include "config.h" #include @@ -144,6 +146,7 @@ extern char *getenv(); #include #include #include +#include #if USE_XAW3D #include #include @@ -205,9 +208,9 @@ extern char *getenv(); // must be moved to xengineoutput.h void EngineOutputProc P((Widget w, XEvent *event, - String *prms, Cardinal *nprms)); - -void EngineOutputPopDown(); + String *prms, Cardinal *nprms)); +void EvalGraphProc P((Widget w, XEvent *event, + String *prms, Cardinal *nprms)); #ifdef __EMX__ @@ -245,6 +248,7 @@ typedef struct { int main P((int argc, char **argv)); RETSIGTYPE CmailSigHandler P((int sig)); RETSIGTYPE IntSigHandler P((int sig)); +RETSIGTYPE TermSizeSigHandler P((int sig)); void CreateGCs P((void)); void CreateXIMPieces P((void)); void CreateXPMPieces P((void)); @@ -258,29 +262,21 @@ static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk)); 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 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)); @@ -288,70 +284,22 @@ void EditCommentPopDown P((void)); 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 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)); @@ -364,12 +312,9 @@ void ErrorPopUp P((char *title, char *text, int modal)); void ErrorPopDown P((void)); static char *ExpandPathName P((char *path)); static void CreateAnimVars P((void)); -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)); @@ -384,14 +329,16 @@ void TimeControlPopDown P(()); 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; @@ -406,11 +353,16 @@ GC lightSquareGC, darkSquareGC, jailSquareGC, wdPieceGC, wlPieceGC, 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, 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; @@ -423,7 +375,11 @@ char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time i Position commentX = -1, commentY = -1; Dimension commentW, commentH; +typedef unsigned int BoardSize; +BoardSize boardSize; +Boolean chessProgram; +int minX, minY; // [HGM] placement: volatile limits on upper-left corner int squareSize, smallLayout = 0, tinyLayout = 0, marginW, marginH, // [HGM] for run-time resizing fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False, @@ -434,6 +390,22 @@ Pixel timerForegroundPixel, timerBackgroundPixel; Pixel buttonForegroundPixel, buttonBackgroundPixel; char *chessDir, *programName, *programVersion, *gameCopyFilename, *gamePasteFilename; +Boolean alwaysOnTop = False; +Boolean saveSettingsOnExit; +char *settingsFileName; +char *icsTextMenuString; +char *icsNames; +char *firstChessProgramNames; +char *secondChessProgramNames; + +WindowPlacement wpMain; +WindowPlacement wpConsole; +WindowPlacement wpComment; +WindowPlacement wpMoveHistory; +WindowPlacement wpEvalGraph; +WindowPlacement wpEngineOutput; +WindowPlacement wpGameList; +WindowPlacement wpTags; #define SOLID 0 #define OUTLINE 1 @@ -639,24 +611,24 @@ Enables userThinkingEnables[] = { 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}, + // {"----", 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_("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} }; @@ -664,19 +636,19 @@ MenuItem modeMenu[] = { // {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} @@ -691,33 +663,37 @@ MenuItem optionsMenu[] = { {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} }; @@ -791,999 +767,17 @@ Arg boardArgs[] = { }; 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 }, @@ -1791,7 +785,7 @@ XtActionsRec boardActions[] = { // { "BlackClock", BlackClock }, { "Iconify", Iconify }, { "LoadSelectedProc", LoadSelectedProc }, - { "LoadPositionProc", LoadPositionProc }, + // { "LoadPositionProc", LoadPositionProc }, // { "LoadNextPositionProc", LoadNextPositionProc }, // { "LoadPrevPositionProc", LoadPrevPositionProc }, // { "ReloadPositionProc", ReloadPositionProc }, @@ -1799,25 +793,26 @@ XtActionsRec boardActions[] = { { "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 }, @@ -1841,38 +836,40 @@ XtActionsRec boardActions[] = { // { "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 }, @@ -1881,27 +878,71 @@ XtActionsRec boardActions[] = { { "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[] = +// ":R: ResignProc() \n \ +// :r: ResetProc() \n \ +// :g: LoadGameProc() \n \ +// :N: LoadNextGameProc() \n \ +// :P: LoadPrevGameProc() \n \ +// :Q: QuitProc() \n \ +// :F: ToEndProc() \n \ +// :f: ForwardProc() \n \ +// :B: ToStartProc() \n \ +// :b: BackwardProc() \n \ +// :p: PauseProc() \n \ +// :d: DrawProc() \n \ +// :t: CallFlagProc() \n \ +// :i: Iconify() \n \ +// :c: Iconify() \n \ +// :v: FlipViewProc() \n \ +// Control_L: BackwardProc() \n \ +// Control_L: ForwardProc() \n \ +// Control_R: BackwardProc() \n \ +// Control_R: ForwardProc() \n \ +// Shift1: AskQuestionProc(\"Direct command\",\ +// \"Send to chess program:\",,1) \n \ +// Shift2: AskQuestionProc(\"Direct command\",\ +// \"Send to second chess program:\",,2) \n"; +// +//char boardTranslations[] = +// ": HandleUserMove() \n \ +// : HandleUserMove() \n \ +// : AnimateUserMove() \n \ +// : HandlePV() \n \ +// : UnLoadPV() \n \ +// Shift: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\ +// PieceMenuPopup(menuB) \n \ +// Any: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \ +// PieceMenuPopup(menuW) \n \ +// Shift: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\ +// PieceMenuPopup(menuW) \n \ +// Any: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \ +// PieceMenuPopup(menuB) \n"; +// +//char whiteTranslations[] = ": WhiteClock()\n"; +//char blackTranslations[] = ": BlackClock()\n"; char ICSInputTranslations[] = "Return: EnterKeyProc() \n"; String xboardResources[] = { - "*fileName*value.translations: #override\\n Return: FileNameAction()", + // "*fileName*value.translations: #override\\n Return: FileNameAction()", "*question*value.translations: #override\\n Return: AskQuestionReplyAction()", "*errorpopup*translations: #override\\n Return: ErrorPopDown()", NULL @@ -1983,25 +1024,271 @@ parse_cpair(cc, str) } -/* 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), "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= 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]; @@ -2178,11 +1434,6 @@ main(argc, argv) textdomain(PACKAGE); #endif - shellWidget = - XtAppInitialize(&appContext, "XBoard", shellOptions, - XtNumber(shellOptions), - &argc, argv, xboardResources, NULL, 0); - /* set up GTK */ gtk_init (&argc, &argv); @@ -2194,30 +1445,58 @@ main(argc, argv) /* test if everything worked ok */ GUI_Window = GTK_WIDGET (gtk_builder_get_object (builder, "MainWindow")); - if(!GUI_Window) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Window) printf("Error: gtk_builder didn't work (MainWindow)!\n"); - GUI_History = GTK_WIDGET (gtk_builder_get_object (builder, "MoveHistory")); - if(!GUI_History) 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 (Aspectframe)!\n"); GUI_Menubar = GTK_WIDGET (gtk_builder_get_object (builder, "MenuBar")); - if(!GUI_Menubar) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Menubar) printf("Error: gtk_builder didn't work (MenuBar)!\n"); GUI_Timer = GTK_WIDGET (gtk_builder_get_object (builder, "Timer")); - if(!GUI_Timer) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Timer) printf("Error: gtk_builder didn't work (Timer)!\n"); GUI_Buttonbar = GTK_WIDGET (gtk_builder_get_object (builder, "ButtonBar")); - if(!GUI_Buttonbar) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Buttonbar) printf("Error: gtk_builder didn't work (ButtonBar)!\n"); GUI_Board = GTK_WIDGET (gtk_builder_get_object (builder, "Board")); - if(!GUI_Board) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Board) printf("Error: gtk_builder didn't work (Board)!\n"); GUI_Whiteclock = GTK_WIDGET (gtk_builder_get_object (builder, "WhiteClock")); - if(!GUI_Whiteclock) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Whiteclock) printf("Error: gtk_builder didn't work (WhiteClock)!\n"); GUI_Blackclock = GTK_WIDGET (gtk_builder_get_object (builder, "BlackClock")); - if(!GUI_Blackclock) printf("Error: gtk_builder didn't work!\n"); + if(!GUI_Blackclock) printf("Error: gtk_builder didn't work (BlackClock)!\n"); + /* GTK lists stores*/ LIST_MoveHistory = GTK_LIST_STORE (gtk_builder_get_object (builder, "MoveHistoryStore")); - if(!LIST_MoveHistory) printf("Error: gtk_builder didn't work!\n"); + if(!LIST_MoveHistory) printf("Error: gtk_builder didn't work (MoveHistoryStore)!\n"); + + LIST_GameList = GTK_LIST_STORE (gtk_builder_get_object (builder, "GameListStore")); + if(!LIST_GameList) printf("Error: gtk_builder didn't work (GameListStore)!\n"); + + /* EditTags window */ + GUI_EditTags = GTK_WIDGET (gtk_builder_get_object (builder, "EditTags")); + if(!GUI_EditTags) printf("Error: gtk_builder didn't work (EditTags)!\n"); + + GUI_EditTagsTextArea = GTK_WIDGET (gtk_builder_get_object (builder, "EditTagsTextArea")); + if(!GUI_EditTagsTextArea) printf("Error: gtk_builder didn't work(EditTagsTextArea)!\n"); + + /* move history and game list windows */ + GUI_History = GTK_WIDGET (gtk_builder_get_object (builder, "MoveHistory")); + if(!GUI_History) printf("Error: gtk_builder didn't work (MoveHistory)!\n"); + + TREE_History = GTK_TREE_VIEW (gtk_builder_get_object (builder, "MoveHistoryView")); + if(!TREE_History) printf("Error: gtk_builder didn't work (MoveHistoryView)!\n"); + + GUI_GameList = GTK_WIDGET (gtk_builder_get_object (builder, "GameList")); + if(!GUI_GameList) printf("Error: gtk_builder didn't work (GameList)!\n"); + + TREE_Game = GTK_TREE_VIEW (gtk_builder_get_object (builder, "GameListView")); + if(!TREE_Game) printf("Error: gtk_builder didn't work (GameListView)!\n"); + /* connect lists to views */ + gtk_tree_view_set_model(TREE_History, GTK_TREE_MODEL(LIST_MoveHistory)); + gtk_tree_view_set_model(TREE_Game, GTK_TREE_MODEL(LIST_GameList)); + gtk_builder_connect_signals (builder, NULL); // don't unref the builder, since we use it to get references to widgets @@ -2225,33 +1504,8 @@ main(argc, argv) /* 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"; @@ -2261,9 +1515,9 @@ main(argc, argv) 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]; @@ -2296,10 +1550,6 @@ main(argc, argv) 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 */ @@ -2307,82 +1557,18 @@ main(argc, argv) #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); @@ -2390,31 +1576,31 @@ main(argc, argv) /* * 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; @@ -2425,7 +1611,7 @@ main(argc, argv) 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; @@ -2436,7 +1622,7 @@ main(argc, argv) 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; @@ -2447,7 +1633,7 @@ main(argc, argv) 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; @@ -2459,7 +1645,7 @@ main(argc, argv) 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; @@ -2471,7 +1657,7 @@ main(argc, argv) 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; @@ -2492,19 +1678,13 @@ main(argc, argv) 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 || @@ -2654,11 +1834,18 @@ main(argc, argv) 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 */ @@ -2694,6 +1881,9 @@ main(argc, argv) if (appData.icsInputBox) ICSInputBoxPopUp(); } + #ifdef SIGWINCH + signal(SIGWINCH, TermSizeSigHandler); + #endif signal(SIGINT, IntSigHandler); signal(SIGTERM, IntSigHandler); if (*appData.cmailGameName != NULLCHAR) { @@ -2725,10 +1915,16 @@ ShutDownFrontEnd() if (appData.icsActive && oldICSInteractionTitle != NULL) { DisplayIcsInteractionTitle(oldICSInteractionTitle); } + if (saveSettingsOnExit) SaveSettings(settingsFileName); unlink(gameCopyFilename); unlink(gamePasteFilename); } +RETSIGTYPE TermSizeSigHandler(int sig) +{ + update_ics_width(); +} + RETSIGTYPE IntSigHandler(sig) int sig; @@ -2796,6 +1992,20 @@ ResetFrontEnd() } 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; { @@ -2932,12 +2142,12 @@ char *FindFont(pattern, targetPxlSize) 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]; @@ -2983,7 +2193,7 @@ char *FindFont(pattern, targetPxlSize) #ifdef ENABLE_NLS if (missing_count > 0) XFreeStringList(missing_list); - XFreeFontSet(xDisplay, fntSet); + // XFreeFontSet(xDisplay, fntSet); #else XFreeFontNames(fonts); #endif @@ -2993,83 +2203,7 @@ char *FindFont(pattern, targetPxlSize) void CreateGCs() { /* 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*/ - - 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); - } + return; } void CreatePieces() @@ -3300,6 +2434,8 @@ void PieceMenuPopup(w, event, params, num_params) Cardinal *num_params; { String whichMenu; + + if (event->type != ButtonRelease) UnLoadPV(); // [HGM] pv if (event->type != ButtonPress) return; if (errorUp) ErrorPopDown(); switch (gameMode) { @@ -3307,12 +2443,25 @@ void PieceMenuPopup(w, event, params, num_params) 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(); @@ -3830,7 +2979,7 @@ static int check_castle_draw(newb, oldb, rrow, rcol) return 0; } -static int damage[BOARD_SIZE][BOARD_SIZE]; +static int damage[BOARD_RANKS][BOARD_FILES]; /* * event handler for redrawing the board @@ -3979,212 +3128,18 @@ void DrawPosition( repaint, 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; @@ -4203,13 +3158,13 @@ Widget CommentCreate(name, text, mutable, callback, lines) 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, @@ -4310,25 +3265,33 @@ Widget CommentCreate(name, text, mutable, callback, lines) 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++; @@ -4358,13 +3321,13 @@ Widget MiscCreate(name, text, mutable, callback, lines) 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, @@ -4407,17 +3370,17 @@ Widget MiscCreate(name, text, mutable, callback, lines) 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; @@ -4451,7 +3414,7 @@ void EditCommentPopUp(index, title, text) editShell = CommentCreate(title, text, True, EditCommentCallback, 4); XtRealizeWidget(editShell); - CatchDeleteWindow(editShell, "EditCommentPopDown"); + // CatchDeleteWindow(editShell, "EditCommentPopDown"); } else { edit = XtNameToWidget(editShell, "*form.text"); j = 0; @@ -4535,7 +3498,7 @@ void ICSInputBoxPopUp() edit = XtNameToWidget(ICSInputShell, "*form.text"); XtOverrideTranslations(edit, tr); XtRealizeWidget(ICSInputShell); - CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown"); + // CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown"); } else { edit = XtNameToWidget(ICSInputShell, "*form.text"); @@ -4600,7 +3563,7 @@ void CommentPopUp(title, text) commentShell = CommentCreate(title, text, False, CommentCallback, 4); XtRealizeWidget(commentShell); - CatchDeleteWindow(commentShell, "CommentPopDown"); + // CatchDeleteWindow(commentShell, "CommentPopDown"); } else { edit = XtNameToWidget(commentShell, "*form.text"); j = 0; @@ -4613,42 +3576,11 @@ void CommentPopUp(title, text) } 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; @@ -4683,152 +3615,10 @@ void CommentPopDown() 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]; @@ -4844,13 +3634,13 @@ void PromotionPopUp() 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++; @@ -4890,7 +3680,7 @@ void PromotionPopUp() (XtPointer) dialog); XtRealizeWidget(promotionShell); - CatchDeleteWindow(promotionShell, "PromotionPopDown"); + // CatchDeleteWindow(promotionShell, "PromotionPopDown"); j = 0; XtSetArg(args[j], XtNwidth, &pw_width); j++; @@ -4948,7 +3738,7 @@ void PromotionCallback(w, client_data, call_data) 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); @@ -5092,9 +3882,10 @@ void ModeHighlight() } } - 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; @@ -5126,7 +3917,11 @@ int LoadGamePopUp(f, gameNumber, title) 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; }; @@ -5137,40 +3932,6 @@ int LoadGamePopUp(f, gameNumber, title) return LoadGame(f, gameNumber, title, FALSE); } -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; @@ -5190,9 +3951,9 @@ void MailMoveProc(w, event, prms, nprms) } /* 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) @@ -5200,21 +3961,34 @@ SendPositionSelection(Widget w, Atom *selection, Atom *target, 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 @@ -5226,20 +4000,25 @@ void CopyPositionProc(w, event, prms, nprms) String *prms; Cardinal *nprms; { - int ret; - + /* + * Set both PRIMARY (the selection) and CLIPBOARD, since we don't + * have a notion of a position that is selected but not copied. + * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki + */ + if(gameMode == EditPosition) EditPositionDone(TRUE); if (selected_fen_position) free(selected_fen_position); selected_fen_position = (char *)PositionToFEN(currentMove, NULL); if (!selected_fen_position) return; - ret = XtOwnSelection(menuBarWidget, XA_PRIMARY, - CurrentTime, - SendPositionSelection, - NULL/* lose_ownership_proc */ , - NULL/* transfer_done_proc */); - if (!ret) { - free(selected_fen_position); - selected_fen_position=NULL; - } +// XtOwnSelection(menuBarWidget, XA_PRIMARY, +// CurrentTime, +// SendPositionSelection, +// NULL/* lose_ownership_proc */ , +// NULL/* transfer_done_proc */); +// XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay), +// CurrentTime, +// SendPositionSelection, +// NULL/* lose_ownership_proc */ , +// NULL/* transfer_done_proc */); } /* function called when the data to Paste is ready */ @@ -5262,15 +4041,16 @@ void PastePositionProc(w, event, prms, nprms) 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; } @@ -5281,29 +4061,42 @@ SendGameSelection(Widget w, Atom *selection, Atom *target, { 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 @@ -5320,11 +4113,21 @@ void CopyGameProc(w, event, prms, nprms) ret = SaveGameToFile(gameCopyFilename, FALSE); if (!ret) return; - ret = XtOwnSelection(menuBarWidget, XA_PRIMARY, - CurrentTime, - SendGameSelection, - NULL/* lose_ownership_proc */ , - NULL/* transfer_done_proc */); + /* + * Set both PRIMARY (the selection) and CLIPBOARD, since we don't + * have a notion of a game that is selected but not copied. + * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki + */ +// XtOwnSelection(menuBarWidget, XA_PRIMARY, +// CurrentTime, +// SendGameSelection, +// NULL/* lose_ownership_proc */ , +// NULL/* transfer_done_proc */); +// XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay), +// CurrentTime, +// SendGameSelection, +// NULL/* lose_ownership_proc */ , +// NULL/* transfer_done_proc */); } /* function called when the data to Paste is ready */ @@ -5355,117 +4158,55 @@ void PasteGameProc(w, event, prms, nprms) 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; @@ -5503,455 +4244,6 @@ void EnterKeyProc(w, event, prms, nprms) 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; @@ -5988,9 +4280,9 @@ void Iconify(w, event, prms, nprms) { 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) @@ -6157,14 +4449,14 @@ void DisplayIcsInteractionTitle(message) 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) { @@ -6255,14 +4547,14 @@ void AskQuestion(title, question, replyPrefix, pr) 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++; @@ -6276,20 +4568,20 @@ void AskQuestion(title, question, replyPrefix, pr) (XtPointer) dialog); XtRealizeWidget(popup); - CatchDeleteWindow(popup, "AskQuestionPopDown"); - - XQueryPointer(xDisplay, xBoardWindow, &root, &child, - &x, &y, &win_x, &win_y, &mask); + // CatchDeleteWindow(popup, "AskQuestionPopDown"); - 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); +// 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); } @@ -6757,8 +5049,11 @@ int StartChildProcess(cmdLine, dir, pr) strcpy(buf, cmdLine); p = buf; for (;;) { + while(*p == ' ') p++; argv[i++] = p; - p = strchr(p, ' '); + if(*p == '"' || *p == '\'') + p = strchr(++argv[i-1], *p); + else p = strchr(p, ' '); if (p == NULL) break; *p++ = NULLCHAR; } @@ -7088,7 +5383,6 @@ InputSourceRef AddInputSource(pr, lineByLine, func, closure) // /* 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); @@ -7115,11 +5409,33 @@ int OutputToProcess(pr, message, count, outError) int count; int *outError; { + static int line = 0; ChildProc *cp = (ChildProc *) pr; int outCount; if (pr == NoProc) - outCount = fwrite(message, 1, count, stdout); + { + if (appData.noJoin || !appData.useInternalWrap) + outCount = fwrite(message, 1, count, stdout); + else + { + int width = get_term_width(); + int len = wrap(NULL, message, count, width, &line); + char *msg = malloc(len); + int dbgchk; + + if (!msg) + outCount = fwrite(message, 1, count, stdout); + else + { + dbgchk = wrap(msg, message, count, width, &line); + if (dbgchk != len && appData.debugMode) + fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len); + outCount = fwrite(msg, 1, dbgchk, stdout); + free(msg); + } + } + } else outCount = write(cp->fdTo, message, count); @@ -7196,71 +5512,71 @@ CreateAnimMasks (pieceDepth) 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 @@ -7840,7 +6156,7 @@ DragPieceMove(x, y) 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); @@ -7896,10 +6212,37 @@ DrawDragPiece () damage[player.startBoardY][player.startBoardX] = TRUE; } -void -SetProgramStats( FrontEndProgramStats * stats ) +#include +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(); }