/*
* xboard.c -- X front end for XBoard
- * $Id$
*
- * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
- * Enhancements Copyright 1992-2001 Free Software Foundation, Inc.
+ * Copyright 1991 by Digital Equipment Corporation, Maynard,
+ * Massachusetts.
+ *
+ * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
+ * 2007, 2008, 2009 Free Software Foundation, Inc.
*
* The following terms apply to Digital Equipment Corporation's copyright
* interest in XBoard:
* SOFTWARE.
* ------------------------------------------------------------------------
*
- * The following terms apply to the enhanced version of XBoard distributed
- * by the Free Software Foundation:
+ * The following terms apply to the enhanced version of XBoard
+ * distributed by the Free Software Foundation:
* ------------------------------------------------------------------------
- * This program is free software; you can redistribute it and/or modify
+ *
+ * GNU XBoard is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
*
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * GNU XBoard is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- * ------------------------------------------------------------------------
+ * along with this program. If not, see http://www.gnu.org/licenses/. *
*
- * See the file ChangeLog for a revision history.
- */
+ *------------------------------------------------------------------------
+ ** See the file ChangeLog for a revision history. */
#include "config.h"
#include <X11/Xaw/AsciiText.h>
#endif
+// [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
+#include "common.h"
+
#if HAVE_LIBXPM
#include <X11/xpm.h>
#include "pixmaps/pixmaps.h"
#include "bitmaps/icon_black.bm"
#include "bitmaps/checkmark.bm"
-#include "common.h"
#include "frontend.h"
#include "backend.h"
#include "moves.h"
#include "xedittags.h"
#include "gettext.h"
+// must be moved to xengineoutput.h
+
+void EngineOutputProc P((Widget w, XEvent *event,
+ String *prms, Cardinal *nprms));
+
+void EngineOutputPopDown();
+
+
#ifdef __EMX__
#ifndef HAVE_USLEEP
#define HAVE_USLEEP
String *prms, Cardinal *nprms));
void DrawPositionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
-void XDrawPosition P((Widget w, /*Boolean*/int repaint,
+void XDrawPosition P((Widget w, /*Boolean*/int repaint,
Board board));
void CommentPopUp P((char *title, char *label));
void CommentPopDown P((void));
void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void AdjuWhiteProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void StopObservingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
Cardinal *nprms));
void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
+void HideThinkingProc P((Widget w, XEvent *event, String *prms,
+ Cardinal *nprms));
void TestLegalityProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
static void DragPieceEnd P((int x, int y));
static void DrawDragPiece P((void));
char *ModeToWidgetName P((GameMode mode));
-
+void EngineOutputUpdate( FrontEndProgramStats * stats );
+void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void ShufflePopDown P(());
+void EnginePopDown P(());
+void UciPopDown P(());
+void TimeControlPopDown P(());
+void NewVariantPopDown P(());
+void SettingsPopDown P(());
/*
* XBoard depends on Xt R4 or higher
*/
Window xBoardWindow;
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
jailSquareColor, highlightSquareColor, premoveHighlightColor;
+Pixel lowTimeWarningColor;
GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
- wjPieceGC, bjPieceGC, prelineGC;
+ wjPieceGC, bjPieceGC, prelineGC, countGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
- whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
+Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
+ whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
ICSInputShell, fileNameShell, askQuestionShell;
XSegment gridSegments[(BOARD_SIZE + 1) * 2];
XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
-Font clockFontID, coordFontID;
-XFontStruct *clockFontStruct, *coordFontStruct;
+Font clockFontID, coordFontID, countFontID;
+XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
char *layoutName;
char *oldICSInteractionTitle;
FileProc fileProc;
char *fileOpenMode;
+char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
Position commentX = -1, commentY = -1;
Dimension commentW, commentH;
int squareSize, smallLayout = 0, tinyLayout = 0,
+ marginW, marginH, // [HGM] for run-time resizing
fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
ICSInputBoxUp = False, askQuestionUp = False,
filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
#define SOLID 0
#define OUTLINE 1
-Pixmap pieceBitmap[2][6];
-Pixmap xpmPieceBitmap[4][6]; /* LL, LD, DL, DD */
+Pixmap pieceBitmap[2][(int)BlackPawn];
+Pixmap pieceBitmap2[2][(int)BlackPawn+4]; /* [HGM] pieces */
+Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
+Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
int useImages, useImageSqs;
-XImage *ximPieceBitmap[4][6]; /* LL, LD, DL, DD */
-Pixmap ximMaskPm[6]; /* clipmasks, used for XIM pieces */
+XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
+Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
+Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
XImage *ximLightSquare, *ximDarkSquare;
XImage *xim_Cross;
-#define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % 6]
-#define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % 6]
+#define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
+#define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
#define White(piece) ((int)(piece) < (int)BlackPawn)
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
MenuItem fileMenu[] = {
- {N_("Reset Game"), ResetProc},
+ {N_("New Game"), ResetProc},
+ {N_("New Shuffle Game ..."), ShuffleMenuProc},
+ {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
{"----", NothingProc},
{N_("Load Game"), LoadGameProc},
{N_("Load Next Game"), LoadNextGameProc},
{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 Game List"), ShowGameListProc},
- {N_("Show Move List"), HistoryShowProc},
+ {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
+ {"----", NothingProc},
{N_("Edit Tags"), EditTagsProc},
{N_("Edit Comment"), EditCommentProc},
{N_("ICS Input Box"), IcsInputBoxProc},
{N_("Accept"), AcceptProc},
{N_("Decline"), DeclineProc},
{N_("Rematch"), RematchProc},
- {"----", NothingProc},
+ {"----", NothingProc},
{N_("Call Flag"), CallFlagProc},
{N_("Draw"), DrawProc},
{N_("Adjourn"), AdjournProc},
{N_("Abort"), AbortProc},
{N_("Resign"), ResignProc},
- {"----", NothingProc},
+ {"----", NothingProc},
{N_("Stop Observing"), StopObservingProc},
{N_("Stop Examining"), StopExaminingProc},
+ {"----", NothingProc},
+ {N_("Adjudicate to White"), AdjuWhiteProc},
+ {N_("Adjudicate to Black"), AdjuBlackProc},
+ {N_("Adjudicate Draw"), AdjuDrawProc},
{NULL, NULL}
};
{N_("Forward to End"), ToEndProc},
{N_("Revert"), RevertProc},
{N_("Truncate Game"), TruncateGameProc},
- {"----", NothingProc},
+ {"----", NothingProc},
{N_("Move Now"), MoveNowProc},
{N_("Retract Move"), RetractMoveProc},
{NULL, NULL}
-};
+};
MenuItem optionsMenu[] = {
+ {N_("Flip View"), FlipViewProc},
+ {"----", NothingProc},
+ {N_("Adjudications ..."), EngineMenuProc},
+ {N_("General Settings ..."), UciMenuProc},
+ {N_("Engine #1 Settings ..."), FirstSettingsProc},
+ {N_("Engine #2 Settings ..."), SecondSettingsProc},
+ {N_("Time Control ..."), TimeControlProc},
+ {"----", NothingProc},
{N_("Always Queen"), AlwaysQueenProc},
{N_("Animate Dragging"), AnimateDraggingProc},
{N_("Animate Moving"), AnimateMovingProc},
{N_("Auto Save"), AutosaveProc},
{N_("Blindfold"), BlindfoldProc},
{N_("Flash Moves"), FlashMovesProc},
- {N_("Flip View"), FlipViewProc},
{N_("Get Move List"), GetMoveListProc},
#if HIGHDRAG
{N_("Highlight Dragging"), HighlightDraggingProc},
{N_("Move Sound"), MoveSoundProc},
{N_("ICS Alarm"), IcsAlarmProc},
{N_("Old Save Style"), OldSaveStyleProc},
- {N_("Periodic Updates"), PeriodicUpdatesProc},
+ {N_("Periodic Updates"), PeriodicUpdatesProc},
{N_("Ponder Next Move"), PonderNextMoveProc},
- {N_("Popup Exit Message"), PopupExitMessageProc},
- {N_("Popup Move Errors"), PopupMoveErrorsProc},
+ {N_("Popup Exit Message"), PopupExitMessageProc},
+ {N_("Popup Move Errors"), PopupMoveErrorsProc},
{N_("Premove"), PremoveProc},
{N_("Quiet Play"), QuietPlayProc},
{N_("Show Coords"), ShowCoordsProc},
- {N_("Show Thinking"), ShowThinkingProc},
+ {N_("Hide Thinking"), HideThinkingProc},
{N_("Test Legality"), TestLegalityProc},
{NULL, NULL}
};
{NULL, NULL}
};
-
-/* Label on pause button */
#define PAUSE_BUTTON N_("P")
MenuItem buttonBar[] = {
{"<<", ToStartProc},
{NULL, NULL}
};
-#define PIECE_MENU_SIZE 11
+#define PIECE_MENU_SIZE 18
String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
{ N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
+ N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
+ N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ N_("Empty square"), N_("Clear board") },
{ N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
- };
+ N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
+ N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ N_("Empty square"), N_("Clear board") }
+};
/* must be in same order as PieceMenuStrings! */
ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
{ WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
- WhiteRook, WhiteQueen, WhiteKing,
- (ChessSquare) 0, EmptySquare, ClearBoard },
+ WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
+ WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
+ PromotePiece, DemotePiece, EmptySquare, ClearBoard },
{ BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
- BlackRook, BlackQueen, BlackKing,
- (ChessSquare) 0, EmptySquare, ClearBoard },
+ BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
+ BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
+ PromotePiece, DemotePiece, EmptySquare, ClearBoard },
};
#define DROP_MENU_SIZE 6
BLACK_PIECE_COLOR },
{ "lightSquareColor", "lightSquareColor", XtRString,
sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
- XtRString, LIGHT_SQUARE_COLOR },
+ XtRString, LIGHT_SQUARE_COLOR },
{ "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
XtOffset(AppDataPtr, darkSquareColor), XtRString,
DARK_SQUARE_COLOR },
{ "secondHost", "secondHost", XtRString, sizeof(String),
XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
{ "firstDirectory", "firstDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, firstDirectory), XtRString, "" },
+ XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
{ "secondDirectory", "secondDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondDirectory), XtRString, "" },
+ XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
{ "bitmapDirectory", "bitmapDirectory", XtRString,
sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
XtRString, "" },
XtOffset(AppDataPtr, searchTime), XtRString,
(XtPointer) "" },
{ "searchDepth", "searchDepth", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, searchDepth), XtRImmediate,
+ XtOffset(AppDataPtr, searchDepth), XtRImmediate,
(XtPointer) 0 },
{ "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
XtOffset(AppDataPtr, showCoords), XtRImmediate,
(XtPointer) 0 },
{ "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
XtOffset(AppDataPtr, showThinking), XtRImmediate,
- (XtPointer) False },
+ (XtPointer) True },
{ "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
(XtPointer) True },
{ "localLineEditing", "localLineEditing", XtRBoolean,
sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
-#ifdef ZIPPY
+#if ZIPPY
{ "zippyTalk", "zippyTalk", XtRBoolean,
sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
XtRImmediate, (XtPointer) ZIPPY_TALK },
{ "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) MS_LOGIN_DELAY },
{ "colorizeMessages", "colorizeMessages", XtRBoolean,
sizeof(Boolean), XtOffset(AppDataPtr, colorize),
- XtRImmediate, (XtPointer) False },
+ XtRImmediate, (XtPointer) False },
{ "colorShout", "colorShout", XtRString,
sizeof(String), XtOffset(AppDataPtr, colorShout),
XtRString, COLOR_SHOUT },
XtRString, COLOR_SEEK },
{ "colorNormal", "colorNormal", XtRString,
sizeof(String), XtOffset(AppDataPtr, colorNormal),
- XtRString, COLOR_NORMAL },
+ XtRString, COLOR_NORMAL },
{ "soundProgram", "soundProgram", XtRString,
sizeof(String), XtOffset(AppDataPtr, soundProgram),
XtRString, "play" },
{ "showButtonBar", "showButtonBar", XtRBoolean,
sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
XtRImmediate, (XtPointer) True },
+ { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
+ XtRString, COLOR_LOWTIMEWARNING },
+ { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
+ XtRImmediate, (XtPointer) False },
+ {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean, /* [DM] icsEngineAnalyze */
+ sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
+ XtRImmediate, (XtPointer) False },
+ { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
+ XtRImmediate, (XtPointer) False },
+ { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
+ XtRImmediate, (XtPointer) False },
+ { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
+ XtRImmediate, (XtPointer) False },
+ { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
+ XtRImmediate, (XtPointer) True },
+ { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
+ XtRImmediate, (XtPointer) 0},
+ { "adjudicateDrawMoves", "adjudicateDrawMoves", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, adjudicateDrawMoves),
+ XtRImmediate, (XtPointer) 0},
+ { "pgnEventHeader", "pgnEventHeader", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
+ XtRImmediate, (XtPointer) "Computer Chess Game" },
+ { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
+ XtRImmediate, (XtPointer) -1},
+ { "gameListTags", "gameListTags", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, gameListTags),
+ XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
+
+ // [HGM] 4.3.xx options
+ { "boardWidth", "boardWidth", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, NrFiles),
+ XtRImmediate, (XtPointer) -1},
+ { "boardHeight", "boardHeight", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, NrRanks),
+ XtRImmediate, (XtPointer) -1},
+ { "matchPause", "matchPause", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, matchPause),
+ XtRImmediate, (XtPointer) 10000},
+ { "holdingsSize", "holdingsSize", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, holdingsSize),
+ XtRImmediate, (XtPointer) -1},
+ { "flipBlack", "flipBlack", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
+ XtRImmediate, (XtPointer) False},
+ { "allWhite", "allWhite", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
+ XtRImmediate, (XtPointer) False},
+ { "pieceToCharTable", "pieceToCharTable", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
+ XtRImmediate, (XtPointer) 0},
+ { "alphaRank", "alphaRank", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
+ XtRImmediate, (XtPointer) False},
+ { "testClaims", "testClaims", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
+ XtRImmediate, (XtPointer) True},
+ { "checkMates", "checkMates", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
+ XtRImmediate, (XtPointer) True},
+ { "materialDraws", "materialDraws", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
+ XtRImmediate, (XtPointer) True},
+ { "trivialDraws", "trivialDraws", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
+ XtRImmediate, (XtPointer) False},
+ { "ruleMoves", "ruleMoves", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, ruleMoves),
+ XtRImmediate, (XtPointer) 51},
+ { "repeatsToDraw", "repeatsToDraw", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, drawRepeats),
+ XtRImmediate, (XtPointer) 6},
+ { "engineDebugOutput", "engineDebugOutput", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, engineComments),
+ XtRImmediate, (XtPointer) 1},
+ { "userName", "userName", XtRString,
+ sizeof(int), XtOffset(AppDataPtr, userName),
+ XtRImmediate, (XtPointer) 0},
+ { "autoKibitz", "autoKibitz", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
+ XtRImmediate, (XtPointer) False},
+ { "firstTimeOdds", "firstTimeOdds", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
+ XtRImmediate, (XtPointer) 1},
+ { "secondTimeOdds", "secondTimeOdds", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
+ XtRImmediate, (XtPointer) 1},
+ { "timeOddsMode", "timeOddsMode", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
+ XtRImmediate, (XtPointer) 0},
+ { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
+ XtRImmediate, (XtPointer) 1},
+ { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
+ XtRImmediate, (XtPointer) 1},
+ { "firstNPS", "firstNPS", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, firstNPS),
+ XtRImmediate, (XtPointer) -1},
+ { "secondNPS", "secondNPS", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, secondNPS),
+ XtRImmediate, (XtPointer) -1},
+ { "serverMoves", "serverMoves", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, serverMovesName),
+ XtRImmediate, (XtPointer) 0},
+ { "serverPause", "serverPause", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, serverPause),
+ XtRImmediate, (XtPointer) 0},
+ { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
+ XtRImmediate, (XtPointer) False},
+ { "userName", "userName", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, userName),
+ XtRImmediate, (XtPointer) 0},
+ { "egtFormats", "egtFormats", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, egtFormats),
+ XtRImmediate, (XtPointer) 0},
+ { "rewindIndex", "rewindIndex", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, rewindIndex),
+ XtRImmediate, (XtPointer) 0},
+ { "sameColorGames", "sameColorGames", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, sameColorGames),
+ XtRImmediate, (XtPointer) 0},
+ { "smpCores", "smpCores", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, smpCores),
+ XtRImmediate, (XtPointer) 1},
+ { "niceEngines", "niceEngines", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, niceEngines),
+ XtRImmediate, (XtPointer) 0},
+ { "nameOfDebugFile", "nameOfDebugFile", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
+ XtRImmediate, (XtPointer) "xboard.debug"},
+ { "engineDebugOutput", "engineDebugOutput", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, engineComments),
+ XtRImmediate, (XtPointer) 1},
+ { "noGUI", "noGUI", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
+ XtRImmediate, (XtPointer) 0},
+ { "firstOptions", "firstOptions", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, firstOptions),
+ XtRImmediate, (XtPointer) "" },
+ { "secondOptions", "secondOptions", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, secondOptions),
+ XtRImmediate, (XtPointer) "" },
+ { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, fenOverride1),
+ XtRImmediate, (XtPointer) 0 },
+ { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, fenOverride2),
+ XtRImmediate, (XtPointer) 0 },
+
+ // [HGM] Winboard_x UCI options
+ { "firstIsUCI", "firstIsUCI", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
+ XtRImmediate, (XtPointer) False},
+ { "secondIsUCI", "secondIsUCI", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
+ XtRImmediate, (XtPointer) False},
+ { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
+ XtRImmediate, (XtPointer) True},
+ { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
+ XtRImmediate, (XtPointer) True},
+ { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
+ XtRImmediate, (XtPointer) False},
+ { "defaultHashSize", "defaultHashSize", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
+ XtRImmediate, (XtPointer) 64},
+ { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
+ XtRImmediate, (XtPointer) 4},
+ { "polyglotDir", "polyglotDir", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, polyglotDir),
+ XtRImmediate, (XtPointer) "." },
+ { "polyglotBook", "polyglotBook", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, polyglotBook),
+ XtRImmediate, (XtPointer) "" },
+ { "defaultPathEGTB", "defaultPathEGTB", XtRString,
+ sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
+ XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
+ { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
+ XtRImmediate, (XtPointer) 0},
+ { "delayAfterQuit", "delayAfterQuit", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
+ XtRImmediate, (XtPointer) 0},
+ { "keepAlive", "keepAlive", XtRInt,
+ sizeof(int), XtOffset(AppDataPtr, keepAlive),
+ XtRImmediate, (XtPointer) 0},
};
XrmOptionDescRec shellOptions[] = {
{ "-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" },
{ "-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 },
};
{ "EditGameProc", EditGameProc },
{ "EditPositionProc", EditPositionProc },
{ "TrainingProc", EditPositionProc },
+ { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
{ "ShowGameListProc", ShowGameListProc },
{ "ShowMoveListProc", HistoryShowProc},
{ "EditTagsProc", EditCommentProc },
{ "AdjournProc", AdjournProc },
{ "AbortProc", AbortProc },
{ "ResignProc", ResignProc },
+ { "AdjuWhiteProc", AdjuWhiteProc },
+ { "AdjuBlackProc", AdjuBlackProc },
+ { "AdjuDrawProc", AdjuDrawProc },
{ "EnterKeyProc", EnterKeyProc },
{ "StopObservingProc", StopObservingProc },
{ "StopExaminingProc", StopExaminingProc },
{ "IcsAlarmProc", IcsAlarmProc },
{ "MoveSoundProc", MoveSoundProc },
{ "OldSaveStyleProc", OldSaveStyleProc },
- { "PeriodicUpdatesProc", PeriodicUpdatesProc },
+ { "PeriodicUpdatesProc", PeriodicUpdatesProc },
{ "PonderNextMoveProc", PonderNextMoveProc },
- { "PopupExitMessageProc", PopupExitMessageProc },
- { "PopupMoveErrorsProc", PopupMoveErrorsProc },
+ { "PopupExitMessageProc", PopupExitMessageProc },
+ { "PopupMoveErrorsProc", PopupMoveErrorsProc },
{ "PremoveProc", PremoveProc },
{ "QuietPlayProc", QuietPlayProc },
{ "ShowCoordsProc", ShowCoordsProc },
{ "ShowThinkingProc", ShowThinkingProc },
+ { "HideThinkingProc", HideThinkingProc },
{ "TestLegalityProc", TestLegalityProc },
{ "InfoProc", InfoProc },
{ "ManProc", ManProc },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
{ "HistoryPopDown", (XtActionProc) HistoryPopDown },
+ { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+ { "ShufflePopDown", (XtActionProc) ShufflePopDown },
+ { "EnginePopDown", (XtActionProc) EnginePopDown },
+ { "UciPopDown", (XtActionProc) UciPopDown },
+ { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
+ { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
+ { "SettingsPopDown", (XtActionProc) SettingsPopDown },
};
-
+
char globalTranslations[] =
":<Key>R: ResignProc() \n \
:<Key>r: ResetProc() \n \
PieceMenuPopup(menuW) \n \
Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
PieceMenuPopup(menuB) \n";
-
+
char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
char blackTranslations[] = "<BtnDown>: BlackClock()\n";
-
+
char ICSInputTranslations[] =
"<Key>Return: EnterKeyProc() \n";
"*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
NULL
};
-
+
/* Max possible square size */
#define MAXSQSIZE 256
{
char *p, *d;
char buf[10];
-
+
if (len < 4)
return 0;
if ((p=strchr(name, '.')) == NULL ||
StrCaseCmp(p+1, ext) != 0)
return 0;
-
+
p = name + 3;
d = buf;
if (appData.debugMode)
fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
-
+
dir = opendir(dirname);
if (!dir)
{
- fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
+ fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
programName, dirname);
exit(1);
}
-
+
while ((ent=readdir(dir)) != NULL) {
i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
if (i > 0 && i < MAXSQSIZE)
int sm_diff = MAXSQSIZE;
int sm_index = 0;
int diff;
-
+
xpm_getavail(dirname, ext);
if (appData.debugMode)
xpm_print_avail(stderr, ext);
-
+
for (i=1; i<MAXSQSIZE; ++i) {
if (xpm_avail[i]) {
diff = size - i;
{
char *p, buf[100], *d;
int i;
-
+
if (strlen(str) > 99) /* watch bounds on buf */
return -1;
if (*p == ',') {
return -1; /* Use default for empty field */
}
-
+
if (which == 2 || isdigit(*p))
return atoi(p);
-
+
while (*p && isalpha(*p))
*(d++) = *(p++);
{
char buf[MSG_SIZ];
XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
- sprintf(buf, "<Message>WM_PROTOCOLS: %s() \n", procname);
+ snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
XtAugmentTranslations(w, XtParseTranslationTable(buf));
}
XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
}
+#ifdef IDSIZES
+ // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
+#else
+#define BoardSize int
+void InitDrawingSizes(BoardSize boardSize, int flags)
+{ // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
+ Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
+ Arg args[16];
+ XtGeometryResult gres;
+ int i;
+
+ if(!formWidget) return;
+
+ /*
+ * Enable shell resizing.
+ */
+ shellArgs[0].value = (XtArgVal) &w;
+ shellArgs[1].value = (XtArgVal) &h;
+ XtGetValues(shellWidget, shellArgs, 2);
+
+ shellArgs[4].value = 2*w; shellArgs[2].value = 10;
+ shellArgs[5].value = 2*h; shellArgs[3].value = 10;
+ XtSetValues(shellWidget, &shellArgs[2], 4);
+
+ XtSetArg(args[0], XtNdefaultDistance, &sep);
+ XtGetValues(formWidget, args, 1);
+
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ CreateGrid();
+
+ XtSetArg(args[0], XtNwidth, boardWidth);
+ XtSetArg(args[1], XtNheight, boardHeight);
+ XtSetValues(boardWidget, args, 2);
+
+ timerWidth = (boardWidth - sep) / 2;
+ XtSetArg(args[0], XtNwidth, timerWidth);
+ XtSetValues(whiteTimerWidget, args, 1);
+ XtSetValues(blackTimerWidget, args, 1);
+
+ XawFormDoLayout(formWidget, False);
+
+ if (appData.titleInWindow) {
+ i = 0;
+ XtSetArg(args[i], XtNborderWidth, &bor); i++;
+ XtSetArg(args[i], XtNheight, &h); i++;
+ XtGetValues(titleWidget, args, i);
+ if (smallLayout) {
+ w = boardWidth - 2*bor;
+ } else {
+ XtSetArg(args[0], XtNwidth, &w);
+ XtGetValues(menuBarWidget, args, 1);
+ w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
+ }
+
+ gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
+ if (gres != XtGeometryYes && appData.debugMode) {
+ fprintf(stderr,
+ _("%s: titleWidget geometry error %d %d %d %d %d\n"),
+ programName, gres, w, h, wr, hr);
+ }
+ }
+
+ XawFormDoLayout(formWidget, True);
+
+ /*
+ * Inhibit shell resizing.
+ */
+ shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
+ shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
+ shellArgs[4].value = shellArgs[2].value = w;
+ shellArgs[5].value = shellArgs[3].value = h;
+ XtSetValues(shellWidget, &shellArgs[0], 6);
+
+ // [HGM] pieces: tailor piece bitmaps to needs of specific variant
+ // (only for xpm)
+ if(useImages) {
+ for(i=0; i<4; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
+ xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
+ xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
+ xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
+ xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
+ }
+#endif
+#if !HAVE_LIBXPM
+ // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
+ for(p=0; p<=(int)WhiteKing; p++)
+ ximMaskPm[p] = ximMaskPm2[p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
+ ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
+ ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
+ ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
+ ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
+ }
+#endif
+#endif
+ }
+ } else {
+ for(i=0; i<2; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
+ pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
+ pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
+ pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
+ pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
+ }
+#endif
+ }
+ }
+#if HAVE_LIBXPM
+ CreateAnimVars();
+#endif
+}
+#endif
+
+void EscapeExpand(char *p, char *q)
+{ // [HGM] initstring: routine to shape up string arguments
+ while(*p++ = *q++) if(p[-1] == '\\')
+ switch(*q++) {
+ case 'n': p[-1] = '\n'; break;
+ case 'r': p[-1] = '\r'; break;
+ case 't': p[-1] = '\t'; break;
+ case '\\': p[-1] = '\\'; break;
+ case 0: *p = 0; return;
+ default: p[-1] = q[-1]; break;
+ }
+}
+
int
main(argc, argv)
int argc;
int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
XSetWindowAttributes window_attributes;
Arg args[16];
- Dimension timerWidth, boardWidth, w, h, sep, bor, wr, hr;
+ Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
XrmValue vFrom, vTo;
XtGeometryResult gres;
char *p;
XrmDatabase xdb;
int forceMono = False;
+#define INDIRECTION
+#ifdef INDIRECTION
+ // [HGM] before anything else, expand any indirection files amongst options
+ char *argvCopy[1000]; // 1000 seems enough
+ char newArgs[10000]; // holds actual characters
+ int k = 0;
+
+ srandom(time(0)); // [HGM] book: make random truly random
+
+ j = 0;
+ for(i=0; i<argc; i++) {
+ if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
+//fprintf(stderr, "arg %s\n", argv[i]);
+ if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
+ char c;
+ FILE *f = fopen(argv[i]+1, "rb");
+ if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
+ argvCopy[j++] = newArgs + k; // get ready for first argument from file
+ while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
+ if(c == '\n') {
+ if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
+ newArgs[k++] = 0; // terminate current arg
+ if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
+ argvCopy[j++] = newArgs + k; // get ready for next
+ } else {
+ if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
+ newArgs[k++] = c;
+ }
+ }
+ newArgs[k] = 0;
+ j--;
+ fclose(f);
+ }
+ }
+ argvCopy[j] = NULL;
+ argv = argvCopy;
+ argc = j;
+#if 0
+ if(appData.debugMode,1) { // OK, appData is not initialized here yet...
+ for(i=0; i<argc; i++) fprintf(stderr, "argv[%2d] = '%s'\n", i, argv[i]);
+ }
+#endif
+#endif
setbuf(stdout, NULL);
setbuf(stderr, NULL);
debugFP = stderr;
-
+
programName = strrchr(argv[0], '/');
if (programName == NULL)
programName = argv[0];
#ifdef ENABLE_NLS
XtSetLanguageProc(NULL, NULL, NULL);
- bindtextdomain(PRODUCT, LOCALEDIR);
- textdomain(PRODUCT);
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
#endif
shellWidget =
if (argc > 1) {
fprintf(stderr, _("%s: unrecognized argument %s\n"),
programName, argv[1]);
+ fprintf(stderr, "Recognized options:\n");
+ for(i = 0; i < XtNumber(shellOptions); i++) {
+ j = fprintf(stderr, " %s%s", shellOptions[i].option,
+ (shellOptions[i].argKind == XrmoptionSepArg
+ ? " ARG" : ""));
+ if (i++ < XtNumber(shellOptions)) {
+ fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
+ shellOptions[i].option,
+ (shellOptions[i].argKind == XrmoptionSepArg
+ ? " ARG" : ""));
+ } else {
+ fprintf(stderr, "\n");
+ }
+ }
exit(2);
}
-
+
+ p = getenv("HOME");
+ if (p == NULL) p = "/tmp";
+ i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
+ gameCopyFilename = (char*) malloc(i);
+ gamePasteFilename = (char*) malloc(i);
+ 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);
+
+ { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
+ static char buf[MSG_SIZ];
+ EscapeExpand(buf, appData.initString);
+ appData.initString = strdup(buf);
+ EscapeExpand(buf, appData.secondInitString);
+ appData.secondInitString = strdup(buf);
+ EscapeExpand(buf, appData.firstComputerString);
+ appData.firstComputerString = strdup(buf);
+ EscapeExpand(buf, appData.secondComputerString);
+ appData.secondComputerString = strdup(buf);
+ }
+
if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
chessDir = ".";
} else {
exit(1);
}
}
-
- p = getenv("HOME");
- if (p == NULL) p = "/tmp";
- i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
- gameCopyFilename = (char*) malloc(i);
- gamePasteFilename = (char*) malloc(i);
- sprintf(gameCopyFilename, "%s/.xboard%05uc.pgn", p, getpid());
- sprintf(gamePasteFilename, "%s/.xboard%05up.pgn", p, getpid());
- XtGetApplicationResources(shellWidget, (XtPointer) &appData,
- clientResources, XtNumber(clientResources),
- NULL, 0);
+ if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
+ /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
+ if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL) {
+ printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
+ exit(errno);
+ }
+ 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 */
xScreen = DefaultScreen(xDisplay);
wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
+ gameInfo.variant = StringToVariant(appData.variant);
+ InitPosition(FALSE);
+#if 0
/*
* Determine boardSize
*/
+ gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8
+
+//#ifndef IDSIZE
+ // [HGM] as long as we have not created the possibility to change size while running, start with requested size
+ gameInfo.boardWidth = appData.NrFiles > 0 ? appData.NrFiles : 8;
+ gameInfo.boardHeight = appData.NrRanks > 0 ? appData.NrRanks : 8;
+ gameInfo.holdingsWidth = appData.holdingsSize > 0 ? 2 : 0;
+#endif
+
+
+#ifdef IDSIZE
+ InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
+#else
if (isdigit(appData.boardSize[0])) {
i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
&lineGap, &clockFontPxlSize, &coordFontPxlSize,
exit(1);
}
if (appData.debugMode) {
- fprintf(stderr, _("\
+ fprintf(stderr, _("\
XBoard square size (hint): %d\n\
%s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
}
fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
}
}
-
- boardWidth = lineGap + BOARD_SIZE * (squareSize + lineGap);
+
+ /* [HR] height treated separately (hacked) */
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
if (appData.showJail == 1) {
/* Jail on top and bottom */
XtSetArg(boardArgs[1], XtNwidth, boardWidth);
XtSetArg(boardArgs[2], XtNheight,
- boardWidth + 2*(lineGap + squareSize));
+ boardHeight + 2*(lineGap + squareSize));
} else if (appData.showJail == 2) {
/* Jail on sides */
XtSetArg(boardArgs[1], XtNwidth,
boardWidth + 2*(lineGap + squareSize));
- XtSetArg(boardArgs[2], XtNheight, boardWidth);
+ XtSetArg(boardArgs[2], XtNheight, boardHeight);
} else {
/* No jail */
XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight, boardWidth);
+ XtSetArg(boardArgs[2], XtNheight, boardHeight);
}
/*
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);
if (forceMono) {
fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
programName);
+
+ if (appData.bitmapDirectory == NULL ||
+ appData.bitmapDirectory[0] == NULLCHAR)
+ appData.bitmapDirectory = DEF_BITMAP_DIR;
+ }
+
+ if (appData.lowTimeWarning && !appData.monoMode) {
+ vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
+ vFrom.size = strlen(appData.lowTimeWarningColor);
+ XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ if (vTo.addr == NULL)
+ appData.monoMode = True;
+ else
+ lowTimeWarningColor = *(Pixel *) vTo.addr;
}
if (appData.monoMode && appData.debugMode) {
(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 ||
}
textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
textColors[ColorNone].attr = 0;
-
+
XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
-
+
/*
* widget hierarchy
*/
formArgs, XtNumber(formArgs));
XtSetArg(args[0], XtNdefaultDistance, &sep);
XtGetValues(formWidget, args, 1);
-
+
j = 0;
widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetValues(menuBarWidget, args, 2);
widgetList[j++] = whiteTimerWidget =
XtCreateWidget("whiteTime", labelWidgetClass,
formWidget, timerArgs, XtNumber(timerArgs));
XtSetArg(args[0], XtNfont, clockFontStruct);
- XtSetValues(whiteTimerWidget, args, 1);
-
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainTop);
+ XtSetValues(whiteTimerWidget, args, 3);
+
widgetList[j++] = blackTimerWidget =
XtCreateWidget("blackTime", labelWidgetClass,
formWidget, timerArgs, XtNumber(timerArgs));
XtSetArg(args[0], XtNfont, clockFontStruct);
- XtSetValues(blackTimerWidget, args, 1);
-
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainTop);
+ XtSetValues(blackTimerWidget, args, 3);
+
if (appData.titleInWindow) {
- widgetList[j++] = titleWidget =
+ widgetList[j++] = titleWidget =
XtCreateWidget("title", labelWidgetClass, formWidget,
titleArgs, XtNumber(titleArgs));
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetValues(titleWidget, args, 2);
}
if (appData.showButtonBar) {
widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
+ XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
+ XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
+ XtSetArg(args[2], XtNtop, XtChainTop);
+ XtSetArg(args[3], XtNbottom, XtChainTop);
+ XtSetValues(buttonBarWidget, args, 4);
}
widgetList[j++] = messageWidget =
XtCreateWidget("message", labelWidgetClass, formWidget,
messageArgs, XtNumber(messageArgs));
-
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetValues(messageWidget, args, 2);
+
widgetList[j++] = boardWidget =
XtCreateWidget("board", widgetClass, formWidget, boardArgs,
XtNumber(boardArgs));
XtManageChildren(widgetList, j);
-
+
timerWidth = (boardWidth - sep) / 2;
XtSetArg(args[0], XtNwidth, timerWidth);
XtSetValues(whiteTimerWidget, args, 1);
XtSetValues(blackTimerWidget, args, 1);
-
+
XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
XtGetValues(whiteTimerWidget, args, 2);
-
+
if (appData.showButtonBar) {
XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
}
i = 0;
XtSetArg(args[0], XtNfromVert, messageWidget);
- XtSetValues(boardWidget, args, 1);
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainBottom);
+ XtSetArg(args[3], XtNleft, XtChainLeft);
+ XtSetArg(args[4], XtNright, XtChainRight);
+ XtSetValues(boardWidget, args, 5);
XtRealizeWidget(shellWidget);
* The value "2" is probably larger than needed.
*/
XawFormDoLayout(formWidget, False);
+
#define WIDTH_FUDGE 2
i = 0;
XtSetArg(args[i], XtNborderWidth, &bor); i++;
fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
programName, gres, w, h, wr, hr);
}
-
+
/* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
/* The size used for the child widget in layout lags one resize behind
its true size, so we resize a second time, 1 pixel smaller. Yeech! */
programName, gres, w, h, wr, hr);
}
/* !! end hack */
+ XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
+ XtSetArg(args[1], XtNright, XtChainRight);
+ XtSetValues(messageWidget, args, 2);
if (appData.titleInWindow) {
i = 0;
XawFormDoLayout(formWidget, True);
xBoardWindow = XtWindow(boardWidget);
-
- /*
+
+ // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
+ // not need to go into InitDrawingSizes().
+#endif
+
+ /*
* Create X checkmark bitmap and initialize option menu checks.
*/
ReadBitmap(&xMarkPixmap, "checkmark.bm",
if (appData.periodicUpdates) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Periodic Updates"), args, 1);
- }
+ }
if (appData.ponderNextMove) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Ponder Next Move"), args, 1);
- }
+ }
if (appData.popupExitMessage) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Popup Exit Message"), args, 1);
- }
+ }
if (appData.popupMoveErrors) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Popup Move Errors"), args, 1);
- }
+ }
if (appData.premove) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Premove"), args, 1);
XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
args, 1);
}
- if (appData.showThinking) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
+ if (appData.hideThinkingFromHuman) {
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
args, 1);
}
if (appData.testLegality) {
i = 0;
XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
XtSetValues(shellWidget, args, i);
-
+
/*
* Create a cursor for the board widget.
*/
window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
XChangeWindowAttributes(xDisplay, xBoardWindow,
CWCursor, &window_attributes);
-
+
/*
* Inhibit shell resizing.
*/
shellArgs[4].value = shellArgs[2].value = w;
shellArgs[5].value = shellArgs[3].value = h;
XtSetValues(shellWidget, &shellArgs[2], 4);
-
+ marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
+ marginH = h - boardHeight;
+
CatchDeleteWindow(shellWidget, "QuitProc");
CreateGCs();
CreateXIMPieces();
/* Create regular pieces */
if (!useImages) CreatePieces();
-#endif
+#endif
CreatePieceMenus();
if (appData.animate || appData.animateDragging)
CreateAnimVars();
-
+
XtAugmentTranslations(formWidget,
XtParseTranslationTable(globalTranslations));
XtAugmentTranslations(boardWidget,
/* end why */
InitBackEnd2();
-
+
if (errorExitStatus == -1) {
if (appData.icsActive) {
/* We now wait until we see "login:" from the ICS before
signal(SIGUSR1, CmailSigHandler);
}
}
+ gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
+ InitPosition(TRUE);
XtAppMainLoop(appContext);
+ if (appData.debugMode) fclose(debugFP); // [DM] debug
return 0;
}
{ "menuHelp.Hint", False },
{ "menuHelp.Book", False },
{ "menuStep.Move Now", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Show Thinking", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
{ "menuOptions.Ponder Next Move", False },
#endif
{ NULL, False }
};
-Enables ncpEnables[] = {
+Enables ncpEnables[] = {
{ "menuFile.Mail Move", False },
{ "menuFile.Reload CMail Message", False },
{ "menuMode.Machine White", False },
{ "menuOptions.ICS Alarm", False },
{ "menuOptions.Move Sound", False },
{ "menuOptions.Quiet Play", False },
- { "menuOptions.Show Thinking", False },
- { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Periodic Updates", False },
{ "menuOptions.Ponder Next Move", False },
{ "menuHelp.Hint", False },
{ "menuHelp.Book", False },
{ NULL, False }
};
-Enables gnuEnables[] = {
+Enables gnuEnables[] = {
{ "menuMode.ICS Client", False },
{ "menuMode.ICS Input Box", False },
{ "menuAction.Accept", False },
{ NULL, False }
};
-Enables cmailEnables[] = {
+Enables cmailEnables[] = {
{ "Action", True },
{ "menuAction.Call Flag", False },
{ "menuAction.Draw", True },
{ NULL, False }
};
-Enables trainingOnEnables[] = {
+Enables trainingOnEnables[] = {
{ "menuMode.Edit Comment", False },
{ "menuMode.Pause", False },
{ "menuStep.Forward", False },
{ NULL, False }
};
-Enables trainingOffEnables[] = {
+Enables trainingOffEnables[] = {
{ "menuMode.Edit Comment", True },
{ "menuMode.Pause", True },
{ "menuStep.Forward", True },
void SetICSMode()
{
SetMenuEnables(icsEnables);
+
+#ifdef ZIPPY
+ if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
+ XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
+#endif
}
void
* Find a font that matches "pattern" that is as close as
* possible to the targetPxlSize. Prefer fonts that are k
* pixels smaller to fonts that are k pixels larger. The
- * pattern must be in the X Consortium standard format,
+ * pattern must be in the X Consortium standard format,
* e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
* The return value should be freed with XtFree when no
* longer needed.
strcat(base_fnt_lst, strInt);
strcat(base_fnt_lst, strchr(p + 2, '-'));
- if ((fntSet = XCreateFontSet(xDisplay,
- base_fnt_lst,
- &missing_list,
- &missing_count,
+ if ((fntSet = XCreateFontSet(xDisplay,
+ base_fnt_lst,
+ &missing_list,
+ &missing_count,
&def_string)) == NULL) {
- fprintf(stderr, _("Unable to create font set.\n"));
- exit (2);
+ fprintf(stderr, _("Unable to create font set.\n"));
+ exit (2);
}
nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
}
#ifdef ENABLE_NLS
if (missing_count > 0)
- XFreeStringList(missing_list);
+ XFreeStringList(missing_list);
XFreeFontSet(xDisplay, fntSet);
#else
- XFreeFontNames(fonts);
+ XFreeFontNames(fonts);
#endif
return p;
}
| 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 = XBlackPixel(xDisplay, xScreen);
lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = XBlackPixel(xDisplay, xScreen);
gc_values.background = XWhitePixel(xDisplay, xScreen);
coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
XSetFont(xDisplay, coordGC, coordFontID);
-
+
+ // [HGM] make font for holdings counts (white on black0
+ gc_values.foreground = XWhitePixel(xDisplay, xScreen);
+ gc_values.background = XBlackPixel(xDisplay, xScreen);
+ countGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ XSetFont(xDisplay, countGC, countFontID);
+
if (appData.monoMode) {
gc_values.foreground = XWhitePixel(xDisplay, xScreen);
gc_values.background = XWhitePixel(xDisplay, xScreen);
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = XWhitePixel(xDisplay, xScreen);
gc_values.background = XBlackPixel(xDisplay, xScreen);
- lightSquareGC = wbPieceGC
+ lightSquareGC = wbPieceGC
= XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = XBlackPixel(xDisplay, xScreen);
} else {
gc_values.foreground = highlightSquareColor;
gc_values.background = highlightSquareColor;
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = premoveHighlightColor;
gc_values.background = premoveHighlightColor;
- prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
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 = 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);
fprintf(stderr, _("%s: error loading XIM!\n"), programName);
exit(1);
}
-
+
w = fgetc(fp);
h = fgetc(fp);
-
+
for (y=0; y<h; ++y) {
for (x=0; x<h; ++x) {
p = fgetc(fp);
switch (p) {
- case 0:
- XPutPixel(xim, x, y, blackPieceColor);
+ case 0:
+ XPutPixel(xim, x, y, blackPieceColor);
if (xmask)
XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
break;
- case 1:
- XPutPixel(xim, x, y, darkSquareColor);
+ case 1:
+ XPutPixel(xim, x, y, darkSquareColor);
if (xmask)
XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
break;
- case 2:
- XPutPixel(xim, x, y, whitePieceColor);
+ case 2:
+ XPutPixel(xim, x, y, whitePieceColor);
if (xmask)
XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
break;
- case 3:
+ case 3:
XPutPixel(xim, x, y, lightSquareColor);
if (xmask)
XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
*dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
w, h, xim->depth);
XPutImage(xDisplay, *dest, lightSquareGC, xim,
- 0, 0, 0, 0, w, h);
+ 0, 0, 0, 0, w, h);
- /* create Pixmap of clipmask
+ /* create Pixmap of clipmask
Note: We assume the white/black pieces have the same
outline, so we make only 6 masks. This is okay
since the XPM clipmask routines do the same. */
temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
w, h, xim->depth);
XPutImage(xDisplay, temp, lightSquareGC, xmask,
- 0, 0, 0, 0, w, h);
+ 0, 0, 0, 0, w, h);
/* now create the 1-bit version */
*mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
values.background = 0;
/* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, *mask,
+ maskGC = XCreateGC(xDisplay, *mask,
GCForeground | GCBackground, &values);
- XCopyPlane(xDisplay, temp, *mask, maskGC,
+ XCopyPlane(xDisplay, temp, *mask, maskGC,
0, 0, squareSize, squareSize, 0, 0, 1);
XFreePixmap(xDisplay, temp);
}
}
+
+char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
+
void CreateXIMPieces()
{
int piece, kind;
Not sure if needed, but can't hurt */
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
-
+
/* temp needed by loadXIM() */
ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
}
fprintf(stderr, _("\nLoading XIMs...\n"));
/* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
fprintf(stderr, "%d", piece+1);
for (kind=0; kind<4; kind++) {
fprintf(stderr, ".");
- sprintf(buf, "%s/%c%s%u.xim",
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
ExpandPathName(appData.pixmapDirectory),
- ToLower(PieceToChar((ChessSquare)piece)),
+ piece <= (int) WhiteKing ? "" : "w",
+ pieceBitmapNames[piece],
ximkind[kind], ss);
ximPieceBitmap[kind][piece] =
XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
if (appData.debugMode)
fprintf(stderr, _("(File:%s:) "), buf);
- loadXIM(ximPieceBitmap[kind][piece],
+ loadXIM(ximPieceBitmap[kind][piece],
ximtemp, buf,
- &(xpmPieceBitmap[kind][piece]),
- &(ximMaskPm[piece%6]));
+ &(xpmPieceBitmap2[kind][piece]),
+ &(ximMaskPm2[piece]));
+ if(piece <= (int)WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
}
fprintf(stderr," ");
}
/* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
+ /* If the LSQ and DSQ pieces don't exist, we will
draw them with solid squares. */
- sprintf(buf, "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
+ snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
if (access(buf, 0) != 0) {
useImageSqs = 0;
} else {
useImageSqs = 1;
fprintf(stderr, _("light square "));
- ximLightSquare=
+ ximLightSquare=
XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
if (appData.debugMode)
loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
fprintf(stderr, _("dark square "));
- sprintf(buf, "%s/dsq%u.xim",
+ snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
ExpandPathName(appData.pixmapDirectory), ss);
if (appData.debugMode)
fprintf(stderr, _("(File:%s:) "), buf);
- ximDarkSquare=
+ ximDarkSquare=
XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
#if 0
/* Apparently some versions of Xpm don't define XpmFormat at all --tpm */
if (appData.debugMode) {
- fprintf(stderr, "XPM Library Version: %d.%d%c\n",
+ fprintf(stderr, "XPM Library Version: %d.%d%c\n",
XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));
}
#endif
-
+
/* The XSynchronize calls were copied from CreatePieces.
Not sure if needed, but can't hurt */
XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
-
+
/* Setup translations so piece colors match square colors */
symbols[0].name = "light_piece";
symbols[0].value = appData.whitePieceColor;
fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
exit(1);
}
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
for (kind=0; kind<4; kind++) {
if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
pieces->xpm[piece][kind],
- &(xpmPieceBitmap[kind][piece]),
+ &(xpmPieceBitmap2[kind][piece]),
NULL, &attr)) != 0) {
fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
r, buf);
- exit(1);
- }
- }
+ exit(1);
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
}
useImageSqs = 0;
xpmJailSquare = xpmLightSquare;
} else {
useImages = 1;
-
+
fprintf(stderr, _("\nLoading XPMs...\n"));
/* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
fprintf(stderr, "%d ", piece+1);
for (kind=0; kind<4; kind++) {
- sprintf(buf, "%s/%c%s%u.xpm",
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
ExpandPathName(appData.pixmapDirectory),
- ToLower(PieceToChar((ChessSquare)piece)),
+ piece > (int) WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
xpmkind[kind], ss);
if (appData.debugMode) {
fprintf(stderr, _("(File:%s:) "), buf);
}
if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &(xpmPieceBitmap[kind][piece]),
+ &(xpmPieceBitmap2[kind][piece]),
NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
- r, buf);
- exit(1);
- }
- }
+ if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
+ // [HGM] missing: read of unorthodox piece failed; substitute King.
+ snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
+ ExpandPathName(appData.pixmapDirectory),
+ xpmkind[kind], ss);
+ if (appData.debugMode) {
+ fprintf(stderr, _("(Replace by File:%s:) "), buf);
+ }
+ r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &(xpmPieceBitmap2[kind][piece]),
+ NULL, &attr);
+ }
+ if (r != 0) {
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
+ r, buf);
+ exit(1);
+ }
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
}
/* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
+ /* If the LSQ and DSQ pieces don't exist, we will
draw them with solid squares. */
fprintf(stderr, _("light square "));
- sprintf(buf, "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
+ snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
if (access(buf, 0) != 0) {
useImageSqs = 0;
} else {
exit(1);
}
fprintf(stderr, _("dark square "));
- sprintf(buf, "%s/dsq%u.xpm",
+ snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
ExpandPathName(appData.pixmapDirectory), ss);
if (appData.debugMode) {
fprintf(stderr, _("(File:%s:) "), buf);
fprintf(stderr, _("Done.\n"));
}
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
+ buffering bug */
}
#endif /* HAVE_LIBXPM */
int piece, kind;
char buf[MSG_SIZ];
u_int ss = squareSize;
-
+
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);
+ ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
-
+
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
buffering bug */
}
int piece, kind;
char buf[MSG_SIZ];
u_int ss = squareSize;
-
+
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
while (bib->squareSize != ss && bib->squareSize != 0) bib++;
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap[kind][piece], buf,
+ ReadBitmap(&pieceBitmap2[kind][piece], buf,
bib->bits[kind][piece], ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
-
+
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
buffering bug */
}
u_int w, h;
int errcode;
char msg[MSG_SIZ], fullname[MSG_SIZ];
-
+
if (*appData.bitmapDirectory != NULLCHAR) {
strcpy(fullname, appData.bitmapDirectory);
strcat(fullname, "/");
strcat(fullname, name);
errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
&w, &h, pm, &x_hot, &y_hot);
+ fprintf(stderr, "load %s\n", name);
if (errcode != BitmapSuccess) {
switch (errcode) {
case BitmapOpenFailed:
- sprintf(msg, _("Can't open bitmap file %s"), fullname);
+ snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
break;
case BitmapFileInvalid:
- sprintf(msg, _("Invalid bitmap in file %s"), fullname);
+ snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
break;
case BitmapNoMemory:
- sprintf(msg, _("Ran out of memory reading bitmap file %s"),
+ snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
fullname);
break;
default:
- sprintf(msg, _("Unknown XReadBitmapFile error %d on file %s"),
+ snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
errcode, fullname);
break;
}
}
}
if (bits == NULL) {
+#if 0
fprintf(stderr, _("%s: No built-in bitmap for %s; giving up\n"),
programName, name);
exit(1);
+#endif
+ ; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
} else {
*pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
wreq, hreq);
void CreateGrid()
{
- int i;
-
+ int i, j;
+
if (lineGap == 0) return;
- for (i = 0; i < BOARD_SIZE + 1; i++) {
- gridSegments[i].x1 = 0;
- gridSegments[i].x2 =
- lineGap + BOARD_SIZE * (squareSize + lineGap);
- gridSegments[i].y1 = gridSegments[i].y2
- = lineGap / 2 + (i * (squareSize + lineGap));
- gridSegments[i + BOARD_SIZE + 1].y1 = 0;
- gridSegments[i + BOARD_SIZE + 1].y2 =
- BOARD_SIZE * (squareSize + lineGap);
- gridSegments[i + BOARD_SIZE + 1].x1 =
- gridSegments[i + BOARD_SIZE + 1].x2
- = lineGap / 2 + (i * (squareSize + lineGap));
+ /* [HR] Split this into 2 loops for non-square boards. */
+
+ for (i = 0; i < BOARD_HEIGHT + 1; i++) {
+ gridSegments[i].x1 = 0;
+ gridSegments[i].x2 =
+ lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ gridSegments[i].y1 = gridSegments[i].y2
+ = lineGap / 2 + (i * (squareSize + lineGap));
+ }
+
+ for (j = 0; j < BOARD_WIDTH + 1; j++) {
+ gridSegments[j + i].y1 = 0;
+ gridSegments[j + i].y2 =
+ lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ gridSegments[j + i].x1 = gridSegments[j + i].x2
+ = lineGap / 2 + (j * (squareSize + lineGap));
}
}
entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
menu, args, j);
} else {
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
+ XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
menu, args, j+1);
XtAddCallback(entry, XtNcallback,
}
mi++;
}
-}
+}
Widget CreateMenuBar(mb)
Menu *mb;
XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;
if (tinyLayout) {
char shortName[2];
- shortName[0] = _(mb->name)[0];
+ shortName[0] = _(mb->name)[0];
shortName[1] = NULLCHAR;
XtSetArg(args[j], XtNlabel, XtNewString(shortName)); j++;
}
- else {
- XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name))); j++;
- }
+ else {
+ XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name))); j++;
+ }
XtSetArg(args[j], XtNborderWidth, 0); j++;
anchor = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,
XtSetArg(args[j], XtNinternalWidth, 2); j++;
XtSetArg(args[j], XtNborderWidth, 0); j++;
}
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
+ XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
button = XtCreateManagedWidget(mi->string, commandWidgetClass,
buttonBar, args, j);
XtAddCallback(button, XtNcallback,
mi++;
}
return buttonBar;
-}
+}
Widget
CreatePieceMenu(name, color)
menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
boardWidget, args, 0);
-
+
for (i = 0; i < PIECE_MENU_SIZE; i++) {
String item = pieceMenuStrings[color][i];
-
+
if (strcmp(item, "----") == 0) {
entry = XtCreateManagedWidget(item, smeLineObjectClass,
menu, NULL, 0);
} else {
- XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
+ XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- menu, args, 1);
+ menu, args, 1);
selection = pieceMenuTranslation[color][i];
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) PieceMenuSelect,
whitePieceMenu = CreatePieceMenu("menuW", 0);
blackPieceMenu = CreatePieceMenu("menuB", 1);
-
+
XtRegisterGrabAction(PieceMenuPopup, True,
(unsigned)(ButtonPressMask|ButtonReleaseMask),
GrabModeAsync, GrabModeAsync);
boardWidget, args, 1);
for (i = 0; i < DROP_MENU_SIZE; i++) {
String item = dropMenuStrings[i];
-
+
if (strcmp(item, "----") == 0) {
entry = XtCreateManagedWidget(item, smeLineObjectClass,
dropMenu, NULL, 0);
} else {
- XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
+ XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- dropMenu, args, 1);
+ dropMenu, args, 1);
selection = dropMenuTranslation[i];
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) DropMenuSelect,
(caddr_t) selection);
}
}
-}
+}
void SetupDropMenu()
{
&& !appData.icsActive));
count = 0;
while (p && *p++ == dmEnables[i].piece) count++;
- sprintf(label, "%s %d", dmEnables[i].widget, count);
+ snprintf(label, sizeof(label), "%s %d", dmEnables[i].widget, count);
j = 0;
XtSetArg(args[j], XtNlabel, label); j++;
XtSetValues(entry, args, j);
default:
return;
}
-
- if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_SIZE)) < 0) ||
- ((pmFromY = EventToSquare(event->xbutton.y, BOARD_SIZE)) < 0)) {
+
+ if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_WIDTH)) < 0) ||
+ ((pmFromY = EventToSquare(event->xbutton.y, BOARD_HEIGHT)) < 0)) {
pmFromX = pmFromY = -1;
return;
}
if (flipView)
- pmFromX = BOARD_SIZE - 1 - pmFromX;
+ pmFromX = BOARD_WIDTH - 1 - pmFromX;
else
- pmFromY = BOARD_SIZE - 1 - pmFromY;
-
+ pmFromY = BOARD_HEIGHT - 1 - pmFromY;
+
XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
}
int EventToSquare(x, limit)
int x;
{
- if (x <= 0)
+ if (x <= 0)
return -2;
if (x < lineGap)
return -1;
int x, y;
if (lineGap == 0 || appData.blindfold) return;
-
+
if (flipView) {
- x = lineGap/2 + ((BOARD_SIZE-1)-file) *
+ x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
(squareSize + lineGap);
y = lineGap/2 + rank * (squareSize + lineGap);
} else {
x = lineGap/2 + file * (squareSize + lineGap);
- y = lineGap/2 + ((BOARD_SIZE-1)-rank) *
+ y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
(squareSize + lineGap);
}
-
+
XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
squareSize+lineGap, squareSize+lineGap);
}
int square_color, x, y;
Drawable dest;
{
+ if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
switch (square_color) {
case 1: /* light */
XCopyPlane(xDisplay, *pieceToSolid(piece),
}
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
+ squareSize, squareSize, x, y);
}
typedef void (*DrawFunc)();
}
}
+/* [HR] determine square color depending on chess variant. */
+static int SquareColor(row, column)
+ int row, column;
+{
+ int square_color;
+
+ if (gameInfo.variant == VariantXiangqi) {
+ if (column >= 3 && column <= 5 && row >= 0 && row <= 2) {
+ square_color = 1;
+ } else if (column >= 3 && column <= 5 && row >= 7 && row <= 9) {
+ square_color = 0;
+ } else if (row <= 4) {
+ square_color = 0;
+ } else {
+ square_color = 1;
+ }
+ } else {
+ square_color = ((column + row) % 2) == 1;
+ }
+
+ /* [hgm] holdings: next line makes all holdings squares light */
+ if(column < BOARD_LEFT || column >= BOARD_RGHT) square_color = 1;
+
+ return square_color;
+}
+
void DrawSquare(row, column, piece, do_flash)
int row, column, do_flash;
ChessSquare piece;
/* Calculate delay in milliseconds (2-delays per complete flash) */
flash_delay = 500 / appData.flashRate;
-
+
if (flipView) {
- x = lineGap + ((BOARD_SIZE-1)-column) *
+ x = lineGap + ((BOARD_WIDTH-1)-column) *
(squareSize + lineGap);
y = lineGap + row * (squareSize + lineGap);
} else {
x = lineGap + column * (squareSize + lineGap);
- y = lineGap + ((BOARD_SIZE-1)-row) *
+ y = lineGap + ((BOARD_HEIGHT-1)-row) *
(squareSize + lineGap);
}
-
- square_color = ((column + row) % 2) == 1;
-
- if (piece == EmptySquare || appData.blindfold) {
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- } else {
- drawfunc = ChooseDrawFunc();
- if (do_flash && appData.flashCount > 0) {
- for (i=0; i<appData.flashCount; ++i) {
-
- drawfunc(piece, square_color, x, y, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
- }
+ square_color = SquareColor(row, column);
+
+ if ( // [HGM] holdings: blank out area between board and holdings
+ column == BOARD_LEFT-1 || column == BOARD_RGHT
+ || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
+ || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
+ BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
+
+ // [HGM] print piece counts next to holdings
+ string[1] = NULLCHAR;
+ if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
+ string[0] = '0' + piece;
+ XTextExtents(countFontStruct, string, 1, &direction,
+ &font_ascent, &font_descent, &overall);
+ if (appData.monoMode) {
+ XDrawImageString(xDisplay, xBoardWindow, countGC,
+ x + squareSize - overall.width - 2,
+ y + font_ascent + 1, string, 1);
+ } else {
+ XDrawString(xDisplay, xBoardWindow, countGC,
+ x + squareSize - overall.width - 2,
+ y + font_ascent + 1, string, 1);
+ }
+ }
+ if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
+ string[0] = '0' + piece;
+ XTextExtents(countFontStruct, string, 1, &direction,
+ &font_ascent, &font_descent, &overall);
+ if (appData.monoMode) {
+ XDrawImageString(xDisplay, xBoardWindow, countGC,
+ x + 2, y + font_ascent + 1, string, 1);
+ } else {
+ XDrawString(xDisplay, xBoardWindow, countGC,
+ x + 2, y + font_ascent + 1, string, 1);
+ }
+ }
+ } else {
+ if (piece == EmptySquare || appData.blindfold) {
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ } else {
+ drawfunc = ChooseDrawFunc();
+ if (do_flash && appData.flashCount > 0) {
+ for (i=0; i<appData.flashCount; ++i) {
+
+ drawfunc(piece, square_color, x, y, xBoardWindow);
+ XSync(xDisplay, False);
+ do_flash_delay(flash_delay);
+
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ XSync(xDisplay, False);
+ do_flash_delay(flash_delay);
+ }
+ }
+ drawfunc(piece, square_color, x, y, xBoardWindow);
+ }
}
- drawfunc(piece, square_color, x, y, xBoardWindow);
- }
-
+
string[1] = NULLCHAR;
- if (appData.showCoords && row == (flipView ? 7 : 0)) {
- string[0] = 'a' + column;
- XTextExtents(coordFontStruct, string, 1, &direction,
+ if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
+ && column >= BOARD_LEFT && column < BOARD_RGHT) {
+ string[0] = 'a' + column - BOARD_LEFT;
+ XTextExtents(coordFontStruct, string, 1, &direction,
&font_ascent, &font_descent, &overall);
if (appData.monoMode) {
XDrawImageString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
+ x + squareSize - overall.width - 2,
y + squareSize - font_descent - 1, string, 1);
} else {
XDrawString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
+ x + squareSize - overall.width - 2,
y + squareSize - font_descent - 1, string, 1);
}
}
- if (appData.showCoords && column == (flipView ? 7 : 0)) {
- string[0] = '1' + row;
- XTextExtents(coordFontStruct, string, 1, &direction,
+ if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
+ string[0] = ONE + row;
+ XTextExtents(coordFontStruct, string, 1, &direction,
&font_ascent, &font_descent, &overall);
if (appData.monoMode) {
XDrawImageString(xDisplay, xBoardWindow, coordGC,
} else {
XDrawString(xDisplay, xBoardWindow, coordGC,
x + 2, y + font_ascent + 1, string, 1);
- }
- }
+ }
+ }
}
{
int i, j;
int c = 0;
-
- for (i=0; i<BOARD_SIZE; ++i) {
- for (j=0; j<BOARD_SIZE; ++j) {
+
+ for (i=0; i<BOARD_HEIGHT; ++i) {
+ for (j=0; j<BOARD_WIDTH; ++j) {
if (b1[i][j] != b2[i][j]) {
if (++c > 4) /* Castling causes 4 diffs */
return 1;
/* Checks whether castling occurred. If it did, *rrow and *rcol
are set to the destination (row,col) of the rook that moved.
-
+
Returns 1 if castling occurred, 0 if not.
-
+
Note: Only handles a max of 1 castling move, so be sure
to call too_many_diffs() first.
*/
static Board lastBoard;
Arg args[16];
int rrow, rcol;
-
+
if (board == NULL) {
if (!lastBoardValid) return;
board = lastBoard;
* It would be simpler to clear the window with XClearWindow()
* but this causes a very distracting flicker.
*/
-
+
if (!repaint && lastBoardValid && lastFlipView == flipView) {
/* If too much changes (begin observing new game, etc.), don't
}
}
- /* First pass -- Draw (newly) empty squares and repair damage.
- This prevents you from having a piece show up twice while it
+ /* First pass -- Draw (newly) empty squares and repair damage.
+ This prevents you from having a piece show up twice while it
is flashing on its new square */
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++)
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
|| damage[i][j]) {
DrawSquare(i, j, board[i][j], 0);
}
/* Second pass -- Draw piece(s) in new position and flash them */
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++)
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
if (board[i][j] != lastBoard[i][j]) {
- DrawSquare(i, j, board[i][j], do_flash);
+ DrawSquare(i, j, board[i][j], do_flash);
}
} else {
if (lineGap > 0)
XDrawSegments(xDisplay, xBoardWindow, lineGC,
- gridSegments, (BOARD_SIZE + 1) * 2);
-
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++) {
+ gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
+
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++) {
DrawSquare(i, j, board[i][j], 0);
damage[i][j] = False;
}
/*
* 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;
int x, y;
Boolean saveAnimate;
static int second = 0;
-
+
if (w != boardWidget || errorExitStatus != -1) return;
if (event->type == ButtonPress) ErrorPopDown();
return;
}
}
-
- x = EventToSquare(event->xbutton.x, BOARD_SIZE);
- y = EventToSquare(event->xbutton.y, BOARD_SIZE);
+
+ x = EventToSquare(event->xbutton.x, BOARD_WIDTH);
+ y = EventToSquare(event->xbutton.y, BOARD_HEIGHT);
if (!flipView && y >= 0) {
- y = BOARD_SIZE - 1 - y;
+ y = BOARD_HEIGHT - 1 - y;
}
if (flipView && x >= 0) {
- x = BOARD_SIZE - 1 - x;
+ x = BOARD_WIDTH - 1 - x;
}
+ /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
+ if(event->type == ButtonPress
+ && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
+ || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
+ || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
+ return;
+
if (fromX == -1) {
if (event->type == ButtonPress) {
- /* First square */
+ /* First square */
if (OKToStartUserMove(x, y)) {
fromX = x;
fromY = y;
if (appData.highlightDragging) {
SetHighlights(x, y, -1, -1);
}
- }
+ }
}
return;
}
x >= 0 && y >= 0) {
ChessSquare fromP;
ChessSquare toP;
+ int frc;
+
/* Check if clicking again on the same color piece */
fromP = boards[currentMove][fromY][fromX];
toP = boards[currentMove][y][x];
- if ((WhitePawn <= fromP && fromP <= WhiteKing &&
- WhitePawn <= toP && toP <= WhiteKing) ||
- (BlackPawn <= fromP && fromP <= BlackKing &&
- BlackPawn <= toP && toP <= BlackKing)) {
+ frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
+ if ((WhitePawn <= fromP && fromP <= WhiteKing && // [HGM] this test should go, as UserMoveTest now does it.
+ WhitePawn <= toP && toP <= WhiteKing &&
+ !(fromP == WhiteKing && toP == WhiteRook && frc)) ||
+ (BlackPawn <= fromP && fromP <= BlackKing &&
+ BlackPawn <= toP && toP <= BlackKing &&
+ !(fromP == BlackKing && toP == BlackRook && frc))) {
/* Clicked again on same color piece -- changed his mind */
second = (x == fromX && y == fromY);
if (appData.highlightDragging) {
SetHighlights(x, y, -1, -1);
}
return;
- }
+ }
/* Completed move */
toX = x;
if (editShell == NULL) {
editShell =
- CommentCreate(title, text, True, EditCommentCallback, 4);
+ CommentCreate(title, text, True, EditCommentCallback, 4);
XtRealizeWidget(editShell);
CatchDeleteWindow(editShell, "EditCommentPopDown");
} else {
int j;
char *title = _("ICS Input");
XtTranslations tr;
-
+
if (ICSInputShell == NULL) {
ICSInputShell = MiscCreate(title, "", True, NULL, 1);
tr = XtParseTranslationTable(ICSInputTranslations);
XtOverrideTranslations(edit, tr);
XtRealizeWidget(ICSInputShell);
CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
-
+
} else {
edit = XtNameToWidget(ICSInputShell, "*form.text");
j = 0;
int j;
Arg args[16];
String val;
-
+
edit = XtNameToWidget(ICSInputShell, "*form.text");
j = 0;
XtSetArg(args[j], XtNstring, &val); j++;
XtPopdown(analysisShell);
XSync(xDisplay, False);
analysisUp = False;
+ if (appData.icsEngineAnalyze) ExitAnalyzeMode(); /* [DM] icsEngineAnalyze */
}
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++;
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++;
XawDialogAddButton(dialog, _("ok"), FileNameCallback, (XtPointer) dialog);
XawDialogAddButton(dialog, _("cancel"), FileNameCallback,
- (XtPointer) dialog);
+ (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);
}
{
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);
}
int index;
name = XawDialogGetValueString(w = XtParent(w));
-
+
if ((name != NULL) && (*name != NULLCHAR)) {
strcpy(buf, name);
XtPopdown(w = XtParent(XtParent(w)));
ModeHighlight();
return;
}
-
+
XtPopdown(w = XtParent(XtParent(w)));
XtDestroyWidget(w);
filenameUp = False;
j = 0;
XtSetArg(args[j], XtNwidth, &bw_width); j++;
XtGetValues(boardWidget, args, j);
-
+
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
layoutArgs, XtNumber(layoutArgs));
-
+
j = 0;
- XtSetArg(args[j], XtNlabel, _("Promote pawn to what?")); j++;
+ XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
XtSetArg(args[j], XtNborderWidth, 0); j++;
dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
layout, args, j);
-
- XawDialogAddButton(dialog, _("Queen"), PromotionCallback,
+
+ if(gameInfo.variant != VariantShogi) {
+ XawDialogAddButton(dialog, _("Queen"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, _("Rook"), PromotionCallback,
+ XawDialogAddButton(dialog, _("Rook"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, _("Bishop"), PromotionCallback,
+ XawDialogAddButton(dialog, _("Bishop"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, _("Knight"), PromotionCallback,
+ XawDialogAddButton(dialog, _("Knight"), PromotionCallback,
(XtPointer) dialog);
if (!appData.testLegality || gameInfo.variant == VariantSuicide ||
gameInfo.variant == VariantGiveaway) {
- XawDialogAddButton(dialog, _("King"), PromotionCallback,
+ XawDialogAddButton(dialog, _("King"), PromotionCallback,
+ (XtPointer) dialog);
+ }
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
+ gameInfo.variant == VariantCapaRandom) {
+ XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
+ (XtPointer) dialog);
+ XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback,
(XtPointer) dialog);
}
- XawDialogAddButton(dialog, _("cancel"), PromotionCallback,
+ } else // [HGM] shogi
+ {
+ XawDialogAddButton(dialog, _("Promote"), PromotionCallback,
+ (XtPointer) dialog);
+ XawDialogAddButton(dialog, _("Defer"), PromotionCallback,
+ (XtPointer) dialog);
+ }
+ XawDialogAddButton(dialog, _("cancel"), PromotionCallback,
(XtPointer) dialog);
-
+
XtRealizeWidget(promotionShell);
CatchDeleteWindow(promotionShell, "PromotionPopDown");
-
+
j = 0;
XtSetArg(args[j], XtNwidth, &pw_width); j++;
XtGetValues(promotionShell, args, j);
-
+
XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
lineGap + squareSize/3 +
- ((toY == 7) ^ (flipView) ?
+ ((toY == BOARD_HEIGHT-1) ^ (flipView) ?
0 : 6*(squareSize + lineGap)), &x, &y);
-
+
j = 0;
XtSetArg(args[j], XtNx, x); j++;
XtSetArg(args[j], XtNy, y); j++;
XtSetValues(promotionShell, args, j);
-
+
XtPopup(promotionShell, XtGrabNone);
-
+
promotionUp = True;
}
String name;
Arg args[16];
int promoChar;
-
+
XtSetArg(args[0], XtNlabel, &name);
XtGetValues(w, args, 1);
-
+
PromotionPopDown();
-
+
if (fromX == -1) return;
-
+
if (strcmp(name, _("cancel")) == 0) {
fromX = fromY = -1;
ClearHighlights();
return;
} else if (strcmp(name, _("Knight")) == 0) {
promoChar = 'n';
+ } else if (strcmp(name, _("Promote")) == 0) {
+ promoChar = '+';
+ } else if (strcmp(name, _("Defer")) == 0) {
+ promoChar = '=';
} else {
promoChar = ToLower(name[0]);
}
Dimension bw_width, pw_width;
Dimension pw_height;
int i;
-
+
i = 0;
XtSetArg(args[i], XtNresizable, True); i++;
XtSetArg(args[i], XtNtitle, title); i++;
- errorShell =
+ errorShell =
XtCreatePopupShell("errorpopup", transientShellWidgetClass,
shellWidget, args, i);
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
layoutArgs, XtNumber(layoutArgs));
-
+
i = 0;
XtSetArg(args[i], XtNlabel, label); i++;
XtSetArg(args[i], XtNborderWidth, 0); i++;
dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
layout, args, i);
-
+
XawDialogAddButton(dialog, _("ok"), ErrorCallback, (XtPointer) dialog);
-
+
XtRealizeWidget(errorShell);
CatchDeleteWindow(errorShell, "ErrorPopDown");
-
+
i = 0;
XtSetArg(args[i], XtNwidth, &bw_width); i++;
XtGetValues(boardWidget, args, i);
case EndOfGame:
return NULL;
}
-}
+}
void ModeHighlight()
{
static int oldPausing = FALSE;
static GameMode oldmode = (GameMode) -1;
char *wname;
-
+
if (!boardWidget || !XtIsRealized(boardWidget)) return;
if (pausing != oldPausing) {
return True;
} else {
return False;
- }
+ }
}
/* note: when called from menu all parameters are NULL, so no clue what the
int ret;
if (selected_fen_position) free(selected_fen_position);
- selected_fen_position = (char *)PositionToFEN(currentMove);
+ selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
if (!selected_fen_position) return;
ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
CurrentTime,
return True;
} else {
return False;
- }
+ }
}
/* note: when called from menu all parameters are NULL, so no clue what the
String *prms;
Cardinal *nprms;
{
+ char buf[MSG_SIZ];
+
if (!first.analysisSupport) {
- char buf[MSG_SIZ];
- sprintf(buf, _("%s does not support analysis"), first.tidy);
+ 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(w,event,prms,nprms);
{
if (!first.analysisSupport) {
char buf[MSG_SIZ];
- sprintf(buf, _("%s does not support analysis"), first.tidy);
+ snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
DisplayError(buf, 0);
return;
}
ResignEvent();
}
+void AdjuWhiteProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(+1);
+}
+
+void AdjuBlackProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(-1);
+}
+
+void AdjuDrawProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(0);
+}
+
void EnterKeyProc(w, event, prms, nprms)
Widget w;
XEvent *event;
Arg args[16];
PeriodicUpdatesEvent(!appData.periodicUpdates);
-
+
if (appData.periodicUpdates) {
XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
} else {
{
Arg args[16];
- ShowThinkingEvent(!appData.showThinking);
-
+ appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
+ ShowThinkingEvent();
+#if 0
+ // [HGM] thinking: currently no suc menu item; replaced by Hide Thinking (From Human)
if (appData.showThinking) {
XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
} else {
}
XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
args, 1);
+#endif
+}
+
+void HideThinkingProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ Arg args[16];
+
+ appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
+ ShowThinkingEvent();
+
+ if (appData.hideThinkingFromHuman) {
+ XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ } else {
+ XtSetArg(args[0], XtNleftBitmap, None);
+ }
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
+ args, 1);
}
void InfoProc(w, event, prms, nprms)
Cardinal *nprms;
{
char buf[MSG_SIZ];
- sprintf(buf, "xterm -e info --directory %s --directory . -f %s &",
+ snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
INFODIR, INFOFILE);
system(buf);
}
name = prms[0];
else
name = "xboard";
- sprintf(buf, "xterm -e man %s &", name);
+ snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
system(buf);
}
#else
char *zippy = "";
#endif
- sprintf(buf, "%s%s\n\n%s\n%s\n\n%s%s\n%s",
+ snprintf(buf, sizeof(buf), "%s%s\n\n%s\n%s\n%s\n\n%s%s\n%s",
programVersion, zippy,
"Copyright 1991 Digital Equipment Corporation",
- "Enhancements Copyright 1992-2001 Free Software Foundation",
- PRODUCT, " is free software and carries NO WARRANTY;",
+ "Enhancements Copyright 1992-2009 Free Software Foundation",
+ "Enhancements Copyright 2005 Alessandro Scotti",
+ PACKAGE, " is free software and carries NO WARRANTY;",
"see the file COPYING for more information.");
ErrorPopUp(_("About XBoard"), buf, FALSE);
}
Cardinal *nprms;
{
Arg args[16];
-
+
fromX = fromY = -1;
XtSetArg(args[0], XtNiconic, True);
XtSetValues(shellWidget, args, 1);
{
char buf[MSG_SIZ];
Arg arg;
-
+
if (extMessage) {
if (*message) {
- sprintf(buf, "%s %s", message, extMessage);
+ snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
message = buf;
} else {
message = extMessage;
strcpy(icon, text);
strcpy(title, text);
} else if (appData.icsActive) {
- sprintf(icon, "%s", appData.icsHost);
- sprintf(title, "%s: %s", programName, appData.icsHost);
+ snprintf(icon, sizeof(icon), "%s", appData.icsHost);
+ snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
} else if (appData.cmailGameName[0] != NULLCHAR) {
- sprintf(icon, "%s", "CMail");
- sprintf(title, "%s: %s", programName, "CMail");
+ snprintf(icon, sizeof(icon), "%s", "CMail");
+ snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
+#ifdef GOTHIC
+ // [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
+ } else if (gameInfo.variant == VariantGothic) {
+ strcpy(icon, programName);
+ strcpy(title, GOTHIC);
+#endif
+#ifdef FALCON
+ } else if (gameInfo.variant == VariantFalcon) {
+ strcpy(icon, programName);
+ strcpy(title, FALCON);
+#endif
} else if (appData.noChessProgram) {
strcpy(icon, programName);
strcpy(title, programName);
} else {
strcpy(icon, first.tidy);
- sprintf(title, "%s: %s", programName, first.tidy);
+ snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
}
i = 0;
XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
fprintf(stderr, "%s: %s: %s\n",
programName, message, strerror(error));
}
- sprintf(buf, "%s: %s", message, strerror(error));
+ snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
message = buf;
- }
+ }
ErrorPopUp(_("Error"), message, FALSE);
}
} else {
fprintf(stderr, "%s: %s: %s\n",
programName, message, strerror(error));
- sprintf(buf, "%s: %s", message, strerror(error));
+ snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
message = buf;
}
if (appData.popupExitMessage && boardWidget && XtIsRealized(boardWidget)) {
XSetErrorHandler(oldHandler);
}
if (oldICSInteractionTitle == NULL) {
- oldICSInteractionTitle = "xterm";
+ oldICSInteractionTitle = "xterm";
}
- }
+ }
printf("\033]0;%s\007", message);
fflush(stdout);
}
XtSetArg(args[0], XtNlabel, &name);
XtGetValues(w, args, 1);
-
+
if (strcmp(name, _("cancel")) == 0) {
AskQuestionPopDown();
} else {
int x, y, i;
int win_x, win_y;
unsigned int mask;
-
+
strcpy(pendingReplyPrefix, replyPrefix);
pendingReplyPR = 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));
-
+
i = 0;
XtSetArg(args[i], XtNlabel, question); i++;
XtSetArg(args[i], XtNvalue, ""); i++;
XtSetArg(args[i], XtNborderWidth, 0); i++;
dialog = XtCreateManagedWidget("question", dialogWidgetClass,
layout, args, i);
-
+
XawDialogAddButton(dialog, _("enter"), AskQuestionCallback,
(XtPointer) dialog);
XawDialogAddButton(dialog, _("cancel"), AskQuestionCallback,
XtRealizeWidget(popup);
CatchDeleteWindow(popup, "AskQuestionPopDown");
-
+
XQueryPointer(xDisplay, xBoardWindow, &root, &child,
&x, &y, &win_x, &win_y, &mask);
-
+
XtSetArg(args[0], XtNx, x - 10);
XtSetArg(args[1], XtNy, y - 30);
XtSetValues(popup, args, 2);
-
+
XtPopup(popup, XtGrabExclusive);
askQuestionUp = True;
-
+
edit = XtNameToWidget(dialog, "*value");
XtSetKeyboardFocus(popup, edit);
}
putc(BELLCHAR, stderr);
} else {
char buf[2048];
- sprintf(buf, "%s '%s' &", appData.soundProgram, name);
+ snprintf(buf, sizeof(buf), "%s '%s' &", appData.soundProgram, name);
system(buf);
}
}
static char static_buf[2000];
char *d, *s, buf[2000];
struct passwd *pwd;
-
+
s = path;
d = static_buf;
strcpy(d, s);
return static_buf;
-}
+}
char *HostName()
{
static char host_name[MSG_SIZ];
-
+
#if HAVE_GETHOSTNAME
gethostname(host_name, MSG_SIZ);
return host_name;
ScheduleDelayedEvent(cb, millisec)
DelayedEventCallback cb; long millisec;
{
+ if(delayedEventTimerXID && delayedEventCallback == cb)
+ // [HGM] alive: replace, rather than add or flush identical event
+ XtRemoveTimeOut(delayedEventTimerXID);
delayedEventCallback = cb;
delayedEventTimerXID =
XtAppAddTimeOut(appContext, millisec,
XtPointer arg;
XtIntervalId *id;
{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
+ if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
+ || appData.icsEngineAnalyze) { // [DM]
AnalysisPeriodicEvent(0);
StartAnalysisClock();
}
{
char buf[MSG_SIZ];
Arg args[16];
-
+
+ /* check for low time warning */
+ Pixel foregroundOrWarningColor = timerForegroundPixel;
+
+ if (timer > 0 &&
+ appData.lowTimeWarning &&
+ (timer / 1000) < appData.icsAlarmTime)
+ foregroundOrWarningColor = lowTimeWarningColor;
+
if (appData.clockMode) {
sprintf(buf, "%s: %s", color, TimeString(timer));
XtSetArg(args[0], XtNlabel, buf);
sprintf(buf, "%s ", color);
XtSetArg(args[0], XtNlabel, buf);
}
-
+
if (highlight) {
- XtSetArg(args[1], XtNbackground, timerForegroundPixel);
+
+ XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
} else {
XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
- XtSetArg(args[2], XtNforeground, timerForegroundPixel);
+ XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
}
-
+
XtSetValues(w, args, 3);
}
int highlight;
{
Arg args[16];
+
+ if(appData.noGUI) return;
DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
if (highlight && iconPixmap == bIconPixmap) {
iconPixmap = wIconPixmap;
int highlight;
{
Arg args[16];
+
+ if(appData.noGUI) return;
DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
if (highlight && iconPixmap == wIconPixmap) {
iconPixmap = bIconPixmap;
typedef struct {
CPKind kind;
int pid;
- int fdTo, fdFrom;
+ int fdTo, fdFrom;
} ChildProc;
int StartChildProcess(cmdLine, dir, pr)
- char *cmdLine;
+ char *cmdLine;
char *dir;
ProcRef *pr;
{
int to_prog[2], from_prog[2];
ChildProc *cp;
char buf[MSG_SIZ];
-
+
if (appData.debugMode) {
fprintf(stderr, "StartChildProcess (dir=\"%s\") %s\n",dir, cmdLine);
}
if ((pid = fork()) == 0) {
/* Child process */
- dup2(to_prog[0], 0);
- dup2(from_prog[1], 1);
- close(to_prog[0]);
- close(to_prog[1]);
+ // [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
+ close(to_prog[1]); // first close the unused pipe ends
close(from_prog[0]);
- close(from_prog[1]);
- dup2(1, fileno(stderr)); /* force stderr to the pipe */
+ dup2(to_prog[0], 0); // to_prog was created first, nd is the only one to use 0 or 1
+ dup2(from_prog[1], 1);
+ if(to_prog[0] >= 2) close(to_prog[0]); // if 0 or 1, the dup2 already cosed the original
+ close(from_prog[1]); // and closing again loses one of the pipes!
+ if(fileno(stderr) >= 2) // better safe than sorry...
+ dup2(1, fileno(stderr)); /* force stderr to the pipe */
if (dir[0] != NULLCHAR && chdir(dir) != 0) {
perror(dir);
exit(1);
}
+ nice(appData.niceEngines); // [HGM] nice: adjust priority of engine proc
+
execvp(argv[0], argv);
-
+
/* If we get here, exec failed */
perror(argv[0]);
exit(1);
}
-
+
/* Parent process */
close(to_prog[0]);
close(from_prog[1]);
-
+
cp = (ChildProc *) calloc(1, sizeof(ChildProc));
cp->kind = CPReal;
cp->pid = pid;
return 0;
}
+// [HGM] kill: implement the 'hard killing' of AS's Winboard_x
+static RETSIGTYPE AlarmCallBack(int n)
+{
+ return;
+}
+
void
-DestroyChildProcess(pr, signal)
+DestroyChildProcess(pr, signalType)
ProcRef pr;
- int signal;
+ int signalType;
{
ChildProc *cp = (ChildProc *) pr;
if (cp->kind != CPReal) return;
cp->kind = CPNone;
- if (signal) {
- kill(cp->pid, SIGTERM);
+ if (signalType == 10) { // [HGM] kill: if it does not terminate in 3 sec, kill
+ signal(SIGALRM, AlarmCallBack);
+ alarm(3);
+ if(wait((int *) 0) == -1) { // process does not terminate on its own accord
+ kill(cp->pid, SIGKILL); // kill it forcefully
+ wait((int *) 0); // and wait again
+ }
+ } else {
+ if (signalType) {
+ kill(cp->pid, signalType == 9 ? SIGKILL : SIGTERM); // [HGM] kill: use hard kill if so requested
+ }
+ /* Process is exiting either because of the kill or because of
+ a quit command sent by the backend; either way, wait for it to die.
+ */
+ wait((int *) 0);
}
- /* Process is exiting either because of the kill or because of
- a quit command sent by the backend; either way, wait for it to die.
- */
- wait((int *) 0);
close(cp->fdFrom);
close(cp->fdTo);
}
char cmdLine[MSG_SIZ];
if (port[0] == NULLCHAR) {
- sprintf(cmdLine, "%s %s", appData.telnetProgram, host);
+ snprintf(cmdLine, sizeof(cmdLine), "%s %s", appData.telnetProgram, host);
} else {
- sprintf(cmdLine, "%s %s %s", appData.telnetProgram, host, port);
+ snprintf(cmdLine, sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
}
return StartChildProcess(cmdLine, "", pr);
}
sa.sin_port = htons(uport);
memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
- if (connect(s, (struct sockaddr *) &sa,
+ if (connect(s, (struct sockaddr *) &sa,
sizeof(struct sockaddr_in)) < 0) {
return errno;
}
{
DisplayFatalError(_("internal rcmd not implemented for Unix"), 0, 1);
return -1;
-}
+}
#define INPUT_SOURCE_BUF_SIZE 8192
} InputSource;
void
-DoInputCallback(closure, source, xid)
+DoInputCallback(closure, source, xid)
caddr_t closure;
int *source;
XtInputId *xid;
else
error = 0;
(is->func)(is, is->closure, is->buf, count, error);
- }
+ }
}
InputSourceRef AddInputSource(pr, lineByLine, func, closure)
if (lineByLine) {
is->unused = is->buf;
}
-
+
is->xid = XtAppAddInput(appContext, is->fd,
(XtPointer) (XtInputReadMask),
(XtInputCallbackProc) DoInputCallback,
ChildProc *cp = (ChildProc *) pr;
int outCount = 0;
int r;
-
+
while (count--) {
r = write(cp->fdTo, message++, 1);
if (r == -1) {
and dark squares, and all pieces must use the same
background square colors/images. */
+static int xpmDone = 0;
+
static void
CreateAnimMasks (pieceDepth)
int pieceDepth;
XFreePixmap(xDisplay, buf);
buf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, pieceDepth);
+ squareSize, squareSize, pieceDepth);
values.foreground = XBlackPixel(xDisplay, xScreen);
values.background = XWhitePixel(xDisplay, xScreen);
bufGC = XCreateGC(xDisplay, buf,
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);
-
+
/* Take a copy of the piece */
if (White(piece))
kind = 0;
else
kind = 2;
XSetFunction(xDisplay, bufGC, GXcopy);
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % 6],
+ 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)
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. */
{
XtGCMask mask;
XGCValues values;
-
+
/* Each buffer is square size, same depth as window */
anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
squareSize, squareSize, info->depth);
static void
CreateAnimVars ()
{
- static int done = 0;
+ static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
XWindowAttributes info;
- if (done) return;
- done = 1;
+ if (xpmDone && gameInfo.variant == old) return;
+ if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
XGetWindowAttributes(xDisplay, xBoardWindow, &info);
-
+
InitAnimState(&game, &info);
InitAnimState(&player, &info);
-
+
/* For XPM pieces, we need bitmaps to use as masks. */
if (useImages)
CreateAnimMasks(info.depth);
+ xpmDone = 1;
}
#ifndef HAVE_USLEEP
int time;
{
struct itimerval delay;
-
+
XSync(xDisplay, False);
if (time > 0) {
frameWaiting = True;
signal(SIGALRM, FrameAlarm);
- delay.it_interval.tv_sec =
+ delay.it_interval.tv_sec =
delay.it_value.tv_sec = time / 1000;
- delay.it_interval.tv_usec =
+ delay.it_interval.tv_usec =
delay.it_value.tv_usec = (time % 1000) * 1000;
setitimer(ITIMER_REAL, &delay, NULL);
#if 0
/* Ugh -- busy-wait! --tpm */
- while (frameWaiting);
+ while (frameWaiting);
#else
while (frameWaiting) pause();
#endif
int column; int row; XPoint * pt; int * color;
{
if (flipView) {
- pt->x = lineGap + ((BOARD_SIZE-1)-column) * (squareSize + lineGap);
+ pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
pt->y = lineGap + row * (squareSize + lineGap);
} else {
pt->x = lineGap + column * (squareSize + lineGap);
- pt->y = lineGap + ((BOARD_SIZE-1)-row) * (squareSize + lineGap);
+ pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
}
- *color = ((column + row) % 2) == 1;
+ *color = SquareColor(row, column);
}
/* Convert window coords to square */
BoardSquare(x, y, column, row)
int x; int y; int * column; int * row;
{
- *column = EventToSquare(x, BOARD_SIZE);
+ *column = EventToSquare(x, BOARD_WIDTH);
if (flipView && *column >= 0)
- *column = BOARD_SIZE - 1 - *column;
- *row = EventToSquare(y, BOARD_SIZE);
+ *column = BOARD_WIDTH - 1 - *column;
+ *row = EventToSquare(y, BOARD_HEIGHT);
if (!flipView && *row >= 0)
- *row = BOARD_SIZE - 1 - *row;
+ *row = BOARD_HEIGHT - 1 - *row;
}
/* Utilities */
/* Test if two frames overlap. If they do, return
intersection rect within old and location of
that rect within new. */
-
+
static Boolean
Intersect(old, new, size, area, pt)
XPoint * old; XPoint * new;
/* For two overlapping frames, return the rect(s)
in the old that do not intersect with the new. */
-
+
static void
CalcUpdateRects(old, new, size, update, nUpdates)
XPoint * old; XPoint * new; int size;
count ++;
fraction = fraction / 2;
}
-
+
/* Midpoint */
frames[count] = *mid;
count ++;
-
+
/* Slow out, stepping 1/2, then 1/4, ... */
fraction = 2;
for (n = 0; n < factor; n++) {
#if HAVE_LIBXPM
*mask = xpmMask[piece];
#else
- *mask = ximMaskPm[piece%6];
+ *mask = ximMaskPm[piece];
#endif
} else {
*mask = *pieceToSolid(piece);
source = blPieceGC;
}
XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
-
+
/* Outline only used in mono mode and is not modified */
if (White(piece))
*outline = bwPieceGC;
ChessSquare piece; GC clip; GC outline; Drawable dest;
{
int kind;
-
+
if (!useImages) {
/* Draw solid rectangle which will be clipped to shape of piece */
XFillRectangle(xDisplay, dest, clip,
kind = 0;
else
kind = 2;
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % 6],
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, clip,
0, 0, squareSize, squareSize,
- 0, 0);
+ 0, 0);
}
}
/* Animate the movement of a single piece */
-static void
+static void
BeginAnimation(anim, piece, startColor, start)
AnimState *anim;
ChessSquare piece;
XPoint * start;
{
Pixmap mask;
-
+
/* The old buffer is initialised with the start square (empty) */
BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
anim->prevFrame = *start;
-
+
/* The piece will be drawn using its own bitmap as a matte */
SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
XSetClipMask(xDisplay, anim->pieceGC, mask);
XRectangle overlap;
XPoint pt;
int count, i;
-
+
/* Save what we are about to draw into the new buffer */
XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
frame->x, frame->y, squareSize, squareSize,
0, 0);
-
+
/* Erase bits of the previous frame */
if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
/* Where the new frame overlapped the previous,
0, 0, squareSize, squareSize,
0, 0);
anim->prevFrame = *frame;
-
+
/* Draw piece over original screen contents, not current,
and copy entire rect. Wipes out overlapping piece images. */
OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);
if (!appData.animate || appData.blindfold)
return;
+ if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
+ board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
+ return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
+
if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
piece = board[fromY][fromX];
if (piece >= EmptySquare) return;
#endif
if (appData.debugMode) {
- printf(hop ? _("AnimateMove: piece %d hops from %d,%d to %d,%d \n") :
- _("AnimateMove: piece %d slides from %d,%d to %d,%d \n"),
- piece, fromX, fromY, toX, toY);
- }
+ fprintf(debugFP, hop ? _("AnimateMove: piece %d hops from %d,%d to %d,%d \n") :
+ _("AnimateMove: piece %d slides from %d,%d to %d,%d \n"),
+ piece, fromX, fromY, toX, toY); }
ScreenSquare(fromX, fromY, &start, &startColor);
ScreenSquare(toX, toY, &finish, &endColor);
mid.x = start.x + (finish.x - start.x) / 2;
mid.y = start.y + (finish.y - start.y) / 2;
}
-
+
/* Don't use as many frames for very short moves */
if (abs(toY - fromY) + abs(toX - fromX) <= 2)
Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
else
Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
-
+
/* Be sure end square is redrawn */
damage[toY][toX] = True;
}
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Figure out which square we start in and the
mouse position relative to top left corner. */
BoardSquare(x, y, &boardX, &boardY);
/* Mark this square as needing to be redrawn. Note that
we don't remove the piece though, since logically (ie
as seen by opponent) the move hasn't been made yet. */
+ if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
+ boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
+ XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
+ corner.x, corner.y, squareSize, squareSize,
+ 0, 0); // [HGM] zh: unstack in stead of grab
damage[boardY][boardX] = True;
} else {
player.dragActive = False;
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Sanity check */
if (! player.dragActive)
return;
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Sanity check */
if (! player.dragActive)
return;
damage[player.startBoardY][player.startBoardX] = TRUE;
}
+void
+SetProgramStats( FrontEndProgramStats * stats )
+{
+ // [HR] TODO
+ // [HGM] done, but perhaps backend should call this directly?
+ EngineOutputUpdate( stats );
+}
projects / xboard.git / blobdiff