#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
+ # include <stdarg.h>
#else /* not STDC_HEADERS */
# if HAVE_STRING_H
# include <string.h>
# include "zippy.h"
#endif
#include "backendz.h"
-#include "gettext.h"
-
-#ifdef ENABLE_NLS
-# define _(s) gettext (s)
-# define N_(s) gettext_noop (s)
-#else
-# define _(s) (s)
-# define N_(s) s
-#endif
+#include "gettext.h"
+
+#ifdef ENABLE_NLS
+# define _(s) gettext (s)
+# define N_(s) gettext_noop (s)
+#else
+# define _(s) (s)
+# define N_(s) s
+#endif
/* A point in time */
char *buf, int count, int error));
void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
char *buf, int count, int error));
+ void ics_printf P((char *format, ...));
void SendToICS P((char *s));
void SendToICSDelayed P((char *s, long msdelay));
void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
+ void ics_update_width P((int new_width));
extern char installDir[MSG_SIZ];
extern int tinyLayout, smallLayout;
case VariantKriegspiel:
flags |= F_KRIEGSPIEL_CAPTURE;
break;
- case VariantCapaRandom:
+ case VariantCapaRandom:
case VariantFischeRandom:
flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
case VariantNoCastle:
FILE *gameFileFP, *debugFP;
-/*
+/*
[AS] Note: sometimes, the sscanf() function is used to parse the input
into a fixed-size buffer. Because of this, we must be prepared to
receive strings as long as the size of the input buffer, which is currently
int initialRulePlies, FENrulePlies;
char FENepStatus;
FILE *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
-int loadFlag = 0;
+int loadFlag = 0;
int shuffleOpenings;
int mute; // mute all sounds
};
ChessSquare CapablancaArray[2][BOARD_SIZE] = {
- { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
+ { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
- { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
+ { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
};
ChessSquare GreatArray[2][BOARD_SIZE] = {
- { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
+ { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
- { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
+ { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
};
ChessSquare JanusArray[2][BOARD_SIZE] = {
- { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
+ { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
- { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
+ { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
};
#ifdef GOTHIC
ChessSquare GothicArray[2][BOARD_SIZE] = {
- { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
+ { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
- { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
+ { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
};
#else // !GOTHIC
#ifdef FALCON
ChessSquare FalconArray[2][BOARD_SIZE] = {
- { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
+ { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
- { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
+ { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
};
#else // !FALCON
if (appData.icsActive) {
appData.matchMode = FALSE;
appData.matchGames = 0;
-#if ZIPPY
+#if ZIPPY
appData.noChessProgram = !appData.zippyPlay;
#else
appData.zippyPlay = FALSE;
/* [AS] Adjudication threshold */
adjudicateLossThreshold = appData.adjudicateLossThreshold;
-
+
first.which = "first";
second.which = "second";
first.maybeThinking = second.maybeThinking = FALSE;
appData.clockMode = FALSE;
first.sendTime = second.sendTime = 0;
}
-
+
#if ZIPPY
/* Override some settings from environment variables, for backward
compatibility. Unfortunately it's not feasible to have the env
ZippyInit();
}
#endif
-
+
if (appData.noChessProgram) {
programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
sprintf(programVersion, "%s", PACKAGE_STRING);
if(result = NextIntegerFromString( str, &temp2)) return -1;
*inc = temp2 * 1000;
} else *inc = 0;
- *moves = 0; *tc = temp * 1000;
+ *moves = 0; *tc = temp * 1000;
return 0;
} else if(temp % 60 != 0) return -1; /* moves was given as min:sec */
void
InitBackEnd2()
{
- if (appData.debugMode) {
- fprintf(debugFP, "%s\n", programVersion);
- }
+ if (appData.debugMode) {
+ fprintf(debugFP, "%s\n", programVersion);
+ }
- if (appData.matchGames > 0) {
- appData.matchMode = TRUE;
- } else if (appData.matchMode) {
- appData.matchGames = 1;
- }
- if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
- appData.matchGames = appData.sameColorGames;
- if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
- if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
- if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
- }
- Reset(TRUE, FALSE);
- if (appData.noChessProgram || first.protocolVersion == 1) {
- InitBackEnd3();
- } else {
- /* kludge: allow timeout for initial "feature" commands */
- FreezeUI();
- DisplayMessage("", _("Starting chess program"));
- ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
- }
+ if (appData.matchGames > 0) {
+ appData.matchMode = TRUE;
+ } else if (appData.matchMode) {
+ appData.matchGames = 1;
+ }
+ if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
+ appData.matchGames = appData.sameColorGames;
+ if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
+ if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
+ if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
+ }
+ Reset(TRUE, FALSE);
+ if (appData.noChessProgram || first.protocolVersion == 1) {
+ InitBackEnd3();
+ } else {
+ /* kludge: allow timeout for initial "feature" commands */
+ FreezeUI();
+ DisplayMessage("", _("Starting chess program"));
+ ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
+ }
}
void
if (appData.icsActive) {
#ifdef WIN32
/* [DM] Make a console window if needed [HGM] merged ifs */
- ConsoleCreate();
+ ConsoleCreate();
#endif
err = establish();
if (err != 0) {
if (*appData.icsCommPort != NULLCHAR) {
- sprintf(buf, _("Could not open comm port %s"),
+ sprintf(buf, _("Could not open comm port %s"),
appData.icsCommPort);
} else {
- snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
+ snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
appData.icsHost, appData.icsPort);
}
DisplayFatalError(buf, err, 1);
cmailISR =
AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
}
-
+
ThawUI();
DisplayMessage("", "");
if (StrCaseCmp(appData.initialMode, "") == 0) {
} else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
initialMode = TwoMachinesPlay;
} else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
- initialMode = AnalyzeFile;
+ initialMode = AnalyzeFile;
} else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
initialMode = AnalyzeMode;
} else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
appData.icsHost, appData.icsPort);
} else {
snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
- appData.remoteShell, appData.gateway,
+ appData.remoteShell, appData.gateway,
appData.remoteUser, appData.telnetProgram,
appData.icsHost, appData.icsPort);
}
if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
}
+ /* added routine for printf style output to ics */
+ void ics_printf(char *format, ...)
+ {
+ char buffer[MSG_SIZ];
+ va_list args;
+
+ va_start(args, format);
+ vsnprintf(buffer, sizeof(buffer), format, args);
+ buffer[sizeof(buffer)-1] = '\0';
+ SendToICS(buffer);
+ va_end(args);
+ }
+
void
SendToICS(s)
char *s;
/* Remove all highlighting escape sequences in s
- Also deletes any suffix starting with '('
+ Also deletes any suffix starting with '('
*/
char *
StripHighlightAndTitle(s)
while( *e++ != '_');
}
+ if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
+ v = VariantNormal;
+ found = TRUE;
+ } else
for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
if (StrCaseStr(e, variantNames[i])) {
v = (VariantClass) i;
if (!found) {
if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
- || StrCaseStr(e, "wild/fr")
+ || StrCaseStr(e, "wild/fr")
|| StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
v = VariantFischeRandom;
} else if ((i = 4, p = StrCaseStr(e, "wild")) ||
v = VariantShatranj;
break;
- /* Temporary names for future ICC types. The name *will* change in
+ /* Temporary names for future ICC types. The name *will* change in
the next xboard/WinBoard release after ICC defines it. */
case 29:
v = Variant29;
char *bufp = &buf[*index], *patternp = pattern;
int star_count = 0;
char *matchp = star_match[0];
-
+
for (;;) {
if (*patternp == NULLCHAR) {
*index = leftover_start = bufp - buf;
VariantSwitch(Board board, VariantClass newVariant)
{
int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
- int oldCurrentMove = currentMove, oldForwardMostMove = forwardMostMove, oldBackwardMostMove = backwardMostMove;
- // Board tempBoard; int saveCastling[BOARD_SIZE], saveEP;
startedFromPositionFile = FALSE;
if(gameInfo.variant == newVariant) return;
* but also when receiving holdings of a crazyhouse game. In the latter
* case we want to add those holdings to the already received position.
*/
--
-
- if (appData.debugMode) {
- fprintf(debugFP, "Switch board from %s to %s\n",
- VariantName(gameInfo.variant), VariantName(newVariant));
- setbuf(debugFP, NULL);
- }
- shuffleOpenings = 0; /* [HGM] shuffle */
- gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
- switch(newVariant) {
- case VariantShogi:
- newWidth = 9; newHeight = 9;
- gameInfo.holdingsSize = 7;
- case VariantBughouse:
- case VariantCrazyhouse:
- newHoldingsWidth = 2; break;
- default:
- newHoldingsWidth = gameInfo.holdingsSize = 0;
- }
-
- if(newWidth != gameInfo.boardWidth ||
- newHeight != gameInfo.boardHeight ||
- newHoldingsWidth != gameInfo.holdingsWidth ) {
-
- /* shift position to new playing area, if needed */
- if(newHoldingsWidth > gameInfo.holdingsWidth) {
- for(i=0; i<BOARD_HEIGHT; i++)
- for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
- board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
- board[i][j];
- for(i=0; i<newHeight; i++) {
- board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
- board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
- }
- } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
- for(i=0; i<BOARD_HEIGHT; i++)
- for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
- board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
- board[i][j];
- }
-
- gameInfo.boardWidth = newWidth;
- gameInfo.boardHeight = newHeight;
- gameInfo.holdingsWidth = newHoldingsWidth;
- gameInfo.variant = newVariant;
- InitDrawingSizes(-2, 0);
-
- /* [HGM] The following should definitely be solved in a better way */
- InitPosition(FALSE); /* this sets up board[0], but also other stuff */
- } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
-
- forwardMostMove = oldForwardMostMove;
- backwardMostMove = oldBackwardMostMove;
- currentMove = oldCurrentMove; /* InitPos reset these, but we need still to redraw the position */
+
+ if (appData.debugMode) {
+ fprintf(debugFP, "Switch board from %s to %s\n",
+ VariantName(gameInfo.variant), VariantName(newVariant));
+ setbuf(debugFP, NULL);
+ }
+ shuffleOpenings = 0; /* [HGM] shuffle */
+ gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
+ switch(newVariant)
+ {
+ case VariantShogi:
+ newWidth = 9; newHeight = 9;
+ gameInfo.holdingsSize = 7;
+ case VariantBughouse:
+ case VariantCrazyhouse:
+ newHoldingsWidth = 2; break;
+ case VariantGreat:
+ newWidth = 10;
+ case VariantSuper:
+ newHoldingsWidth = 2;
+ gameInfo.holdingsSize = 8;
+ return;
+ case VariantGothic:
+ case VariantCapablanca:
+ case VariantCapaRandom:
+ newWidth = 10;
+ default:
+ newHoldingsWidth = gameInfo.holdingsSize = 0;
+ };
+
+ if(newWidth != gameInfo.boardWidth ||
+ newHeight != gameInfo.boardHeight ||
+ newHoldingsWidth != gameInfo.holdingsWidth ) {
+
+ /* shift position to new playing area, if needed */
+ if(newHoldingsWidth > gameInfo.holdingsWidth) {
+ for(i=0; i<BOARD_HEIGHT; i++)
+ for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
+ board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
+ board[i][j];
+ for(i=0; i<newHeight; i++) {
+ board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
+ board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
+ }
+ } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
+ for(i=0; i<BOARD_HEIGHT; i++)
+ for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
+ board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
+ board[i][j];
+ }
+ gameInfo.boardWidth = newWidth;
+ gameInfo.boardHeight = newHeight;
+ gameInfo.holdingsWidth = newHoldingsWidth;
+ gameInfo.variant = newVariant;
+ InitDrawingSizes(-2, 0);
+ InitPosition(FALSE); /* this sets up board[0], but also other stuff */
+ } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
+
+ DrawPosition(TRUE, boards[currentMove]);
}
static int loggedOn = FALSE;
#define STARTED_CHATTER 5
#define STARTED_COMMENT 6
#define STARTED_MOVES_NOHIDE 7
-
+
static int started = STARTED_NONE;
static char parse[20000];
static int parse_pos = 0;
for (i = 0; i < count; i++) {
if (data[i] != NULLCHAR && data[i] != '\r')
buf[buf_len++] = data[i];
- if(buf_len >= 5 && buf[buf_len-5]=='\n' && buf[buf_len-4]=='\\' &&
+ if(!appData.noJoin && buf_len >= 5 && buf[buf_len-5]=='\n' && buf[buf_len-4]=='\\' &&
buf[buf_len-3]==' ' && buf[buf_len-2]==' ' && buf[buf_len-1]==' ') {
buf_len -= 5; // [HGM] ICS: join continuation line of Lasker 2.2.3 server with previous
if(buf_len == 0 || buf[buf_len-1] != ' ')
buf[buf_len] = NULLCHAR;
next_out = leftover_len;
leftover_start = 0;
-
+
i = 0;
while (i < buf_len) {
/* Deal with part of the TELNET option negotiation
next_out = i;
continue;
}
-
+
/* OK, this at least will *usually* work */
if (!loggedOn && looking_at(buf, &i, "ics%")) {
loggedOn = TRUE;
}
-
+
if (loggedOn && !intfSet) {
if (ics_type == ICS_ICC) {
sprintf(str,
"/set-quietly interface %s\n/set-quietly style 12\n",
programVersion);
-
+ if (!appData.noJoin)
+ strcat(str, "/set-quietly wrap 0\n");
} else if (ics_type == ICS_CHESSNET) {
sprintf(str, "/style 12\n");
} else {
#ifdef WIN32
strcat(str, "$iset nohighlight 1\n");
#endif
+ if (!appData.noJoin)
+ strcat(str, "$iset nowrap 1\n");
strcat(str, "$iset lock 1\n$style 12\n");
}
SendToICS(str);
+ NotifyFrontendLogin();
intfSet = TRUE;
}
oldi = i;
// [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
- if (appData.autoKibitz && started == STARTED_NONE &&
+ if (appData.autoKibitz && started == STARTED_NONE &&
!appData.icsEngineAnalyze && // [HGM] [DM] ICS analyze
(gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
if(looking_at(buf, &i, "* kibitzes: ") &&
- (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
+ (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
StrStr(star_match[0], gameInfo.black) == star_match[0] )) { // kibitz of self or opponent
suppressKibitz = TRUE;
if((StrStr(star_match[0], gameInfo.white) == star_match[0]
savingComment = TRUE;
suppressKibitz = gameMode != IcsObserving ? 2 :
(StrStr(star_match[0], gameInfo.white) == NULL) + 1;
- }
+ }
continue;
} else
if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
SendToICS("refresh\n");
continue;
}
-
+
if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
ICSInitScript();
have_sent_ICS_logon = 1;
continue;
}
-
- if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
+
+ if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
(looking_at(buf, &i, "\n<12> ") ||
looking_at(buf, &i, "<12> "))) {
loggedOn = TRUE;
gameInfo.whiteRating = string_to_rating(star_match[1]);
gameInfo.blackRating = string_to_rating(star_match[3]);
if (appData.debugMode)
- fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
+ fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
gameInfo.whiteRating, gameInfo.blackRating);
}
continue;
break;
}
continue;
- }
-
+ }
+
if (looking_at(buf, &i, "% ") ||
((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
&& looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
if (WhiteOnMove(forwardMostMove)) {
if (first.sendTime) {
if (first.useColors) {
- SendToProgram("black\n", &first);
+ SendToProgram("black\n", &first);
}
SendTimeRemaining(&first, TRUE);
}
firstMove = TRUE;
}
}
- }
+ }
}
#endif
if (gameMode == IcsObserving && ics_gamenum == -1) {
if(bookHit) { // [HGM] book: simulate book reply
static char bookMove[MSG_SIZ]; // a bit generous?
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
}
continue;
}
-
+
if ((started == STARTED_MOVES || started == STARTED_BOARD ||
started == STARTED_HOLDINGS ||
started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
/* Accumulate characters in move list or board */
parse[parse_pos++] = buf[i];
}
-
+
/* Start of game messages. Mostly we detect start of game
when the first board image arrives. On some versions
of the ICS, though, we need to do a "refresh" after starting
player2Rating = string_to_rating(star_match[3]);
if (appData.debugMode)
- fprintf(debugFP,
+ fprintf(debugFP,
"Ratings from 'Game notification:' %s %d, %s %d\n",
player1Name, player1Rating,
player2Name, player2Rating);
SendToICS("refresh\n");
}
continue;
- }
-
+ }
+
/* Error messages */
// if (ics_user_moved) {
if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
2 empty, white, or black (IGNORED)
3 player 2 name (not necessarily black)
4 player 2 rating
-
+
The names/ratings are sorted out when the game
actually starts (below).
*/
player2Rating = string_to_rating(star_match[4]);
if (appData.debugMode)
- fprintf(debugFP,
+ fprintf(debugFP,
"Ratings from 'Creating:' %s %d, %s %d\n",
player1Name, player1Rating,
player2Name, player2Rating);
continue;
}
-
+
/* Improved generic start/end-of-game messages */
if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
(tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
ClearPremoveHighlights();
if (appData.debugMode)
fprintf(debugFP, "Sending premove:\n");
- UserMoveEvent(premoveFromX, premoveFromY,
- premoveToX, premoveToY,
+ UserMoveEvent(premoveFromX, premoveFromY,
+ premoveToX, premoveToY,
premovePromoChar);
}
}
i++; /* skip unparsed character and loop back */
}
-
+
if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
started != STARTED_HOLDINGS && i > next_out) {
SendToPlayer(&buf[next_out], i - next_out);
next_out = i;
}
suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
-
+
leftover_len = buf_len - leftover_start;
/* if buffer ends with something we couldn't parse,
reparse it after appending the next read */
-
+
} else if (count == 0) {
RemoveInputSource(isr);
DisplayFatalError(_("Connection closed by ICS"), 0, 0);
/* Board style 12 looks like this:
-
+
<12> r-b---k- pp----pp ---bP--- ---p---- q------- ------P- P--Q--BP -----R-K W -1 0 0 0 0 0 0 paf MaxII 0 2 12 21 25 234 174 24 Q/d7-a4 (0:06) Qxa4 0 0
-
+
* The "<12> " is stripped before it gets to this routine. The two
* trailing 0's (flip state and clock ticking) are later addition, and
* some chess servers may not have them, or may have only the first.
- * Additional trailing fields may be added in the future.
+ * Additional trailing fields may be added in the future.
*/
#define PATTERN "%c%d%d%d%d%d%d%d%s%s%d%d%d%d%d%d%d%d%s%s%s%d%d"
void
ParseBoard12(string)
char *string;
-{
+{
GameMode newGameMode;
int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
char *bookHit = NULL; // [HGM] book
fromX = fromY = toX = toY = -1;
-
+
newGame = FALSE;
if (appData.debugMode)
0, 1);
return;
}
-
+
switch (relation) {
case RELATION_OBSERVING_PLAYED:
case RELATION_OBSERVING_STATIC:
case RELATION_ISOLATED_BOARD:
default:
/* Just display this board. If user was doing something else,
- we will forget about it until the next board comes. */
+ we will forget about it until the next board comes. */
newGameMode = IcsIdle;
break;
case RELATION_STARTING_POSITION:
newGameMode = gameMode;
break;
}
-
+
/* Modify behavior for initial board display on move listing
of wild games.
*/
ics_getting_history = H_FALSE;
return;
}
-
+
/* Take action if this is the first board of a new game, or of a
different game than is currently being displayed. */
if (gamenum != ics_gamenum || newGameMode != gameMode ||
relation == RELATION_ISOLATED_BOARD) {
-
+
/* Forget the old game and get the history (if any) of the new one */
if (gameMode != BeginningOfGame) {
Reset(FALSE, TRUE);
sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
SendToICS(str);
}
-
+
/* Initially flip the board to have black on the bottom if playing
black or if the ICS flip flag is set, but let the user change
it with the Flip View button. */
- flipView = appData.autoFlipView ?
+ flipView = appData.autoFlipView ?
(newGameMode == IcsPlayingBlack) || ics_flip :
appData.flipView;
-
+
/* Done with values from previous mode; copy in new ones */
gameMode = newGameMode;
ModeHighlight();
}
gameInfo.outOfBook = NULL;
-
+
/* Do we have the ratings? */
if (strcmp(player1Name, white) == 0 &&
strcmp(player2Name, black) == 0) {
SendToICS("set shout 0\n");
}
}
-
+
/* Deal with midgame name changes */
if (!newGame) {
if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
gameInfo.black = StrSave(black);
}
}
-
+
/* Throw away game result if anything actually changes in examine mode */
if (gameMode == IcsExamining && !newGame) {
gameInfo.result = GameUnfinished;
gameInfo.resultDetails = NULL;
}
}
-
+
/* In pausing && IcsExamining mode, we ignore boards coming
in if they are in a different variation than we are. */
if (pauseExamInvalid) return;
return;
}
}
-
+
if (appData.debugMode) {
fprintf(debugFP, "load %dx%d board\n", files, ranks);
}
/* [HGM] e.p. rights. Assume that ICS sends file number here? */
epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
-
+
if (ics_getting_history == H_GOT_REQ_HEADER ||
ics_getting_history == H_GOT_UNREQ_HEADER) {
/* This was an initial position from a move list, not
the current position */
return;
}
-
+
/* Update currentMove and known move number limits */
newMove = newGame || moveNum > forwardMostMove;
if (!pausing || currentMove > forwardMostMove)
currentMove = forwardMostMove;
} else {
- /* New part of history that is not contiguous with old part */
+ /* New part of history that is not contiguous with old part */
if (pausing && gameMode == IcsExamining) {
pauseExamInvalid = TRUE;
forwardMostMove = pauseExamForwardMostMove;
SendToICS(str);
}
}
-
+
/* Update the clocks */
if (strchr(elapsed_time, '.')) {
/* Time is in ms */
timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
}
-
+
#if ZIPPY
if (appData.zippyPlay && newGame &&
gameMode != IcsExamining)
ZippyFirstBoard(moveNum, basetime, increment);
#endif
-
+
/* Put the move on the move list, first converting
to canonical algebraic form. */
if (moveNum > 0) {
startedFromSetupPosition = TRUE;
fromX = fromY = toX = toY = -1;
} else {
- // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
+ // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
// So we parse the long-algebraic move string in stead of the SAN move
int valid; char buf[MSG_SIZ], *prom;
// str looks something like "Q/a1-a2"; kill the slash
- if(str[1] == '/')
+ if(str[1] == '/')
sprintf(buf, "%c%s", str[0], str+2);
else strcpy(buf, str); // might be castling
- if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
+ if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
strcat(buf, prom); // long move lacks promo specification!
if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
- if(appData.debugMode)
+ if(appData.debugMode)
fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
strcpy(move_str, buf);
}
#if ZIPPY
/* Send move to chess program (BEFORE animating it). */
- if (appData.zippyPlay && !newGame && newMove &&
+ if (appData.zippyPlay && !newGame && newMove &&
(!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
SetHighlights(fromX, fromY, toX, toY);
}
}
-
+
/* Start the clocks */
whiteFlag = blackFlag = FALSE;
appData.clockMode = !(basetime == 0 && increment == 0);
DisplayBothClocks();
else
StartClocks();
-
+
/* Display opponents and material strengths */
if (gameInfo.variant != VariantBughouse &&
gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
if (tinyLayout || smallLayout) {
if(gameInfo.variant == VariantNormal)
- sprintf(str, "%s(%d) %s(%d) {%d %d}",
+ sprintf(str, "%s(%d) %s(%d) {%d %d}",
gameInfo.white, white_stren, gameInfo.black, black_stren,
basetime, increment);
else
- sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
+ sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
gameInfo.white, white_stren, gameInfo.black, black_stren,
basetime, increment, (int) gameInfo.variant);
} else {
if(gameInfo.variant == VariantNormal)
- sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
+ sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
gameInfo.white, white_stren, gameInfo.black, black_stren,
basetime, increment);
else
- sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
+ sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
gameInfo.white, white_stren, gameInfo.black, black_stren,
basetime, increment, VariantName(gameInfo.variant));
}
}
}
-
+
/* Display the board */
if (!pausing && !appData.noGUI) {
-
if (appData.premove)
- if (!gotPremove ||
+ if (!gotPremove ||
((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
ClearPremoveHighlights();
if(bookHit) { // [HGM] book: simulate book reply
static char bookMove[MSG_SIZ]; // a bit generous?
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
programStats.ok_to_send = 0;
}
+ void ics_update_width(new_width)
+ int new_width;
+ {
+ ics_printf("set width %d\n", new_width);
+ }
+
void
SendMoveToProgram(moveNum, cps)
int moveNum;
AlphaRank(moveList[moveNum], 4); // and back
} else
/* Added by Tord: Send castle moves in "O-O" in FRC games if required by
- * the engine. It would be nice to have a better way to identify castle
+ * the engine. It would be nice to have a better way to identify castle
* moves here. */
if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
&& cps->useOOCastle) {
- int fromX = moveList[moveNum][0] - AAA;
+ int fromX = moveList[moveNum][0] - AAA;
int fromY = moveList[moveNum][1] - ONE;
- int toX = moveList[moveNum][2] - AAA;
+ int toX = moveList[moveNum][2] - AAA;
int toY = moveList[moveNum][3] - ONE;
- if((boards[moveNum][fromY][fromX] == WhiteKing
+ if((boards[moveNum][fromY][fromX] == WhiteKing
&& boards[moveNum][toY][toX] == WhiteRook)
- || (boards[moveNum][fromY][fromX] == BlackKing
+ || (boards[moveNum][fromY][fromX] == BlackKing
&& boards[moveNum][toY][toX] == BlackRook)) {
if(toX > fromX) SendToProgram("O-O\n", cps);
else SendToProgram("O-O-O\n", cps);
fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
}
- if(move[1]=='*' &&
+ if(move[1]=='*' &&
move[2]>='0' && move[2]<='9' &&
move[3]>='a' && move[3]<='x' ) {
move[1] = '@';
ChessMove *moveType;
int *fromX, *fromY, *toX, *toY;
char *promoChar;
-{
+{
if (appData.debugMode) {
fprintf(debugFP, "move to parse: %s\n", move);
}
board[rank][i] = (ChessSquare) pieceType;
squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
squaresLeft[ANY]--;
- piecesLeft[pieceType]--;
+ piecesLeft[pieceType]--;
return i;
}
}
{
int result = FALSE; int NrPieces;
- if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
+ if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
&& NrPieces >= 12 && !(NrPieces&1)) {
int i; /* [HGM] Accept even length from 12 to 34 */
void Prelude(Board board)
{ // [HGM] superchess: random selection of exo-pieces
- int i, j, k; ChessSquare p;
+ int i, j, k; ChessSquare p;
static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
GetPositionNumber(); // use FRC position number
if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
SetCharTable(pieceToChar, appData.pieceToCharTable);
- for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
+ for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
}
- j = seed%4; seed /= 4;
+ j = seed%4; seed /= 4;
p = board[0][BOARD_LEFT+j]; board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
board[k][BOARD_WIDTH-1] = p; board[k][BOARD_WIDTH-2]++;
board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p; board[BOARD_HEIGHT-1-k][1]++;
- j = seed%3 + (seed%3 >= j); seed /= 3;
+ j = seed%3 + (seed%3 >= j); seed /= 3;
p = board[0][BOARD_LEFT+j]; board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
board[k][BOARD_WIDTH-1] = p; board[k][BOARD_WIDTH-2]++;
board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p; board[BOARD_HEIGHT-1-k][1]++;
- j = seed%3; seed /= 3;
+ j = seed%3; seed /= 3;
p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
board[k][BOARD_WIDTH-1] = p; board[k][BOARD_WIDTH-2]++;
board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p; board[BOARD_HEIGHT-1-k][1]++;
- j = seed%2 + (seed%2 >= j); seed /= 2;
+ j = seed%2 + (seed%2 >= j); seed /= 2;
p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
board[k][BOARD_WIDTH-1] = p; board[k][BOARD_WIDTH-2]++;
board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p; board[BOARD_HEIGHT-1-k][1]++;
castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
}
-
+
/* [HGM] logic here is completely changed. In stead of full positions */
/* the initialized data only consist of the two backranks. The switch */
/* selects which one we will use, which is than copied to the Board */
gameInfo.holdingsSize = 0;
nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1; /* but no rights yet */
- SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
+ SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
switch (gameInfo.variant) {
case VariantFischeRandom:
case VariantShatranj:
pieces = ShatranjArray;
nrCastlingRights = 0;
- SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
+ SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
break;
case VariantTwoKings:
pieces = twoKingsArray;
case VariantCapablanca:
pieces = CapablancaArray;
gameInfo.boardWidth = 10;
- SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
+ SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
break;
case VariantGothic:
pieces = GothicArray;
gameInfo.boardWidth = 10;
- SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
+ SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
break;
case VariantJanus:
pieces = JanusArray;
gameInfo.boardWidth = 10;
- SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
+ SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
nrCastlingRights = 6;
castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
case VariantFalcon:
pieces = FalconArray;
gameInfo.boardWidth = 10;
- SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
+ SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
break;
case VariantXiangqi:
pieces = XiangqiArray;
gameInfo.boardWidth = 9;
gameInfo.boardHeight = 10;
nrCastlingRights = 0;
- SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
+ SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
break;
case VariantShogi:
pieces = ShogiArray;
gameInfo.boardHeight = 9;
gameInfo.holdingsSize = 7;
nrCastlingRights = 0;
- SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
+ SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
break;
case VariantCourier:
pieces = CourierArray;
gameInfo.boardWidth = 12;
nrCastlingRights = 0;
- SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
+ SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
break;
case VariantKnightmate:
pieces = KnightmateArray;
- SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
+ SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
break;
case VariantFairy:
pieces = fairyArray;
- SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
+ SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
break;
case VariantGreat:
pieces = GreatArray;
case VariantCrazyhouse:
case VariantBughouse:
pieces = FIDEArray;
- SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
+ SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
gameInfo.holdingsSize = 5;
break;
case VariantWildCastle:
initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
if(gameInfo.variant == VariantXiangqi) {
if(j&1) {
- initialPosition[pawnRow][j] =
+ initialPosition[pawnRow][j] =
initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
initialPosition[2][j] = WhiteCannon;
/* This sets default castling rights from none to normal corners */
/* Variants with other castling rights must set them themselves above */
nrCastlingRights = 6;
-
+
castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
castlingRights[0][2] = initialRights[2] = BOARD_WIDTH>>1;
}
CopyBoard(boards[0], initialPosition);
-
if(oldx != gameInfo.boardWidth ||
oldy != gameInfo.boardHeight ||
oldh != gameInfo.holdingsWidth
gameInfo.variant == VariantFalcon
#endif
)
+ {
InitDrawingSizes(-2 ,0);
+ }
if (redraw)
DrawPosition(TRUE, boards[currentMove]);
+
}
void
int moveNum;
{
char message[MSG_SIZ];
-
+
if (cps->useSetboard) {
char* fen = PositionToFEN(moveNum, cps->fenOverride);
sprintf(message, "setboard %s\n", fen);
bp = &boards[moveNum][i][BOARD_LEFT];
for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
if ((int) *bp < (int) BlackPawn) {
- sprintf(message, "%c%c%c\n", PieceToChar(*bp),
+ sprintf(message, "%c%c%c\n", PieceToChar(*bp),
AAA + j, ONE + i);
if(message[0] == '+' || message[0] == '~') {
sprintf(message, "%c%c%c+\n",
}
}
}
-
+
SendToProgram("c\n", cps);
for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
bp = &boards[moveNum][i][BOARD_LEFT];
}
}
}
-
+
SendToProgram(".\n", cps);
}
setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
if (!white_piece && WhiteOnMove(currentMove)) {
DisplayMoveError(_("It is White's turn"));
return FALSE;
- }
+ }
if (white_piece && !WhiteOnMove(currentMove)) {
DisplayMoveError(_("It is Black's turn"));
return FALSE;
- }
+ }
if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
/* Editing correspondence game history */
/* Could disallow this or prompt for confirmation */
}
}
break;
-
+
case Training:
if (!white_piece && WhiteOnMove(currentMove)) {
DisplayMoveError(_("It is White's turn"));
return FALSE;
- }
+ }
if (white_piece && !WhiteOnMove(currentMove)) {
DisplayMoveError(_("It is Black's turn"));
return FALSE;
- }
+ }
break;
default:
(WhitePawn <= pdown && pdown < BlackPawn &&
WhitePawn <= pup && pup < BlackPawn ||
BlackPawn <= pdown && pdown < EmptySquare &&
- BlackPawn <= pup && pup < EmptySquare
+ BlackPawn <= pup && pup < EmptySquare
) && !((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
(pup == WhiteRook && pdown == WhiteKing && fromY == 0 && toY == 0||
pup == BlackRook && pdown == BlackKing && fromY == BOARD_HEIGHT-1 && toY == BOARD_HEIGHT-1 ||
premoveFromY = fromY;
premovePromoChar = promoChar;
gotPremove = 1;
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Got premove: fromX %d,"
"fromY %d, toX %d, toY %d\n",
fromX, fromY, toX, toY);
premoveFromY = fromY;
premovePromoChar = promoChar;
gotPremove = 1;
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Got premove: fromX %d,"
"fromY %d, toX %d, toY %d\n",
fromX, fromY, toX, toY);
}
/* [HGM] If move started in holdings, it means a drop */
- if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
+ if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
if( pup != EmptySquare ) return ImpossibleMove;
if(appData.testLegality) {
/* it would be more logical if LegalityTest() also figured out
}
userOfferedDraw = FALSE;
-
+
/* [HGM] always test for legality, to get promotion info */
moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
epStatus[currentMove], castlingRights[currentMove],
return ImpossibleMove;
}
}
-if(appData.debugMode) fprintf(debugFP, "moveType 3 = %d, promochar = %x\n", moveType, promoChar);
+ if(appData.debugMode) fprintf(debugFP, "moveType 3 = %d, promochar = %x\n", moveType, promoChar);
return moveType;
/* [HGM] <popupFix> in stead of calling FinishMove directly, this
function is made into one that returns an OK move type if FinishMove
int fromX, fromY, toX, toY;
/*char*/int promoChar;
{
- char *bookHit = 0;
-if(appData.debugMode) fprintf(debugFP, "moveType 5 = %d, promochar = %x\n", moveType, promoChar);
- if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
- // [HGM] superchess: suppress promotions to non-available piece
- int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
- if(WhiteOnMove(currentMove)) {
- if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
- } else {
- if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
+ char *bookHit = 0;
+
+ if(appData.debugMode)
+ fprintf(debugFP, "moveType 5 = %d, promochar = %x\n", moveType, promoChar);
+
+ if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR)
+ {
+ // [HGM] superchess: suppress promotions to non-available piece
+ int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
+ if(WhiteOnMove(currentMove))
+ {
+ if(!boards[currentMove][k][BOARD_WIDTH-2])
+ return 0;
+ }
+ else
+ {
+ if(!boards[currentMove][BOARD_HEIGHT-1-k][1])
+ return 0;
}
}
+
+ /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
+ move type in caller when we know the move is a legal promotion */
+ if(moveType == NormalMove && promoChar)
+ moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
- /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
- move type in caller when we know the move is a legal promotion */
- if(moveType == NormalMove && promoChar)
- moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
-if(appData.debugMode) fprintf(debugFP, "moveType 1 = %d, promochar = %x\n", moveType, promoChar);
- /* [HGM] convert drag-and-drop piece drops to standard form */
- if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
- moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
- if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
+ if(appData.debugMode)
+ fprintf(debugFP, "moveType 1 = %d, promochar = %x\n", moveType, promoChar);
+
+ /* [HGM] convert drag-and-drop piece drops to standard form */
+ if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1)
+ {
+ moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
+ if(appData.debugMode)
+ fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
-// fromX = boards[currentMove][fromY][fromX];
- // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
- if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
- fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
- while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
- fromY = DROP_RANK;
- }
-
- /* [HGM] <popupFix> The following if has been moved here from
- UserMoveEvent(). Because it seemed to belon here (why not allow
- piece drops in training games?), and because it can only be
- performed after it is known to what we promote. */
- if (gameMode == Training) {
+ // fromX = boards[currentMove][fromY][fromX];
+ // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
+ if(fromX == 0)
+ fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
+
+ fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
+
+ while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare)
+ fromX++;
+
+ fromY = DROP_RANK;
+ }
+
+ /* [HGM] <popupFix> The following if has been moved here from
+ UserMoveEvent(). Because it seemed to belon here (why not allow
+ piece drops in training games?), and because it can only be
+ performed after it is known to what we promote. */
+ if (gameMode == Training)
+ {
/* compare the move played on the board to the next move in the
- * game. If they match, display the move and the opponent's response.
+ * game. If they match, display the move and the opponent's response.
* If they don't match, display an error message.
*/
int saveAnimate;
CopyBoard(testBoard, boards[currentMove]);
ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard, testRights, &testStatus);
- if (CompareBoards(testBoard, boards[currentMove+1])) {
- ForwardInner(currentMove+1);
+ if (CompareBoards(testBoard, boards[currentMove+1]))
+ {
+ ForwardInner(currentMove+1);
- /* Autoplay the opponent's response.
- * if appData.animate was TRUE when Training mode was entered,
- * the response will be animated.
- */
- saveAnimate = appData.animate;
- appData.animate = animateTraining;
- ForwardInner(currentMove+1);
- appData.animate = saveAnimate;
-
- /* check for the end of the game */
- if (currentMove >= forwardMostMove) {
- gameMode = PlayFromGameFile;
- ModeHighlight();
- SetTrainingModeOff();
- DisplayInformation(_("End of game"));
+ /* Autoplay the opponent's response.
+ * if appData.animate was TRUE when Training mode was entered,
+ * the response will be animated.
+ */
+ saveAnimate = appData.animate;
+ appData.animate = animateTraining;
+ ForwardInner(currentMove+1);
+ appData.animate = saveAnimate;
+
+ /* check for the end of the game */
+ if (currentMove >= forwardMostMove)
+ {
+ gameMode = PlayFromGameFile;
+ ModeHighlight();
+ SetTrainingModeOff();
+ DisplayInformation(_("End of game"));
+ }
+ }
+ else
+ {
+ DisplayError(_("Incorrect move"), 0);
}
- } else {
- DisplayError(_("Incorrect move"), 0);
- }
return 1;
}
/* Ok, now we know that the move is good, so we can kill
the previous line in Analysis Mode */
- if (gameMode == AnalyzeMode && currentMove < forwardMostMove) {
- forwardMostMove = currentMove;
- }
+ if (gameMode == AnalyzeMode && currentMove < forwardMostMove)
+ {
+ forwardMostMove = currentMove;
+ }
/* If we need the chess program but it's dead, restart it */
ResurrectChessProgram();
MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
- if (gameMode == BeginningOfGame) {
- if (appData.noChessProgram) {
- gameMode = EditGame;
- SetGameInfo();
- } else {
- char buf[MSG_SIZ];
- gameMode = MachinePlaysBlack;
- StartClocks();
- SetGameInfo();
- sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
- DisplayTitle(buf);
- if (first.sendName) {
- sprintf(buf, "name %s\n", gameInfo.white);
- SendToProgram(buf, &first);
- }
- StartClocks();
+ if (gameMode == BeginningOfGame)
+ {
+ if (appData.noChessProgram)
+ {
+ gameMode = EditGame;
+ SetGameInfo();
+ }
+ else
+ {
+ char buf[MSG_SIZ];
+ gameMode = MachinePlaysBlack;
+ StartClocks();
+ SetGameInfo();
+ sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
+ DisplayTitle(buf);
+ if (first.sendName)
+ {
+ sprintf(buf, "name %s\n", gameInfo.white);
+ SendToProgram(buf, &first);
+ }
+ StartClocks();
+ }
+ ModeHighlight();
}
- ModeHighlight();
- }
-if(appData.debugMode) fprintf(debugFP, "moveType 2 = %d, promochar = %x\n", moveType, promoChar);
+ if(appData.debugMode) fprintf(debugFP, "moveType 2 = %d, promochar = %x\n", moveType, promoChar);
+
/* Relay move to ICS or chess engine */
- if (appData.icsActive) {
- if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
- gameMode == IcsExamining) {
- SendMoveToICS(moveType, fromX, fromY, toX, toY);
- ics_user_moved = 1;
+ if (appData.icsActive)
+ {
+ if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
+ gameMode == IcsExamining)
+ {
+ SendMoveToICS(moveType, fromX, fromY, toX, toY);
+ ics_user_moved = 1;
+ }
}
- } else {
- if (first.sendTime && (gameMode == BeginningOfGame ||
- gameMode == MachinePlaysWhite ||
- gameMode == MachinePlaysBlack)) {
- SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
- }
- if (gameMode != EditGame && gameMode != PlayFromGameFile) {
- // [HGM] book: if program might be playing, let it use book
- bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
- first.maybeThinking = TRUE;
- } else SendMoveToProgram(forwardMostMove-1, &first);
- if (currentMove == cmailOldMove + 1) {
- cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
+ else
+ {
+ if (first.sendTime && (gameMode == BeginningOfGame ||
+ gameMode == MachinePlaysWhite ||
+ gameMode == MachinePlaysBlack))
+ {
+ SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
+ }
+ if (gameMode != EditGame && gameMode != PlayFromGameFile)
+ {
+ // [HGM] book: if program might be playing, let it use book
+ bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
+ first.maybeThinking = TRUE;
+ }
+ else
+ SendMoveToProgram(forwardMostMove-1, &first);
+ if (currentMove == cmailOldMove + 1)
+ {
+ cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
+ }
}
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- switch (gameMode) {
- case EditGame:
- switch (MateTest(boards[currentMove], PosFlags(currentMove),
- EP_UNKNOWN, castlingRights[currentMove]) ) {
- case MT_NONE:
- case MT_CHECK:
+ switch (gameMode)
+ {
+ case EditGame:
+ switch (MateTest(boards[currentMove], PosFlags(currentMove),
+ EP_UNKNOWN, castlingRights[currentMove]) )
+ {
+ case MT_NONE:
+ case MT_CHECK:
+ break;
+ case MT_CHECKMATE:
+ case MT_STAINMATE:
+ if (WhiteOnMove(currentMove))
+ {
+ GameEnds(BlackWins, "Black mates", GE_PLAYER);
+ }
+ else
+ {
+ GameEnds(WhiteWins, "White mates", GE_PLAYER);
+ }
+ break;
+ case MT_STALEMATE:
+ GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
+ break;
+ }
break;
- case MT_CHECKMATE:
- case MT_STAINMATE:
- if (WhiteOnMove(currentMove)) {
- GameEnds(BlackWins, "Black mates", GE_PLAYER);
- } else {
- GameEnds(WhiteWins, "White mates", GE_PLAYER);
- }
+
+ case MachinePlaysBlack:
+ case MachinePlaysWhite:
+ /* disable certain menu options while machine is thinking */
+ SetMachineThinkingEnables();
break;
- case MT_STALEMATE:
- GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
+
+ default:
break;
}
- break;
-
- case MachinePlaysBlack:
- case MachinePlaysWhite:
- /* disable certain menu options while machine is thinking */
- SetMachineThinkingEnables();
- break;
- default:
- break;
- }
+ if(bookHit)
+ { // [HGM] book: simulate book reply
+ static char bookMove[MSG_SIZ]; // a bit generous?
- if(bookHit) { // [HGM] book: simulate book reply
- static char bookMove[MSG_SIZ]; // a bit generous?
-
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
- sprintf(programStats.movelist, "%s (xbook)", bookHit);
+ sprintf(programStats.movelist, "%s (xbook)", bookHit);
+
+ strcpy(bookMove, "move ");
+ strcat(bookMove, bookHit);
+ HandleMachineMove(bookMove, &first);
+ }
- strcpy(bookMove, "move ");
- strcat(bookMove, bookHit);
- HandleMachineMove(bookMove, &first);
- }
return 1;
}
slip a promotion popup in between. But that it always needs two
calls, to the first part, (now called UserMoveTest() ), and to
FinishMove if the first part succeeded. Calls that do not need
- to do anything in between, can call this routine the old way.
+ to do anything in between, can call this routine the old way.
*/
ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar, FALSE);
if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
cps->bookSuspend = FALSE; // after a 'go' we are never suspended
} else { // 'go' might be sent based on 'firstMove' after this routine returns
if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
- SendToProgram("go\n", cps);
+ SendToProgram("go\n", cps);
cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
}
return bookHit; // notify caller of hit, so it can take action to send move to opponent
* Look for machine move.
*/
if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
- (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
+ (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
{
/* This method is only useful on engines that support ping */
if (cps->lastPing != cps->lastPong) {
if( count >= adjudicateLossPlies ) {
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
- "Xboard adjudication",
+ GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
+ "Xboard adjudication",
GE_XBOARD );
return;
NrWQ++; break;
case BlackQueen:
NrBQ++; break;
- case EmptySquare:
+ case EmptySquare:
break;
case BlackPawn:
m = 7-i;
}
NrPieces += (p != EmptySquare);
NrW += ((int)p < (int)BlackPawn);
- if(gameInfo.variant == VariantXiangqi &&
+ if(gameInfo.variant == VariantXiangqi &&
(p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
NrPieces--; // [HGM] XQ: do not count purely defensive pieces
NrW -= ((int)p < (int)BlackPawn);
if(appData.checkMates) {
SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
+ GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
"Xboard adjudication: King destroyed", GE_XBOARD );
return;
}
if(appData.checkMates) {
SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets to see move
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
+ GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
"Xboard adjudication: Bare king", GE_XBOARD );
return;
}
/* but only adjudicate if adjudication enabled */
SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
+ GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
"Xboard adjudication: Bare king", GE_XBOARD );
return;
}
}
/* Next absolutely insufficient mating material. */
- if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
+ if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
(NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
}
/* Then some trivial draws (only adjudicate, cannot be claimed) */
- if(NrPieces == 4 &&
+ if(NrPieces == 4 &&
( NrWR == 1 && NrBR == 1 /* KRKR */
|| NrWQ==1 && NrBQ==1 /* KQKQ */
|| NrWN==2 || NrBN==2 /* KNNK */
}
if( castlingRights[forwardMostMove][5] != castlingRights[k][5] &&
(castlingRights[k][3] >= 0 || castlingRights[k][4] >= 0) )
- rights++;
+ rights++;
if( castlingRights[forwardMostMove][5] >= 0 ) {
if( castlingRights[forwardMostMove][3] != castlingRights[k][3] ||
castlingRights[forwardMostMove][4] != castlingRights[k][4] )
SendToProgram("force\n", cps->other); // suppress reply
SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
- if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
+ if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
// [HGM] xiangqi: check for forbidden perpetuals
int m, ourPerpetual = 1, hisPerpetual = 1;
for(m=forwardMostMove; m>k; m-=2) {
- if(MateTest(boards[m], PosFlags(m),
+ if(MateTest(boards[m], PosFlags(m),
EP_NONE, castlingRights[m]) != MT_CHECK)
ourPerpetual = 0; // the current mover did not always check
- if(MateTest(boards[m-1], PosFlags(m-1),
+ if(MateTest(boards[m-1], PosFlags(m-1),
EP_NONE, castlingRights[m-1]) != MT_CHECK)
hisPerpetual = 0; // the opponent did not always check
}
if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
ourPerpetual, hisPerpetual);
if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
- GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
+ GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
"Xboard adjudication: perpetual checking", GE_XBOARD );
return;
}
hisPerpetual = PerpetualChase(k, forwardMostMove);
ourPerpetual = PerpetualChase(k+1, forwardMostMove);
if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
- GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
+ GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
"Xboard adjudication: perpetual chasing", GE_XBOARD );
return;
}
/* if we hit starting position, add initial plies */
if( count == backwardMostMove )
count -= initialRulePlies;
- count = forwardMostMove - count;
+ count = forwardMostMove - count;
if( count >= 100)
epStatus[forwardMostMove] = EP_RULE_DRAW;
/* this is used to judge if draw claims are legal */
}
ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
-
+
if (!pausing && appData.ringBellAfterMoves) {
RingBell();
}
- /*
+ /*
* Reenable menu items that were disabled while
* machine was thinking
*/
strcat(bookMove, bookHit);
message = bookMove;
cps = cps->other;
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
for( i=0; i<nrCastlingRights; i++ )
castlingRights[0][i] = FENcastlingRights[i];
if(blackPlaysFirst) gameMode = MachinePlaysWhite;
- else gameMode = MachinePlaysBlack;
+ else gameMode = MachinePlaysBlack;
DrawPosition(FALSE, boards[currentMove]);
}
return;
AskQuestion(realname, buf2, buf1, cps->pr);
return;
}
- /* Commands from the engine directly to ICS. We don't allow these to be
- * sent until we are logged on. Crafty kibitzes have been known to
+ /* Commands from the engine directly to ICS. We don't allow these to be
+ * sent until we are logged on. Crafty kibitzes have been known to
* interfere with the login process.
*/
if (loggedOn) {
*/
if (strncmp(message + 1, "llegal move", 11) == 0 ||
strncmp(message, "Error", 5) == 0) {
- if (StrStr(message, "name") ||
+ if (StrStr(message, "name") ||
StrStr(message, "rating") || StrStr(message, "?") ||
StrStr(message, "result") || StrStr(message, "board") ||
StrStr(message, "bk") || StrStr(message, "computer") ||
Don't use it. */
cps->sendTime = 0;
}
-
+
/*
* If chess program startup fails, exit with an error message.
* Attempts to recover here are futile.
DisplayFatalError(buf1, 0, 1);
return;
}
-
- /*
+
+ /*
* Look for hint output
*/
if (sscanf(message, "Hint: %s", buf1) == 1) {
r = p + 1;
}
}
-
+
GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
return;
}
}
-
+
/*
* Look for thinking output
*/
}
/* [AS] Negate score if machine is playing black and reporting absolute scores */
- if( cps->scoreIsAbsolute &&
+ if( cps->scoreIsAbsolute &&
((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) )
{
curscore = -curscore;
if(cps->nps == 0) ticklen = 10*time; // use engine reported time
else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
- if(WhiteOnMove(forwardMostMove))
+ if(WhiteOnMove(forwardMostMove))
whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
else blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
}
SendProgramStatsToFrontend( cps, &programStats );
- /*
+ /*
[AS] Protect the thinkOutput buffer from overflow... this
is only useful if buf1 hasn't overflowed first!
*/
sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
- plylev,
+ plylev,
(gameMode == TwoMachinesPlay ?
ToUpper(cps->twoMachinesColor[0]) : ' '),
((double) curscore) / 100.0,
programStats.line_is_book = 1;
SendProgramStatsToFrontend( cps, &programStats );
-
- if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
+
+ if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
DisplayMove(currentMove - 1);
DisplayAnalysis();
buf1[0] = NULLCHAR;
if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
- &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
+ &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
{
ChessProgramStats cpstats;
/* Parse a game score from the character string "game", and
record it as the history of the current game. The game
- score is NOT assumed to start from the standard position.
+ score is NOT assumed to start from the standard position.
The display is not updated in any way.
*/
void
strcpy(moveList[boardIndex], currentMoveString);
strcat(moveList[boardIndex], "\n");
boardIndex++;
- ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex],
+ ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex],
castlingRights[boardIndex], &epStatus[boardIndex]);
switch (MateTest(boards[boardIndex], PosFlags(boardIndex),
EP_UNKNOWN, castlingRights[boardIndex]) ) {
oldEP = *ep;
*ep = EP_NONE;
- if( board[toY][toX] != EmptySquare )
- *ep = EP_CAPTURE;
+ if( board[toY][toX] != EmptySquare )
+ *ep = EP_CAPTURE;
if( board[fromY][fromX] == WhitePawn ) {
if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
gameInfo.variant != VariantBerolina || toX < fromX)
*ep = toX | berolina;
if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
- gameInfo.variant != VariantBerolina || toX > fromX)
+ gameInfo.variant != VariantBerolina || toX > fromX)
*ep = toX;
}
- } else
+ } else
if( board[fromY][fromX] == BlackPawn ) {
if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
- *ep = EP_PAWN_MOVE;
+ *ep = EP_PAWN_MOVE;
if( toY-fromY== -2) {
if(toX>BOARD_LEFT && board[toY][toX-1] == WhitePawn &&
gameInfo.variant != VariantBerolina || toX < fromX)
*ep = toX | berolina;
if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
- gameInfo.variant != VariantBerolina || toX > fromX)
+ gameInfo.variant != VariantBerolina || toX > fromX)
*ep = toX;
}
}
for(i=0; i<nrCastlingRights; i++) {
if(castling[i] == fromX && castlingRank[i] == fromY ||
- castling[i] == toX && castlingRank[i] == toY
+ castling[i] == toX && castlingRank[i] == toY
) castling[i] = -1; // revoke for moved or captured piece
}
/* [HGM] In Shatranj and Courier all promotions are to Ferz */
if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier)
&& promoChar != 0) promoChar = PieceToChar(WhiteFerz);
-
+
if (fromX == toX && fromY == toY) return;
if (fromY == DROP_RANK) {
if (captured != EmptySquare && gameInfo.holdingsSize > 0
&& gameInfo.variant != VariantBughouse ) {
/* [HGM] holdings: Add to holdings, if holdings exist */
- if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
+ if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
// [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
}
board[toY][toX] = (ChessSquare) (PROMOTED piece);
}
- if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
- && promoChar != NULLCHAR && gameInfo.holdingsSize) {
+ if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
+ && promoChar != NULLCHAR && gameInfo.holdingsSize) {
// [HGM] superchess: take promotion piece out of holdings
int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
if((int)piece < (int)BlackPawn) { // determine stm from piece color
if(gameInfo.variant == VariantKnightmate)
king += (int) WhiteUnicorn - (int) WhiteKing;
if(forwardMostMove == 0) {
- if(blackPlaysFirst)
+ if(blackPlaysFirst)
fprintf(serverMoves, "%s;", second.tidy);
fprintf(serverMoves, "%s;", first.tidy);
- if(!blackPlaysFirst)
+ if(!blackPlaysFirst)
fprintf(serverMoves, "%s;", second.tidy);
} else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
lastLoadFlag = loadFlag;
}
CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
{int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[forwardMostMove+1][i] = castlingRights[forwardMostMove][i];}
- ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1],
+ ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1],
castlingRights[forwardMostMove+1], &epStatus[forwardMostMove+1]);
forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
SwitchClocks(); // uses forwardMostMove, so must be done after incrementing it !
{
int instant = (gameMode == PlayFromGameFile) ?
(matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
+
if(appData.noGUI) return;
- if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
- if (!instant) {
- if (forwardMostMove == currentMove + 1) {
- AnimateMove(boards[forwardMostMove - 1],
- fromX, fromY, toX, toY);
- }
- if (appData.highlightLastMove) {
+
+ if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile)
+ {
+ if (!instant)
+ {
+ if (forwardMostMove == currentMove + 1)
+ {
+//TODO
+// AnimateMove(boards[forwardMostMove - 1],
+// fromX, fromY, toX, toY);
+ }
+ if (appData.highlightLastMove)
+ {
SetHighlights(fromX, fromY, toX, toY);
- }
- }
+ }
+ }
currentMove = forwardMostMove;
}
DrawPosition(FALSE, boards[currentMove]);
DisplayBothClocks();
HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
+
+ return;
}
void SendEgtPath(ChessProgramState *cps)
name[0] = ','; // extract next format name from feature and copy with prefixed ','
while(*p && *p != ',') *q++ = *p++;
*q++ = ':'; *q = 0;
- if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
+ if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
strcmp(name, ",nalimov:") == 0 ) {
// take nalimov path from the menu-changeable option first, if it is defined
sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
- if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
+ if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
gameInfo.variant == VariantGothic || gameInfo.variant == VariantFalcon )
overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
if( gameInfo.variant == VariantCourier )
overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
if(overruled) {
- sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
+ sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
/* [HGM] varsize: try first if this defiant size variant is specifically known */
- if(StrStr(cps->variants, b) == NULL) {
+ if(StrStr(cps->variants, b) == NULL) {
// specific sized variant not known, check if general sizing allowed
if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
if(StrStr(cps->variants, "boardsize") == NULL) {
timeIncrement, appData.searchDepth,
searchTime);
}
- if (appData.showThinking
+ if (appData.showThinking
// [HGM] thinking: four options require thinking output to be sent
|| !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
) {
SendToProgram(buf, cps);
}
cps->initDone = TRUE;
-}
+}
void
}
err = StartChildProcess(buf, "", &cps->pr);
}
-
+
if (err != 0) {
sprintf(buf, _("Startup failure on '%s'"), cps->program);
DisplayFatalError(buf, err, 1);
cps->isr = NULL;
return;
}
-
+
cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
if (cps->protocolVersion > 1) {
sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
if(index < 0) { // [HGM] autoinc
lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
- }
+ }
LoadGameFromFile(appData.loadGameFile,
index,
appData.loadGameFile, FALSE);
if(index < 0) { // [HGM] autoinc
lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
- }
+ }
LoadPositionFromFile(appData.loadPositionFile,
index,
appData.loadPositionFile);
if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
/* If we are playing on ICS, the server decides when the
- game is over, but the engine can offer to draw, claim
- a draw, or resign.
+ game is over, but the engine can offer to draw, claim
+ a draw, or resign.
*/
#if ZIPPY
if (appData.zippyPlay && first.initDone) {
/* If this is an ICS game, only ICS can really say it's done;
if not, anyone can. */
- isIcsGame = (gameMode == IcsPlayingWhite ||
- gameMode == IcsPlayingBlack ||
- gameMode == IcsObserving ||
+ isIcsGame = (gameMode == IcsPlayingWhite ||
+ gameMode == IcsPlayingBlack ||
+ gameMode == IcsObserving ||
gameMode == IcsExamining);
if (!isIcsGame || whosays == GE_ICS) {
/* OK -- not an ICS game, or ICS said it was done */
StopClocks();
- if (!isIcsGame && !appData.noChessProgram)
+ if (!isIcsGame && !appData.noChessProgram)
SetUserThinkingEnables();
-
+
/* [HGM] if a machine claims the game end we verify this claim */
if(gameMode == TwoMachinesPlay && appData.testClaims) {
if(appData.testLegality && whosays >= GE_ENGINE1 ) {
}
/* (Claiming a loss is accepted no questions asked!) */
}
+
/* [HGM] bare: don't allow bare King to win */
if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
- && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
+ && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
&& gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
&& result != GameIsDrawn)
{ int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
}
}
-
if(serverMoves != NULL && !loadFlag) { char c = '=';
if(result==WhiteWins) c = '+';
if(result==BlackWins) c = '-';
/* display last move only if game was not loaded from file */
if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
DisplayMove(currentMove - 1);
-
+
if (forwardMostMove != 0) {
if (gameMode != PlayFromGameFile && gameMode != EditGame
&& lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
}
}
} else if (gameMode == EditGame ||
- gameMode == PlayFromGameFile ||
- gameMode == AnalyzeMode ||
+ gameMode == PlayFromGameFile ||
+ gameMode == AnalyzeMode ||
gameMode == AnalyzeFile) {
nextGameMode = gameMode;
} else {
if (first.isr != NULL)
RemoveInputSource(first.isr);
first.isr = NULL;
-
+
if (first.pr != NoProc) {
ExitAnalyzeMode();
DoSleep( appData.delayBeforeQuit );
if (second.isr != NULL)
RemoveInputSource(second.isr);
second.isr = NULL;
-
+
if (second.pr != NoProc) {
DoSleep( appData.delayBeforeQuit );
SendToProgram("quit\n", &second);
/* Assumes program was just initialized (initString sent).
Leaves program in force mode. */
void
-FeedMovesToProgram(cps, upto)
+FeedMovesToProgram(cps, upto)
ChessProgramState *cps;
int upto;
{
int i;
-
+
if (appData.debugMode)
fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
startedFromSetupPosition ? "position and " : "",
If so, restart it and feed it all the moves made so far. */
if (appData.noChessProgram || first.pr != NoProc) return;
-
+
StartChessProgram(&first);
InitChessProgram(&first, FALSE);
FeedMovesToProgram(&first, currentMove);
white_holding[0] = black_holding[0] = NULLCHAR;
ClearProgramStats();
opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
-
+
ResetFrontEnd();
ClearHighlights();
flipView = appData.flipView;
ExitAnalyzeMode();
gameMode = BeginningOfGame;
ModeHighlight();
+
if(appData.icsActive) gameInfo.variant = VariantNormal;
currentMove = forwardMostMove = backwardMostMove = 0;
InitPosition(redraw);
commentList[i] = NULL;
}
}
+
ResetClocks();
timeRemaining[0][0] = whiteTimeRemaining;
timeRemaining[1][0] = blackTimeRemaining;
if (init) {
InitChessProgram(&first, startedFromSetupPosition);
}
+
DisplayTitle("");
DisplayMessage("", "");
HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
+ return;
}
void
return FALSE;
}
-
+
toX = moveList[currentMove][2] - AAA;
toY = moveList[currentMove][3] - ONE;
ChessMove moveType;
char move[MSG_SIZ];
char *p, *q;
-
- if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
+
+ if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
gameMode != AnalyzeMode && gameMode != Training) {
gameFileFP = NULL;
return FALSE;
}
-
+
yyboardindex = forwardMostMove;
if (readAhead != (ChessMove)0) {
moveType = readAhead;
return FALSE;
moveType = (ChessMove) yylex();
}
-
+
done = FALSE;
switch (moveType) {
case Comment:
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
p = yy_text;
if (*p == '{' || *p == '[' || *p == '(') {
/* currentMoveString is set as a side-effect of yylex */
strcat(currentMoveString, "\n");
strcpy(moveList[forwardMostMove], currentMoveString);
-
+
thinkOutput[0] = NULLCHAR;
MakeMove(fromX, fromY, toX, toY, promoChar);
currentMove = forwardMostMove;
if (appData.debugMode)
fprintf(debugFP, "Restoring %s for game %d\n",
cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
-
+
thinkOutput[0] = NULLCHAR;
strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
promoChar = cmailMove[lastLoadGameNumber - 1][4];
MakeMove(fromX, fromY, toX, toY, promoChar);
ShowMove(fromX, fromY, toX, toY);
-
+
switch (MateTest(boards[currentMove], PosFlags(currentMove),
EP_UNKNOWN, castlingRights[currentMove]) ) {
case MT_NONE:
case MT_CHECK:
break;
-
+
case MT_CHECKMATE:
case MT_STAINMATE:
if (WhiteOnMove(currentMove)) {
GameEnds(WhiteWins, "White mates", GE_PLAYER);
}
break;
-
+
case MT_STALEMATE:
GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
break;
}
break;
-
+
case CMAIL_RESIGN:
if (WhiteOnMove(currentMove)) {
GameEnds(BlackWins, "White resigns", GE_PLAYER);
GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
}
break;
-
+
case CMAIL_ACCEPT:
GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
break;
-
+
default:
break;
}
GameMode oldGameMode;
VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
if (gameMode == Training )
SetTrainingModeOff();
oldGameMode = gameMode;
- if (gameMode != BeginningOfGame) {
- Reset(FALSE, TRUE);
- }
+ if (gameMode != BeginningOfGame)
+ {
+ Reset(FALSE, TRUE);
+ };
gameFileFP = f;
- if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
+ if (lastLoadGameFP != NULL && lastLoadGameFP != f)
+ {
fclose(lastLoadGameFP);
- }
+ };
- if (useList) {
+ if (useList)
+ {
lg = (ListGame *) ListElem(&gameList, gameNumber-1);
- if (lg) {
+ if (lg)
+ {
fseek(f, lg->offset, 0);
GameListHighlight(gameNumber);
gn = 1;
- }
- else {
+ }
+ else
+ {
DisplayError(_("Game number out of range"), 0);
return FALSE;
- }
- } else {
+ };
+ }
+ else
+ {
GameListDestroy();
- if (fseek(f, 0, 0) == -1) {
+ if (fseek(f, 0, 0) == -1)
+ {
if (f == lastLoadGameFP ?
gameNumber == lastLoadGameNumber + 1 :
- gameNumber == 1) {
+ gameNumber == 1)
+ {
gn = 1;
- } else {
+ }
+ else
+ {
DisplayError(_("Can't seek on game file"), 0);
return FALSE;
- }
- }
- }
- lastLoadGameFP = f;
- lastLoadGameNumber = gameNumber;
+ };
+ };
+ };
+
+ lastLoadGameFP = f;
+ lastLoadGameNumber = gameNumber;
strcpy(lastLoadGameTitle, title);
lastLoadGameUseList = useList;
yynewfile(f);
- if (lg && lg->gameInfo.white && lg->gameInfo.black) {
- snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
- lg->gameInfo.black);
- DisplayTitle(buf);
- } else if (*title != NULLCHAR) {
- if (gameNumber > 1) {
+ if (lg && lg->gameInfo.white && lg->gameInfo.black)
+ {
+ snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
+ lg->gameInfo.black);
+ DisplayTitle(buf);
+ }
+ else if (*title != NULLCHAR)
+ {
+ if (gameNumber > 1)
+ {
sprintf(buf, "%s %d", title, gameNumber);
DisplayTitle(buf);
- } else {
+ }
+ else
+ {
DisplayTitle(title);
- }
- }
+ };
+ };
- if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
+ if (gameMode != AnalyzeFile && gameMode != AnalyzeMode)
+ {
gameMode = PlayFromGameFile;
ModeHighlight();
- }
+ };
currentMove = forwardMostMove = backwardMostMove = 0;
CopyBoard(boards[0], initialPosition);
/*
* Skip the first gn-1 games in the file.
- * Also skip over anything that precedes an identifiable
- * start of game marker, to avoid being confused by
- * garbage at the start of the file. Currently
+ * Also skip over anything that precedes an identifiable
+ * start of game marker, to avoid being confused by
+ * garbage at the start of the file. Currently
* recognized start of game markers are the move number "1",
* the pattern "gnuchess .* game", the pattern
- * "^[#;%] [^ ]* game file", and a PGN tag block.
+ * "^[#;%] [^ ]* game file", and a PGN tag block.
* A game that starts with one of the latter two patterns
* will also have a move number 1, possibly
* following a position diagram.
gn--;
lastLoadGameStart = cm;
break;
-
+
case MoveNumberOne:
switch (lastLoadGameStart) {
case GNUChessGame:
break;
}
}
-
+
if (appData.debugMode)
fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
free(gameInfo.event);
}
gameInfo.event = StrSave(yy_text);
- }
+ }
startedFromSetupPosition = FALSE;
while (cm == PGNTag) {
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
err = ParsePGNTag(yy_text, &gameInfo);
if (!err) numPGNTags++;
startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
InitPosition(TRUE);
oldVariant = gameInfo.variant;
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "New variant %d\n", (int) oldVariant);
}
/* Handle comments interspersed among the tags */
while (cm == Comment) {
char *p;
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
p = yy_text;
if (*p == '{' || *p == '[' || *p == '(') {
}
while (*p == ' ' || *p == '\t' ||
*p == '\n' || *p == '\r') p++;
-
+
if (strncmp(p, "black", strlen("black"))==0)
blackPlaysFirst = TRUE;
else
blackPlaysFirst = FALSE;
startedFromSetupPosition = TRUE;
-
+
CopyBoard(boards[0], initial_position);
if (blackPlaysFirst) {
currentMove = forwardMostMove = backwardMostMove = 1;
fprintf(debugFP, "Load Game\n");
}
DisplayBothClocks();
- }
+ }
/* [HGM] server: flag to write setup moves in broadcast file as one */
loadFlag = appData.suppressLoadMoves;
while (cm == Comment) {
char *p;
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
p = yy_text;
if (*p == '{' || *p == '[' || *p == '(') {
if (!matchMode && (pausing || appData.timeDelay != 0)) {
DisplayComment(currentMove - 1, commentList[currentMove]);
}
- if (!matchMode && appData.timeDelay != 0)
+ if (!matchMode && appData.timeDelay != 0)
DrawPosition(FALSE, boards[currentMove]);
if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
}
/* if the first token after the PGN tags is a move
- * and not move number 1, retrieve it from the parser
+ * and not move number 1, retrieve it from the parser
*/
if (cm != MoveNumberOne)
LoadGameOneMove(cm);
AutoPlayGameLoop();
}
- if (appData.debugMode)
+ if (appData.debugMode)
fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
loadFlag = 0; /* [HGM] true game starts */
char *p, line[MSG_SIZ];
Board initial_position;
int i, j, fenMode, pn;
-
+
if (gameMode == Training )
SetTrainingModeOff();
if (first.pr == NoProc) {
StartChessProgram(&first);
InitChessProgram(&first, FALSE);
- }
+ }
pn = positionNumber;
if (positionNumber < 0) {
/* Negative position number means to seek to that byte offset */
} else {
(void) fgets(line, MSG_SIZ, f);
(void) fgets(line, MSG_SIZ, f);
-
+
for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
(void) fgets(line, MSG_SIZ, f);
for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
initial_position[i][j++] = CharToPiece(*p);
}
}
-
+
blackPlaysFirst = FALSE;
if (!feof(f)) {
(void) fgets(line, MSG_SIZ, f);
}
}
startedFromSetupPosition = TRUE;
-
+
SendToProgram("force\n", &first);
CopyBoard(boards[0], initial_position);
if (blackPlaysFirst) {
timeRemaining[0][1] = whiteTimeRemaining;
timeRemaining[1][1] = blackTimeRemaining;
DrawPosition(FALSE, boards[currentMove]);
-
+
return TRUE;
}
{
static char buf[MSG_SIZ];
char *p;
-
+
p = strchr(str, ' ');
if (p == NULL) return str;
strncpy(buf, str, p - str);
}
sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
- sprintf( buf+strlen(buf), "%s%.2f",
+ sprintf( buf+strlen(buf), "%s%.2f",
pvInfoList[idx].score >= 0 ? "+" : "",
pvInfoList[idx].score / 100.0 );
}
char move_buffer[100]; /* [AS] Buffer for move+PV info */
offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
-
+
tm = time((time_t *) NULL);
-
+
PrintPGNTags(f, &gameInfo);
-
+
if (backwardMostMove > 0 || startedFromSetupPosition) {
char *fen = PositionToFEN(backwardMostMove, NULL);
fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
GetOutOfBookInfo( buf );
if( buf[0] != '\0' ) {
- fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
+ fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
}
}
fprintf(f, " ");
linelen++;
}
- fprintf(f, numtext);
+ fprintf(f, "%s", numtext);
linelen += numlen;
/* Get move */
fprintf(f, " ");
linelen++;
}
- fprintf(f, move_buffer);
+ fprintf(f, "%s", move_buffer);
linelen += movelen;
/* [AS] Add PV info if present */
sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
}
- sprintf( move_buffer, "{%s%.2f/%d%s}",
+ sprintf( move_buffer, "{%s%.2f/%d%s}",
pvInfoList[i].score >= 0 ? "+" : "",
pvInfoList[i].score / 100.0,
pvInfoList[i].depth,
fprintf(f, " ");
linelen++;
}
- fprintf(f, move_buffer);
+ fprintf(f, "%s", move_buffer);
linelen += movelen;
}
i++;
}
-
+
/* Start a new line */
if (linelen > 0) fprintf(f, "\n");
{
int i, offset;
time_t tm;
-
+
tm = time((time_t *) NULL);
-
+
fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
PrintOpponents(f);
-
+
if (backwardMostMove > 0 || startedFromSetupPosition) {
fprintf(f, "\n[--------------\n");
PrintPosition(f, backwardMostMove);
i++;
}
}
-
+
if (commentList[i] != NULL) {
fprintf(f, "[%s]\n", commentList[i]);
}
{
time_t tm;
char *fen;
-
+
if (appData.oldSaveStyle) {
tm = time((time_t *) NULL);
-
+
fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
PrintOpponents(f);
fprintf(f, "[--------------\n");
int i;
struct stat inbuf, outbuf;
int status;
-
+
/* Any registered moves are unregistered if unregister is set, */
/* i.e. invoked by the signal handler */
if (unregister) {
outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
sprintf(outFilename, "%s.out", appData.cmailGameName);
}
-
+
status = stat(outFilename, &outbuf);
if (status < 0) {
cmailMailedMove = FALSE;
status = stat(inFilename, &inbuf);
cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
}
-
+
/* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
counts the games, notes how each one terminated, etc.
-
+
It would be nice to remove this kludge and instead gather all
the information while building the game list. (And to keep it
in the game list nodes instead of having a bunch of fixed-size
*/
cmailMsgLoaded = TRUE;
LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
-
+
/* Load first game in the file or popup game menu */
LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
nCmailMovesRegistered --;
- if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
+ if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
{
free(cmailCommentList[lastLoadGameNumber - 1]);
cmailCommentList[lastLoadGameNumber - 1] = NULL;
sprintf(string,
"%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
-
+
f = fopen(string, "w");
if (appData.oldSaveStyle) {
SaveGameOldStyle(f); /* also closes the file */
-
+
sprintf(string, "%s.pos.out", appData.cmailGameName);
f = fopen(string, "w");
SavePosition(f, 0, NULL); /* also closes the file */
fprintf(f, "{--------------\n");
PrintPosition(f, currentMove);
fprintf(f, "--------------}\n\n");
-
+
SaveGame(f, 0, NULL); /* also closes the file*/
}
-
+
cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
nCmailMovesRegistered ++;
} else if (nCmailGames == 1) {
#endif
if (! (cmailMailedMove || RegisterMove())) return;
-
+
if ( cmailMailedMove
|| (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
sprintf(string, partCommandString,
char number[5];
char string[MSG_SIZ]; /* Space for game-list */
int i;
-
+
if (!cmailMsgLoaded) return "";
if (cmailMailedMove) {
sprintf(number, "%d", i + 1);
prependComma = 1;
}
-
+
strcat(string, number);
}
}
sprintf(cmailMsg,
_("Still need to make move for game\n"));
break;
-
+
case 2:
sprintf(cmailMsg,
_("Still need to make moves for both games\n"));
break;
-
+
default:
sprintf(cmailMsg,
_("Still need to make moves for all %d games\n"),
_("Still need to make a move for game %s\n"),
string);
break;
-
+
case 0:
if (nCmailResults == nCmailGames) {
sprintf(cmailMsg, _("No unfinished games\n"));
sprintf(cmailMsg, _("Ready to send mail\n"));
}
break;
-
+
default:
sprintf(cmailMsg,
_("Still need to make moves for games %s\n"),
/* Kill off chess programs */
if (first.pr != NoProc) {
ExitAnalyzeMode();
-
+
DoSleep( appData.delayBeforeQuit );
SendToProgram("quit\n", &first);
DoSleep( appData.delayAfterQuit );
DisplayBothClocks();
}
if (gameMode == PlayFromGameFile) {
- if (appData.timeDelay >= 0)
+ if (appData.timeDelay >= 0)
AutoPlayGameLoop();
} else if (gameMode == IcsExamining && pauseExamInvalid) {
Reset(FALSE, TRUE);
first.analyzing = TRUE;
/*first.maybeThinking = TRUE;*/
first.maybeThinking = FALSE; /* avoid killing GNU Chess */
- AnalysisPopUp(_("Analysis"),
- _("Starting analysis mode...\nIf this message stays up, your chess program does not support analysis."));
+ EngineOutputPopUp();
}
if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
pausing = FALSE;
first.analyzing = TRUE;
/*first.maybeThinking = TRUE;*/
first.maybeThinking = FALSE; /* avoid killing GNU Chess */
- AnalysisPopUp(_("Analysis"),
- _("Starting analysis mode...\nIf this message stays up, your chess program does not support analysis."));
+ EngineOutputPopUp();
}
gameMode = AnalyzeFile;
pausing = FALSE;
return;
- if (gameMode == PlayFromGameFile ||
- gameMode == TwoMachinesPlay ||
- gameMode == Training ||
- gameMode == AnalyzeMode ||
+ if (gameMode == PlayFromGameFile ||
+ gameMode == TwoMachinesPlay ||
+ gameMode == Training ||
+ gameMode == AnalyzeMode ||
gameMode == EndOfGame)
EditGameEvent();
- if (gameMode == EditPosition)
+ if (gameMode == EditPosition)
EditPositionDone();
if (!WhiteOnMove(currentMove)) {
DisplayError(_("It is not White's turn"), 0);
return;
}
-
+
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
ExitAnalyzeMode();
- if (gameMode == EditGame || gameMode == AnalyzeMode ||
+ if (gameMode == EditGame || gameMode == AnalyzeMode ||
gameMode == AnalyzeFile)
TruncateGame();
if(bookHit) { // [HGM] book: simulate book reply
static char bookMove[MSG_SIZ]; // a bit generous?
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
return;
- if (gameMode == PlayFromGameFile ||
- gameMode == TwoMachinesPlay ||
- gameMode == Training ||
- gameMode == AnalyzeMode ||
+ if (gameMode == PlayFromGameFile ||
+ gameMode == TwoMachinesPlay ||
+ gameMode == Training ||
+ gameMode == AnalyzeMode ||
gameMode == EndOfGame)
EditGameEvent();
- if (gameMode == EditPosition)
+ if (gameMode == EditPosition)
EditPositionDone();
if (WhiteOnMove(currentMove)) {
DisplayError(_("It is not Black's turn"), 0);
return;
}
-
+
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
ExitAnalyzeMode();
- if (gameMode == EditGame || gameMode == AnalyzeMode ||
+ if (gameMode == EditGame || gameMode == AnalyzeMode ||
gameMode == AnalyzeFile)
TruncateGame();
if(bookHit) { // [HGM] book: simulate book reply
static char bookMove[MSG_SIZ]; // a bit generous?
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
char buf[MSG_SIZ];
ChessProgramState *onmove;
char *bookHit = NULL;
-
+
if (appData.noChessProgram) return;
switch (gameMode) {
if(bookHit) { // [HGM] book: simulate book reply
static char bookMove[MSG_SIZ]; // a bit generous?
- programStats.nodes = programStats.depth = programStats.time =
+ programStats.nodes = programStats.depth = programStats.time =
programStats.score = programStats.got_only_move = 0;
sprintf(programStats.movelist, "%s (xbook)", bookHit);
case AnalyzeFile:
ExitAnalyzeMode();
break;
-
+
default:
EditGameEvent();
break;
default:
return;
}
-
+
pausing = FALSE;
StopClocks();
first.offeredDraw = second.offeredDraw = 0;
whiteFlag = blackFlag = 0;
}
DisplayTitle("");
- }
-
+ }
+
gameMode = EditGame;
ModeHighlight();
SetGameInfo();
EditGameEvent();
return;
}
-
+
EditGameEvent();
if (gameMode != EditGame) return;
-
+
gameMode = EditPosition;
ModeHighlight();
SetGameInfo();
if (currentMove > 0)
CopyBoard(boards[0], boards[currentMove]);
-
+
blackPlaysFirst = !WhiteOnMove(currentMove);
ResetClocks();
currentMove = forwardMostMove = backwardMostMove = 0;
SendToProgram("exit\n", &first);
first.analyzing = FALSE;
}
- AnalysisPopDown();
+ EngineOutputPopDown();
thinkOutput[0] = NULLCHAR;
}
len = strlen(buf);
if (len > MSG_SIZ)
len = MSG_SIZ;
-
+
strncpy(temp, buf, len);
temp[len] = 0;
piece > (int)BlackMan && piece <= (int)BlackKing ) {
selection = (ChessSquare) (DEMOTED piece);
} else if(piece == EmptySquare) selection = BlackSilver;
- else selection = (ChessSquare)((int)piece + 1);
+ else selection = (ChessSquare)((int)piece + 1);
goto defaultlabel;
case WhiteQueen:
AcceptEvent()
{
/* Accept a pending offer of any kind from opponent */
-
+
if (appData.icsActive) {
SendToICS(ics_prefix);
SendToICS("accept\n");
DeclineEvent()
{
/* Decline a pending offer of any kind from opponent */
-
+
if (appData.icsActive) {
SendToICS(ics_prefix);
SendToICS("decline\n");
DrawEvent()
{
/* Offer draw or accept pending draw offer from opponent */
-
+
if (appData.icsActive) {
/* Note: tournament rules require draw offers to be
made after you make your move but before you punch
your clock. Currently ICS doesn't let you do that;
instead, you immediately punch your clock after making
a move, but you can offer a draw at any time. */
-
+
SendToICS(ics_prefix);
SendToICS("draw\n");
} else if (cmailMsgLoaded) {
AdjournEvent()
{
/* Offer Adjourn or accept pending Adjourn offer from opponent */
-
+
if (appData.icsActive) {
SendToICS(ics_prefix);
SendToICS("adjourn\n");
AbortEvent()
{
/* Offer Abort or accept pending Abort offer from opponent */
-
+
if (appData.icsActive) {
SendToICS(ics_prefix);
SendToICS("abort\n");
ResignEvent()
{
/* Resign. You can do this even if it's not your turn. */
-
+
if (appData.icsActive) {
SendToICS(ics_prefix);
SendToICS("resign\n");
if (gameMode == PlayFromGameFile && !pausing)
PauseEvent();
-
+
if (gameMode == IcsExamining && pausing)
limit = pauseExamForwardMostMove;
else
limit = forwardMostMove;
-
+
if (target > limit) target = limit;
if (target > 0 && moveList[target - 1][0]) {
}
}
}
- if (gameMode == EditGame || gameMode == AnalyzeMode ||
- gameMode == Training || gameMode == PlayFromGameFile ||
+ if (gameMode == EditGame || gameMode == AnalyzeMode ||
+ gameMode == Training || gameMode == PlayFromGameFile ||
gameMode == AnalyzeFile) {
while (currentMove < target) {
SendMoveToProgram(currentMove++, &first);
} else {
currentMove = target;
}
-
+
if (gameMode == EditGame || gameMode == EndOfGame) {
whiteTimeRemaining = timeRemaining[0][currentMove];
blackTimeRemaining = timeRemaining[1][currentMove];
/* to optimze, we temporarily turn off analysis mode while we feed
* the remaining moves to the engine. Otherwise we get analysis output
* after each move.
- */
+ */
if (first.analysisSupport) {
SendToProgram("exit\nforce\n", &first);
first.analyzing = FALSE;
}
}
-
+
if (gameMode == IcsExamining && !pausing) {
SendToICS(ics_prefix);
SendToICS("forward 999999\n");
}
if (gameMode == PlayFromGameFile && !pausing)
PauseEvent();
-
+
if (moveList[target][0]) {
int fromX, fromY, toX, toY;
toX = moveList[target][2] - AAA;
} else {
currentMove = target;
}
-
+
if (gameMode == EditGame || gameMode == EndOfGame) {
whiteTimeRemaining = timeRemaining[0][currentMove];
blackTimeRemaining = timeRemaining[1][currentMove];
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
/* to optimze, we temporarily turn off analysis mode while we undo
* all the moves. Otherwise we get analysis output after each undo.
- */
+ */
if (first.analysisSupport) {
SendToProgram("exit\nforce\n", &first);
first.analyzing = FALSE;
int move;
{
int i, j;
-
+
for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
char c = PieceToChar(boards[move][i][j]);
if (cps->pr == NULL) return;
Attention(cps);
-
+
if (appData.debugMode) {
TimeMark now;
GetTimeMark(&now);
- fprintf(debugFP, "%ld >%-6s: %s",
+ fprintf(debugFP, "%ld >%-6s: %s",
SubtractTimeMarks(&now, &programStartTime),
cps->which, message);
}
-
+
count = strlen(message);
outCount = OutputToProcess(cps->pr, message, count, &error);
- if (outCount < count && !exiting
+ if (outCount < count && !exiting
&& !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
sprintf(buf, _("Error writing to %s chess program"), cps->which);
if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
}
return;
}
-
+
if ((end_str = strchr(message, '\r')) != NULL)
*end_str = NULLCHAR;
if ((end_str = strchr(message, '\n')) != NULL)
*end_str = NULLCHAR;
-
+
if (appData.debugMode) {
TimeMark now; int print = 1;
char *quote = ""; char c; int i;
if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
char start = message[0];
if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
- if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
+ if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
sscanf(message, "move %c", &c)!=1 && sscanf(message, "offer%c", &c)!=1 &&
sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
}
if(print) {
GetTimeMark(&now);
- fprintf(debugFP, "%ld <%-6s: %s%s\n",
- SubtractTimeMarks(&now, &programStartTime), cps->which,
+ fprintf(debugFP, "%ld <%-6s: %s%s\n",
+ SubtractTimeMarks(&now, &programStartTime), cps->which,
quote,
message);
}
/* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
if (appData.icsEngineAnalyze) {
if (strstr(message, "whisper") != NULL ||
- strstr(message, "kibitz") != NULL ||
+ strstr(message, "kibitz") != NULL ||
strstr(message, "tellics") != NULL) return;
}
ChessProgramState *WhitePlayer()
/* [HGM] return pointer to 'first' or 'second', depending on who plays white */
{
- if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
+ if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
return &second;
return &first;
if (time <= 0) time = 1;
if (otime <= 0) otime = 1;
-
+
sprintf(message, "time %ld\n", time);
SendToProgram(message, cps);
return FALSE;
}
-int
+int
ParseOption(Option *opt, ChessProgramState *cps)
// [HGM] options: process the string that defines an engine option, and determine
// name, type, default value, and allowed value range
void
ParseFeatures(args, cps)
char* args;
- ChessProgramState *cps;
+ ChessProgramState *cps;
{
char *p = args;
char *q;
if (*p == NULLCHAR) return;
if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
- if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
- if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
- if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
- if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
+ if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
+ if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
+ if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
+ if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
if (BoolFeature(&p, "reuse", &val, cps)) {
/* Engine can disable reuse, but can't enable it if user said no */
if (!val) cps->reuse = FALSE;
int newState = appData.showThinking
// [HGM] thinking: other features now need thinking output as well
|| !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
-
+
if (oldState == newState) return;
oldState = newState;
if (gameMode == EditPosition) EditPositionDone();
char cpThinkOutput[MSG_SIZ];
if(appData.noGUI) return; // [HGM] fast: suppress display of moves
-
- if (moveNumber == forwardMostMove - 1 ||
+
+ if (moveNumber == forwardMostMove - 1 ||
gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
DisplayAnalysisText(text)
char *text;
{
- char buf[MSG_SIZ];
-
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
- || appData.icsEngineAnalyze) {
- sprintf(buf, "Analysis (%s)", first.tidy);
- AnalysisPopUp(buf, text);
+ if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
+ || appData.icsEngineAnalyze)
+ {
+ EngineOutputPopUp();
}
}
double nps;
static char *xtra[] = { "", " (--)", " (++)" };
int h, m, s, cs;
-
+
if (programStats.time == 0) {
programStats.time = 1;
}
-
+
if (programStats.got_only_move) {
safeStrCpy(buf, programStats.movelist, sizeof(buf));
} else {
}
// [HGM] PV info: display PV info together with (or as) comment
if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
- if(text == NULL) text = "";
+ if(text == NULL) text = "";
score = pvInfoList[moveNumber].score;
sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
depth, (pvInfoList[moveNumber].time+50)/100, text);
struct timezone timeZone;
gettimeofday(&timeVal, &timeZone);
- tm->sec = (long) timeVal.tv_sec;
+ tm->sec = (long) timeVal.tv_sec;
tm->ms = (int) (timeVal.tv_usec / 1000L);
#else /*!HAVE_GETTIMEOFDAY*/
* We give the human user a slight advantage if he is playing white---the
* clocks don't run until he makes his first move, so it takes zero time.
* Also, we don't account for network lag, so we could get out of sync
- * with GNU Chess's clock -- but then, referees are always right.
+ * with GNU Chess's clock -- but then, referees are always right.
*/
static TimeMark tickStartTM;
/* Stop clocks and reset to a fresh time control */
void
-ResetClocks()
+ResetClocks()
{
(void) StopClockTimer();
if (appData.icsActive) {
if (!appData.clockMode) return;
if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
-
+
GetTimeMark(&now);
lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
}
if (CheckFlags()) return;
-
+
tickStartTM = now;
intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
StartClockTimer(intendedTickLength);
/* if the time remaining has fallen below the alarm threshold, sound the
* alarm. if the alarm has sounded and (due to a takeback or time control
* with increment) the time remaining has increased to a level above the
- * threshold, reset the alarm so it can sound again.
+ * threshold, reset the alarm so it can sound again.
*/
-
+
if (appData.icsActive && appData.icsAlarm) {
/* make sure we are dealing with the user's clock */
if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
alarmSounded = FALSE;
- } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
+ } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
PlayAlarmSound();
alarmSounded = TRUE;
}
whiteTimeRemaining -= lastTickLength;
/* [HGM] PGNtime: save time for PGN file if engine did not give it */
// if(pvInfoList[forwardMostMove-1].time == -1)
- pvInfoList[forwardMostMove-1].time =
+ pvInfoList[forwardMostMove-1].time =
(timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
}
flagged = CheckFlags();
whiteTimeRemaining : blackTimeRemaining);
StartClockTimer(intendedTickLength);
}
-
+
/* Stop both clocks */
void
StopClocks()
-{
+{
long lastTickLength;
TimeMark now;
}
CheckFlags();
}
-
+
/* Start clock of player on move. Time may have been reset, so
if clock is already running, stop and restart it. */
void
whiteTimeRemaining : blackTimeRemaining);
/* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
- whiteNPS = blackNPS = -1;
+ whiteNPS = blackNPS = -1;
if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
|| appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
whiteNPS = first.nps;
long second, minute, hour, day;
char *sign = "";
static char buf[32];
-
+
if (ms > 0 && ms <= 9900) {
/* convert milliseconds to tenths, rounding up */
double tenths = floor( ((double)(ms + 99L)) / 100.00 );
sign = "-";
second = -second;
}
-
+
day = second / (60 * 60 * 24);
second = second % (60 * 60 * 24);
hour = second / (60 * 60);
second = second % (60 * 60);
minute = second / 60;
second = second % 60;
-
+
if (day > 0)
sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
sign, day, hour, minute, second);
sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
else
sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
-
+
return buf;
}
char *string, *match;
{
int i, length;
-
+
length = strlen(match);
-
+
for (i = strlen(string) - length; i >= 0; i--, string++)
if (!strncmp(match, string, length))
return string;
-
+
return NULL;
}
char *string, *match;
{
int i, j, length;
-
+
length = strlen(match);
-
+
for (i = strlen(string) - length; i >= 0; i--, string++) {
for (j = 0; j < length; j++) {
if (ToLower(match[j]) != ToLower(string[j]))
char *s1, *s2;
{
char c1, c2;
-
+
for (;;) {
c1 = ToLower(*s1++);
c2 = ToLower(*s2++);
/* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
*p++ = '+';
piece = (ChessSquare)(DEMOTED piece);
- }
+ }
*p++ = PieceToChar(piece);
if(p[-1] == '~') {
/* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
}
if(gameInfo.variant != VariantShogi && gameInfo.variant != VariantXiangqi &&
- gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
+ gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
/* En passant target square */
if (move > backwardMostMove) {
fromX = moveList[move - 1][0] - AAA;
} else {
*p++ = '-';
}
+ } else if(move == backwardMostMove) {
+ // [HGM] perhaps we should always do it like this, and forget the above?
+ if(epStatus[move] >= 0) {
+ *p++ = epStatus[move] + AAA;
+ *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
+ } else {
+ *p++ = '-';
+ }
} else {
*p++ = '-';
}
}
/* Fullmove number */
sprintf(p, "%d", (move / 2) + 1);
-
+
return StrSave(buf);
}
case 'w':
*blackPlaysFirst = FALSE;
break;
- case 'b':
+ case 'b':
*blackPlaysFirst = TRUE;
break;
default:
/* read e.p. field in games that know e.p. capture */
if(gameInfo.variant != VariantShogi && gameInfo.variant != VariantXiangqi &&
- gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
+ gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
if(*p=='-') {
p++; FENepStatus = EP_NONE;
} else {
return TRUE;
}
-
+
void
EditPositionPasteFEN(char *fen)
{
* xboard.c -- X front end for XBoard
*
* Copyright 1991 by Digital Equipment Corporation, Maynard,
- * Massachusetts.
+ * Massachusetts.
*
* Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
* 2007, 2008, 2009 Free Software Foundation, Inc.
#include "bitmaps/bitmaps.h"
#endif
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
#include "bitmaps/icon_white.bm"
#include "bitmaps/icon_black.bm"
#include "bitmaps/checkmark.bm"
#include "xhistory.h"
#include "xedittags.h"
#include "gettext.h"
+#include "callback.h"
+#include "interface.h"
// must be moved to xengineoutput.h
MenuItem *mi;
} Menu;
+typedef struct {
+ char *name;
+ gboolean value;
+} Enables;
+
+
+
int main P((int argc, char **argv));
RETSIGTYPE CmailSigHandler P((int sig));
RETSIGTYPE IntSigHandler P((int sig));
+ RETSIGTYPE TermSizeSigHandler P((int sig));
void CreateGCs P((void));
void CreateXIMPieces P((void));
void CreateXPMPieces P((void));
void CreatePieces P((void));
void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb));
-Widget CreateButtonBar P ((MenuItem *mi));
char *FindFont P((char *pattern, int targetPxlSize));
void PieceMenuPopup P((Widget w, XEvent *event,
String *params, Cardinal *num_params));
static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
-void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
- u_int wreq, u_int hreq));
-void CreateGrid P((void));
int EventToSquare P((int x, int limit));
void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
-void EventProc P((Widget widget, caddr_t unused, XEvent *event));
void HandleUserMove P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void AnimateUserMove P((Widget w, XEvent * event,
String * params, Cardinal * nParams));
-void WhiteClock P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void BlackClock P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void DrawPositionProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
-void XDrawPosition P((Widget w, /*Boolean*/int repaint,
- Board board));
void CommentPopUp P((char *title, char *label));
void CommentPopDown P((void));
void CommentCallback P((Widget w, XtPointer client_data,
void EditCommentCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
-void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ReloadGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void LoadPositionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
-void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void CopyPositionProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void PastePositionProc P((Widget w, XEvent *event, String *prms,
void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
-void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void MachineBlackProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MachineWhiteProc P((Widget w, XEvent *event,
- String *prms, Cardinal *nprms));
void AnalyzeModeProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void AnalyzeFileProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
-void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void IcsClientProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void EditPositionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
String *prms, Cardinal *nprms));
void IcsInputBoxProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
-void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-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));
-void StopExaminingProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void TruncateGameProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void RetractMoveProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
-void AutocommProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
-void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AutobsProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void FlashMovesProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
-void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void GetMoveListProc P((Widget w, XEvent *event, String *prms,
- Cardinal *nprms));
void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
Cardinal *nprms));
void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
- 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));
-void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
-void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
void ErrorPopDown P((void));
static char *ExpandPathName P((char *path));
static void CreateAnimVars P((void));
-static void DragPieceBegin P((int x, int y));
+void DragPieceBegin P((int x, int y));
static void DragPieceMove P((int x, int y));
-static void DragPieceEnd P((int x, int y));
+void DragPieceEnd P((int x, int y));
static void DrawDragPiece P((void));
char *ModeToWidgetName P((GameMode mode));
void EngineOutputUpdate( FrontEndProgramStats * stats );
void TimeControlPopDown P(());
void NewVariantPopDown P(());
void SettingsPopDown P(());
+void SetMenuEnables P((Enables *enab));
-
+ void update_ics_width P(());
+ int get_term_width P(());
/*
* XBoard depends on Xt R4 or higher
*/
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
jailSquareColor, highlightSquareColor, premoveHighlightColor;
Pixel lowTimeWarningColor;
-GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
- bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
- wjPieceGC, bjPieceGC, prelineGC, countGC;
+
+#define LINE_TYPE_NORMAL 0
+#define LINE_TYPE_HIGHLIGHT 1
+#define LINE_TYPE_PRE 2
+
+
+GC lightSquareGC, darkSquareGC, jailSquareGC, wdPieceGC, wlPieceGC,
+ bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC,
+ wjPieceGC, bjPieceGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
- menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
+ menuBarWidget, editShell, errorShell, analysisShell,
ICSInputShell, fileNameShell, askQuestionShell;
-XSegment gridSegments[(BOARD_SIZE + 1) * 2];
-XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
Font clockFontID, coordFontID, countFontID;
XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
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;
+int useImages=0, useImageSqs;
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 */
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
+Enables icsEnables[] = {
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Analysis Mode", False },
+ { "menuMode.Analyze File", False },
+ { "menuMode.Two Machines", False },
+#ifndef ZIPPY
+ { "menuHelp.Hint", False },
+ { "menuHelp.Book", False },
+ { "menuStep.Move Now", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Ponder Next Move", False },
+#endif
+ { NULL, False }
+};
+
+Enables ncpEnables[] = {
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Analysis Mode", False },
+ { "menuMode.Analyze File", False },
+ { "menuMode.Two Machines", False },
+ { "menuMode.ICS Client", False },
+ { "menuMode.ICS Input Box", False },
+ { "Action", False },
+ { "menuStep.Revert", False },
+ { "menuStep.Move Now", False },
+ { "menuStep.Retract Move", False },
+ { "menuOptions.Auto Comment", False },
+ { "menuOptions.Auto Flag", False },
+ { "menuOptions.Auto Flip View", False },
+ { "menuOptions.Auto Observe", False },
+ { "menuOptions.Auto Raise Board", False },
+ { "menuOptions.Get Move List", False },
+ { "menuOptions.ICS Alarm", False },
+ { "menuOptions.Move Sound", False },
+ { "menuOptions.Quiet Play", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Ponder Next Move", False },
+ { "menuHelp.Hint", False },
+ { "menuHelp.Book", False },
+ { NULL, False }
+};
+
+Enables gnuEnables[] = {
+ { "menuMode.ICS Client", False },
+ { "menuMode.ICS Input Box", False },
+ { "menuAction.Accept", False },
+ { "menuAction.Decline", False },
+ { "menuAction.Rematch", False },
+ { "menuAction.Adjourn", False },
+ { "menuAction.Stop Examining", False },
+ { "menuAction.Stop Observing", False },
+ { "menuStep.Revert", False },
+ { "menuOptions.Auto Comment", False },
+ { "menuOptions.Auto Observe", False },
+ { "menuOptions.Auto Raise Board", False },
+ { "menuOptions.Get Move List", False },
+ { "menuOptions.Premove", False },
+ { "menuOptions.Quiet Play", False },
+
+ /* The next two options rely on SetCmailMode being called *after* */
+ /* SetGNUMode so that when GNU is being used to give hints these */
+ /* menu options are still available */
+
+ { "menuFile.Mail Move", False },
+ { "menuFile.Reload CMail Message", False },
+ { NULL, False }
+};
+
+Enables cmailEnables[] = {
+ { "Action", True },
+ { "menuAction.Call Flag", False },
+ { "menuAction.Draw", True },
+ { "menuAction.Adjourn", False },
+ { "menuAction.Abort", False },
+ { "menuAction.Stop Observing", False },
+ { "menuAction.Stop Examining", False },
+ { "menuFile.Mail Move", True },
+ { "menuFile.Reload CMail Message", True },
+ { NULL, False }
+};
+
+Enables trainingOnEnables[] = {
+ { "menuMode.Edit Comment", False },
+ { "menuMode.Pause", False },
+ { "menuStep.Forward", False },
+ { "menuStep.Backward", False },
+ { "menuStep.Forward to End", False },
+ { "menuStep.Back to Start", False },
+ { "menuStep.Move Now", False },
+ { "menuStep.Truncate Game", False },
+ { NULL, False }
+};
+
+Enables trainingOffEnables[] = {
+ { "menuMode.Edit Comment", True },
+ { "menuMode.Pause", True },
+ { "menuStep.Forward", True },
+ { "menuStep.Backward", True },
+ { "menuStep.Forward to End", True },
+ { "menuStep.Back to Start", True },
+ { "menuStep.Move Now", True },
+ { "menuStep.Truncate Game", True },
+ { NULL, False }
+};
+
+Enables machineThinkingEnables[] = {
+ { "menuFile.Load Game", False },
+ { "menuFile.Load Next Game", False },
+ { "menuFile.Load Previous Game", False },
+ { "menuFile.Reload Same Game", False },
+ { "menuFile.Paste Game", False },
+ { "menuFile.Load Position", False },
+ { "menuFile.Load Next Position", False },
+ { "menuFile.Load Previous Position", False },
+ { "menuFile.Reload Same Position", False },
+ { "menuFile.Paste Position", False },
+ { "menuMode.Machine White", False },
+ { "menuMode.Machine Black", False },
+ { "menuMode.Two Machines", False },
+ { "menuStep.Retract Move", False },
+ { NULL, False }
+};
+
+Enables userThinkingEnables[] = {
+ { "menuFile.Load Game", True },
+ { "menuFile.Load Next Game", True },
+ { "menuFile.Load Previous Game", True },
+ { "menuFile.Reload Same Game", True },
+ { "menuFile.Paste Game", True },
+ { "menuFile.Load Position", True },
+ { "menuFile.Load Next Position", True },
+ { "menuFile.Load Previous Position", True },
+ { "menuFile.Reload Same Position", True },
+ { "menuFile.Paste Position", True },
+ { "menuMode.Machine White", True },
+ { "menuMode.Machine Black", True },
+ { "menuMode.Two Machines", True },
+ { "menuStep.Retract Move", True },
+ { NULL, False }
+};
+
+
+
MenuItem fileMenu[] = {
{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_("Load Previous Game"), LoadPrevGameProc},
- {N_("Reload Same Game"), ReloadGameProc},
{N_("Save Game"), SaveGameProc},
{"----", NothingProc},
{N_("Copy Game"), CopyGameProc},
{N_("Paste Game"), PasteGameProc},
{"----", NothingProc},
{N_("Load Position"), LoadPositionProc},
- {N_("Load Next Position"), LoadNextPositionProc},
- {N_("Load Previous Position"), LoadPrevPositionProc},
- {N_("Reload Same Position"), ReloadPositionProc},
+ // {N_("Load Next Position"), LoadNextPositionProc},
+ // {N_("Load Previous Position"), LoadPrevPositionProc},
+ // {N_("Reload Same Position"), ReloadPositionProc},
{N_("Save Position"), SavePositionProc},
{"----", NothingProc},
{N_("Copy Position"), CopyPositionProc},
{N_("Mail Move"), MailMoveProc},
{N_("Reload CMail Message"), ReloadCmailMsgProc},
{"----", NothingProc},
- {N_("Exit"), QuitProc},
{NULL, NULL}
};
MenuItem modeMenu[] = {
- {N_("Machine White"), MachineWhiteProc},
- {N_("Machine Black"), MachineBlackProc},
- {N_("Two Machines"), TwoMachinesProc},
+ // {N_("Machine White"), MachineWhiteProc},
+ // {N_("Machine Black"), MachineBlackProc},
+ // {N_("Two Machines"), TwoMachinesProc},
{N_("Analysis Mode"), AnalyzeModeProc},
{N_("Analyze File"), AnalyzeFileProc },
- {N_("ICS Client"), IcsClientProc},
+ // {N_("ICS Client"), IcsClientProc},
{N_("Edit Game"), EditGameProc},
{N_("Edit Position"), EditPositionProc},
{N_("Training"), TrainingProc},
{N_("Show Engine Output"), EngineOutputProc},
{N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
{N_("Show Game List"), ShowGameListProc},
- {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
+ // {"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_("Pause"), PauseProc},
- {NULL, NULL}
-};
-
-MenuItem actionMenu[] = {
- {N_("Accept"), AcceptProc},
- {N_("Decline"), DeclineProc},
- {N_("Rematch"), RematchProc},
- {"----", NothingProc},
- {N_("Call Flag"), CallFlagProc},
- {N_("Draw"), DrawProc},
- {N_("Adjourn"), AdjournProc},
- {N_("Abort"), AbortProc},
- {N_("Resign"), ResignProc},
- {"----", 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}
-};
-
-MenuItem stepMenu[] = {
- {N_("Backward"), BackwardProc},
- {N_("Forward"), ForwardProc},
- {N_("Back to Start"), ToStartProc},
- {N_("Forward to End"), ToEndProc},
- {N_("Revert"), RevertProc},
- {N_("Truncate Game"), TruncateGameProc},
- {"----", NothingProc},
- {N_("Move Now"), MoveNowProc},
- {N_("Retract Move"), RetractMoveProc},
{NULL, NULL}
};
MenuItem optionsMenu[] = {
- {N_("Flip View"), FlipViewProc},
- {"----", NothingProc},
+ // {N_("Flip View"), FlipViewProc},
+ // {"----", NothingProc},
{N_("Adjudications ..."), EngineMenuProc},
{N_("General Settings ..."), UciMenuProc},
{N_("Engine #1 Settings ..."), FirstSettingsProc},
{N_("Always Queen"), AlwaysQueenProc},
{N_("Animate Dragging"), AnimateDraggingProc},
{N_("Animate Moving"), AnimateMovingProc},
- {N_("Auto Comment"), AutocommProc},
- {N_("Auto Flag"), AutoflagProc},
- {N_("Auto Flip View"), AutoflipProc},
+ // {N_("Auto Comment"), AutocommProc},
+ // {N_("Auto Flag"), AutoflagProc},
+ // {N_("Auto Flip View"), AutoflipProc},
{N_("Auto Observe"), AutobsProc},
{N_("Auto Raise Board"), AutoraiseProc},
{N_("Auto Save"), AutosaveProc},
{N_("Blindfold"), BlindfoldProc},
{N_("Flash Moves"), FlashMovesProc},
- {N_("Get Move List"), GetMoveListProc},
+ // {N_("Get Move List"), GetMoveListProc},
#if HIGHDRAG
{N_("Highlight Dragging"), HighlightDraggingProc},
#endif
{N_("Popup Move Errors"), PopupMoveErrorsProc},
{N_("Premove"), PremoveProc},
{N_("Quiet Play"), QuietPlayProc},
- {N_("Show Coords"), ShowCoordsProc},
- {N_("Hide Thinking"), HideThinkingProc},
+ // {N_("Hide Thinking"), HideThinkingProc},
{N_("Test Legality"), TestLegalityProc},
{NULL, NULL}
};
Menu menuBar[] = {
{N_("File"), fileMenu},
{N_("Mode"), modeMenu},
- {N_("Action"), actionMenu},
- {N_("Step"), stepMenu},
{N_("Options"), optionsMenu},
- {N_("Help"), helpMenu},
- {NULL, NULL}
-};
-
-#define PAUSE_BUTTON N_("P")
-MenuItem buttonBar[] = {
- {"<<", ToStartProc},
- {"<", BackwardProc},
- {PAUSE_BUTTON, PauseProc},
- {">", ForwardProc},
- {">>", ToEndProc},
{NULL, NULL}
};
#define PIECE_MENU_SIZE 18
String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
{ N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
+ N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
N_("Empty square"), N_("Clear board") },
{ N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
- N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
- N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
+ N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
+ N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
N_("Empty square"), N_("Clear board") }
};
/* must be in same order as PieceMenuStrings! */
ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
{ WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
- WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
+ WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
PromotePiece, DemotePiece, EmptySquare, ClearBoard },
{ BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
- BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
+ BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
PromotePiece, DemotePiece, EmptySquare, ClearBoard },
};
{ 'Q', "Queen" }
};
-Arg shellArgs[] = {
- { XtNwidth, 0 },
- { XtNheight, 0 },
- { XtNminWidth, 0 },
- { XtNminHeight, 0 },
- { XtNmaxWidth, 0 },
- { XtNmaxHeight, 0 }
-};
-
Arg layoutArgs[] = {
{ XtNborderWidth, 0 },
{ XtNdefaultDistance, 0 },
{ XtNheight, 0 }
};
-Arg titleArgs[] = {
- { XtNjustify, (XtArgVal) XtJustifyRight },
- { XtNlabel, (XtArgVal) "..." },
- { XtNresizable, (XtArgVal) True },
- { XtNresize, (XtArgVal) False }
-};
-
-Arg messageArgs[] = {
- { XtNjustify, (XtArgVal) XtJustifyLeft },
- { XtNlabel, (XtArgVal) "..." },
- { XtNresizable, (XtArgVal) True },
- { XtNresize, (XtArgVal) False }
-};
-
-Arg timerArgs[] = {
- { XtNborderWidth, 0 },
- { XtNjustify, (XtArgVal) XtJustifyLeft }
-};
-
XtResource clientResources[] = {
{ "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
XtOffset(AppDataPtr, whitePieceColor), XtRString,
{ "forceIllegalMoves", "forceIllegalMoves", XtRBoolean,
sizeof(Boolean), XtOffset(AppDataPtr, forceIllegal),
XtRImmediate, (XtPointer) False},
+ { "keepLineBreaksICS", "keepLineBreaksICS", XtRBoolean,
+ sizeof(Boolean), XtOffset(AppDataPtr, noJoin),
+ XtRImmediate, (XtPointer) True},
};
XrmOptionDescRec shellOptions[] = {
{ "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
{ "-keepAlive", "keepAlive", XrmoptionSepArg, NULL },
{ "-forceIllegalMoves", "forceIllegalMoves", XrmoptionNoArg, "True" },
+ { "-keepLineBreaksICS", "keepLineBreaksICS", XrmoptionSepArg, NULL },
};
XtActionsRec boardActions[] = {
- { "DrawPosition", DrawPositionProc },
{ "HandleUserMove", HandleUserMove },
{ "AnimateUserMove", AnimateUserMove },
{ "FileNameAction", FileNameAction },
{ "AskQuestionProc", AskQuestionProc },
{ "AskQuestionReplyAction", AskQuestionReplyAction },
{ "PieceMenuPopup", PieceMenuPopup },
- { "WhiteClock", WhiteClock },
- { "BlackClock", BlackClock },
+ // { "WhiteClock", WhiteClock },
+ // { "BlackClock", BlackClock },
{ "Iconify", Iconify },
- { "ResetProc", ResetProc },
- { "LoadGameProc", LoadGameProc },
- { "LoadNextGameProc", LoadNextGameProc },
- { "LoadPrevGameProc", LoadPrevGameProc },
{ "LoadSelectedProc", LoadSelectedProc },
- { "ReloadGameProc", ReloadGameProc },
{ "LoadPositionProc", LoadPositionProc },
- { "LoadNextPositionProc", LoadNextPositionProc },
- { "LoadPrevPositionProc", LoadPrevPositionProc },
- { "ReloadPositionProc", ReloadPositionProc },
+ // { "LoadNextPositionProc", LoadNextPositionProc },
+ // { "LoadPrevPositionProc", LoadPrevPositionProc },
+ // { "ReloadPositionProc", ReloadPositionProc },
{ "CopyPositionProc", CopyPositionProc },
{ "PastePositionProc", PastePositionProc },
{ "CopyGameProc", CopyGameProc },
{ "SavePositionProc", SavePositionProc },
{ "MailMoveProc", MailMoveProc },
{ "ReloadCmailMsgProc", ReloadCmailMsgProc },
- { "QuitProc", QuitProc },
- { "MachineWhiteProc", MachineWhiteProc },
- { "MachineBlackProc", MachineBlackProc },
+ // { "MachineWhiteProc", MachineWhiteProc },
+ // { "MachineBlackProc", MachineBlackProc },
{ "AnalysisModeProc", AnalyzeModeProc },
{ "AnalyzeFileProc", AnalyzeFileProc },
- { "TwoMachinesProc", TwoMachinesProc },
- { "IcsClientProc", IcsClientProc },
+ // { "TwoMachinesProc", TwoMachinesProc },
+ // { "IcsClientProc", IcsClientProc },
{ "EditGameProc", EditGameProc },
{ "EditPositionProc", EditPositionProc },
{ "TrainingProc", EditPositionProc },
{ "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
{ "ShowGameListProc", ShowGameListProc },
- { "ShowMoveListProc", HistoryShowProc},
+ // { "ShowMoveListProc", HistoryShowProc},
{ "EditTagsProc", EditCommentProc },
{ "EditCommentProc", EditCommentProc },
{ "IcsAlarmProc", IcsAlarmProc },
{ "IcsInputBoxProc", IcsInputBoxProc },
- { "PauseProc", PauseProc },
- { "AcceptProc", AcceptProc },
- { "DeclineProc", DeclineProc },
- { "RematchProc", RematchProc },
- { "CallFlagProc", CallFlagProc },
- { "DrawProc", DrawProc },
- { "AdjournProc", AdjournProc },
- { "AbortProc", AbortProc },
- { "ResignProc", ResignProc },
- { "AdjuWhiteProc", AdjuWhiteProc },
- { "AdjuBlackProc", AdjuBlackProc },
- { "AdjuDrawProc", AdjuDrawProc },
+ // { "AcceptProc", AcceptProc },
+ // { "DeclineProc", DeclineProc },
+ // { "RematchProc", RematchProc },
+ // { "CallFlagProc", CallFlagProc },
+ // { "DrawProc", DrawProc },
+ // { "AdjournProc", AdjournProc },
+ // { "AbortProc", AbortProc },
+ // { "ResignProc", ResignProc },
+ // { "AdjuWhiteProc", AdjuWhiteProc },
+ // { "AdjuBlackProc", AdjuBlackProc },
+ // { "AdjuDrawProc", AdjuDrawProc },
{ "EnterKeyProc", EnterKeyProc },
- { "StopObservingProc", StopObservingProc },
- { "StopExaminingProc", StopExaminingProc },
- { "BackwardProc", BackwardProc },
- { "ForwardProc", ForwardProc },
- { "ToStartProc", ToStartProc },
- { "ToEndProc", ToEndProc },
- { "RevertProc", RevertProc },
- { "TruncateGameProc", TruncateGameProc },
- { "MoveNowProc", MoveNowProc },
- { "RetractMoveProc", RetractMoveProc },
+ // { "StopObservingProc", StopObservingProc },
+ // { "StopExaminingProc", StopExaminingProc },
+ // { "BackwardProc", BackwardProc },
+ // { "ForwardProc", ForwardProc },
+ // { "ToStartProc", ToStartProc },
+ // { "ToEndProc", ToEndProc },
+ // { "RevertProc", RevertProc },
+ // { "TruncateGameProc", TruncateGameProc },
+ // { "MoveNowProc", MoveNowProc },
+ // { "RetractMoveProc", RetractMoveProc },
{ "AlwaysQueenProc", AlwaysQueenProc },
{ "AnimateDraggingProc", AnimateDraggingProc },
{ "AnimateMovingProc", AnimateMovingProc },
- { "AutoflagProc", AutoflagProc },
- { "AutoflipProc", AutoflipProc },
+ // { "AutoflagProc", AutoflagProc },
+ // { "AutoflipProc", AutoflipProc },
{ "AutobsProc", AutobsProc },
{ "AutoraiseProc", AutoraiseProc },
{ "AutosaveProc", AutosaveProc },
{ "BlindfoldProc", BlindfoldProc },
{ "FlashMovesProc", FlashMovesProc },
- { "FlipViewProc", FlipViewProc },
- { "GetMoveListProc", GetMoveListProc },
+ // { "FlipViewProc", FlipViewProc },
+ // { "GetMoveListProc", GetMoveListProc },
#if HIGHDRAG
{ "HighlightDraggingProc", HighlightDraggingProc },
#endif
{ "PopupMoveErrorsProc", PopupMoveErrorsProc },
{ "PremoveProc", PremoveProc },
{ "QuietPlayProc", QuietPlayProc },
- { "ShowCoordsProc", ShowCoordsProc },
- { "ShowThinkingProc", ShowThinkingProc },
- { "HideThinkingProc", HideThinkingProc },
+ // { "ShowThinkingProc", ShowThinkingProc },
+ // { "HideThinkingProc", HideThinkingProc },
{ "TestLegalityProc", TestLegalityProc },
- { "InfoProc", InfoProc },
- { "ManProc", ManProc },
- { "HintProc", HintProc },
- { "BookProc", BookProc },
+ // { "InfoProc", InfoProc },
+ // { "ManProc", ManProc },
+ // { "HintProc", HintProc },
+ // { "BookProc", BookProc },
{ "AboutGameProc", AboutGameProc },
- { "AboutProc", AboutProc },
{ "DebugProc", DebugProc },
{ "NothingProc", NothingProc },
{ "CommentPopDown", (XtActionProc) CommentPopDown },
{ "TagsPopDown", (XtActionProc) TagsPopDown },
{ "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
- { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
+ { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
{ "FileNamePopDown", (XtActionProc) FileNamePopDown },
{ "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
- { "HistoryPopDown", (XtActionProc) HistoryPopDown },
+ // { "HistoryPopDown", (XtActionProc) HistoryPopDown },
{ "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
{ "ShufflePopDown", (XtActionProc) ShufflePopDown },
{ "EnginePopDown", (XtActionProc) EnginePopDown },
{ "SettingsPopDown", (XtActionProc) SettingsPopDown },
};
-char globalTranslations[] =
- ":<Key>R: ResignProc() \n \
- :<Key>r: ResetProc() \n \
- :<Key>g: LoadGameProc() \n \
- :<Key>N: LoadNextGameProc() \n \
- :<Key>P: LoadPrevGameProc() \n \
- :<Key>Q: QuitProc() \n \
- :<Key>F: ToEndProc() \n \
- :<Key>f: ForwardProc() \n \
- :<Key>B: ToStartProc() \n \
- :<Key>b: BackwardProc() \n \
- :<Key>p: PauseProc() \n \
- :<Key>d: DrawProc() \n \
- :<Key>t: CallFlagProc() \n \
- :<Key>i: Iconify() \n \
- :<Key>c: Iconify() \n \
- :<Key>v: FlipViewProc() \n \
- <KeyDown>Control_L: BackwardProc() \n \
- <KeyUp>Control_L: ForwardProc() \n \
- <KeyDown>Control_R: BackwardProc() \n \
- <KeyUp>Control_R: ForwardProc() \n \
- Shift<Key>1: AskQuestionProc(\"Direct command\",\
- \"Send to chess program:\",,1) \n \
- Shift<Key>2: AskQuestionProc(\"Direct command\",\
- \"Send to second chess program:\",,2) \n";
-
-char boardTranslations[] =
- "<Btn1Down>: HandleUserMove() \n \
- <Btn1Up>: HandleUserMove() \n \
- <Btn1Motion>: AnimateUserMove() \n \
- Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
- PieceMenuPopup(menuB) \n \
- Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
- PieceMenuPopup(menuW) \n \
- Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
- PieceMenuPopup(menuW) \n \
- Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
- PieceMenuPopup(menuB) \n";
-
-char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
-char blackTranslations[] = "<BtnDown>: BlackClock()\n";
char ICSInputTranslations[] =
"<Key>Return: EnterKeyProc() \n";
NULL
};
-
-/* Max possible square size */
-#define MAXSQSIZE 256
-
-static int xpm_avail[MAXSQSIZE];
-
-#ifdef HAVE_DIR_STRUCT
-
-/* Extract piece size from filename */
-static int
-xpm_getsize(name, len, ext)
- char *name;
- int len;
- char *ext;
-{
- 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;
-
- while (*p && isdigit(*p))
- *(d++) = *(p++);
-
- *d = 0;
- return atoi(buf);
-}
-
-/* Setup xpm_avail */
-static int
-xpm_getavail(dirname, ext)
- char *dirname;
- char *ext;
-{
- DIR *dir;
- struct dirent *ent;
- int i;
-
- for (i=0; i<MAXSQSIZE; ++i)
- xpm_avail[i] = 0;
-
- 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"),
- programName, dirname);
- exit(1);
- }
-
- while ((ent=readdir(dir)) != NULL) {
- i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
- if (i > 0 && i < MAXSQSIZE)
- xpm_avail[i] = 1;
- }
-
- closedir(dir);
-
- return 0;
-}
-
-void
-xpm_print_avail(fp, ext)
- FILE *fp;
- char *ext;
-{
- int i;
-
- fprintf(fp, _("Available `%s' sizes:\n"), ext);
- for (i=1; i<MAXSQSIZE; ++i) {
- if (xpm_avail[i])
- printf("%d\n", i);
- }
-}
-
-/* Return XPM piecesize closest to size */
-int
-xpm_closest_to(dirname, size, ext)
- char *dirname;
- int size;
- char *ext;
-{
- int i;
- 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;
- diff = (diff<0) ? -diff : diff;
- if (diff < sm_diff) {
- sm_diff = diff;
- sm_index = i;
- }
- }
- }
-
- if (!sm_index) {
- fprintf(stderr, _("Error: No `%s' files!\n"), ext);
- exit(1);
- }
-
- return sm_index;
-}
-#else /* !HAVE_DIR_STRUCT */
-/* If we are on a system without a DIR struct, we can't
- read the directory, so we can't collect a list of
- filenames, etc., so we can't do any size-fitting. */
-int
-xpm_closest_to(dirname, size, ext)
- char *dirname;
- int size;
- char *ext;
-{
- fprintf(stderr, _("\
-Warning: No DIR structure found on this system --\n\
- Unable to autosize for XPM/XIM pieces.\n\
- Please report this error to frankm@hiwaay.net.\n\
- Include system type & operating system in message.\n"));
- return size;
-}
-#endif /* HAVE_DIR_STRUCT */
-
static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
"magenta", "cyan", "white" };
typedef struct {
void
BoardToTop()
{
- Arg args[16];
- XtSetArg(args[0], XtNiconic, False);
- XtSetValues(shellWidget, args, 1);
-
- XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
+ /* this should raise the board to the top */
+ gtk_window_present(GTK_WINDOW(GUI_Window));
+ return;
}
-#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)
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);
+ 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) {
+ if (appData.titleInWindow)
+ {
i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(titleWidget, args, i);
- if (smallLayout) {
+ if (smallLayout)
+ {
w = boardWidth - 2*bor;
- } else {
- XtSetArg(args[0], XtNwidth, &w);
- XtGetValues(menuBarWidget, args, 1);
+ }
+ else
+ {
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);
+ if(!formWidget) return;
/*
* 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)
CreateAnimVars();
#endif
}
-#endif
void EscapeExpand(char *p, char *q)
{ // [HGM] initstring: routine to shape up string arguments
char *p;
XrmDatabase xdb;
int forceMono = False;
+
#define INDIRECTION
#ifdef INDIRECTION
// [HGM] before anything else, expand any indirection files amongst options
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]);
+ //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");
XtAppInitialize(&appContext, "XBoard", shellOptions,
XtNumber(shellOptions),
&argc, argv, xboardResources, NULL, 0);
- if (argc > 1)
- { /* left over command line arguments, print out help and exit.
- * Use two columns to print help
- */
+
+ /* set up GTK */
+ gtk_init (&argc, &argv);
+
+ /* parse glade file to build widgets */
+
+ builder = gtk_builder_new ();
+ gtk_builder_add_from_file (builder, "gtk-interface.xml", NULL);
+
+ /* test if everything worked ok */
+
+ GUI_Window = GTK_WIDGET (gtk_builder_get_object (builder, "MainWindow"));
+ if(!GUI_Window) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_History = GTK_WIDGET (gtk_builder_get_object (builder, "MoveHistory"));
+ if(!GUI_History) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Menubar = GTK_WIDGET (gtk_builder_get_object (builder, "MenuBar"));
+ if(!GUI_Menubar) printf("Error: gtk_builder didn't work!\n");
+ GUI_Timer = GTK_WIDGET (gtk_builder_get_object (builder, "Timer"));
+ if(!GUI_Timer) printf("Error: gtk_builder didn't work!\n");
+ GUI_Buttonbar = GTK_WIDGET (gtk_builder_get_object (builder, "ButtonBar"));
+ if(!GUI_Buttonbar) printf("Error: gtk_builder didn't work!\n");
+ GUI_Board = GTK_WIDGET (gtk_builder_get_object (builder, "Board"));
+ if(!GUI_Board) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Whiteclock = GTK_WIDGET (gtk_builder_get_object (builder, "WhiteClock"));
+ if(!GUI_Whiteclock) printf("Error: gtk_builder didn't work!\n");
+
+ GUI_Blackclock = GTK_WIDGET (gtk_builder_get_object (builder, "BlackClock"));
+ if(!GUI_Blackclock) printf("Error: gtk_builder didn't work!\n");
+
+ LIST_MoveHistory = GTK_LIST_STORE (gtk_builder_get_object (builder, "MoveHistoryStore"));
+ if(!LIST_MoveHistory) printf("Error: gtk_builder didn't work!\n");
+
+
+ gtk_builder_connect_signals (builder, NULL);
+
+ // don't unref the builder, since we use it to get references to widgets
+ // g_object_unref (G_OBJECT (builder));
+
+ /* end parse glade file */
+
+ if (argc > 1)
+ {
fprintf(stderr, _("%s: unrecognized argument %s\n"),
programName, argv[1]);
/* [HGM,HR] make sure board size is acceptable */
if(appData.NrFiles > BOARD_SIZE ||
appData.NrRanks > BOARD_SIZE )
- DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
+ 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);
+ gameInfo.variant = StringToVariant(appData.variant);
+ InitPosition(FALSE);
-#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,
+ /* calc board size */
+ if (isdigit(appData.boardSize[0]))
+ {
+ i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
&lineGap, &clockFontPxlSize, &coordFontPxlSize,
&fontPxlSize, &smallLayout, &tinyLayout);
- if (i == 0) {
+ if (i == 0)
+ {
fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
programName, appData.boardSize);
exit(2);
- }
- if (i < 7) {
+ }
+ if (i < 7)
+ {
/* Find some defaults; use the nearest known size */
SizeDefaults *szd, *nearest;
int distance = 99999;
nearest = szd = sizeDefaults;
- while (szd->name != NULL) {
- if (abs(szd->squareSize - squareSize) < distance) {
+ while (szd->name != NULL)
+ {
+ if (abs(szd->squareSize - squareSize) < distance)
+ {
nearest = szd;
distance = abs(szd->squareSize - squareSize);
if (distance == 0) break;
- }
+ }
szd++;
- }
+ };
if (i < 2) lineGap = nearest->lineGap;
if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
if (i < 5) fontPxlSize = nearest->fontPxlSize;
if (i < 6) smallLayout = nearest->smallLayout;
if (i < 7) tinyLayout = nearest->tinyLayout;
- }
- } else {
+ }
+ }
+ else
+ {
SizeDefaults *szd = sizeDefaults;
- if (*appData.boardSize == NULLCHAR) {
- while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
- DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
- szd++;
- }
+ if (*appData.boardSize == NULLCHAR)
+ {
+ while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize
+ || DisplayHeight(xDisplay, xScreen) < szd->minScreenSize)
+ {
+ szd++;
+ }
if (szd->name == NULL) szd--;
- } else {
- while (szd->name != NULL &&
- StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
- if (szd->name == NULL) {
+ }
+ else
+ {
+ while (szd->name != NULL
+ && StrCaseCmp(szd->name, appData.boardSize) != 0)
+ szd++;
+ if (szd->name == NULL)
+ {
fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
programName, appData.boardSize);
exit(2);
- }
- }
+ }
+ }
squareSize = szd->squareSize;
lineGap = szd->lineGap;
clockFontPxlSize = szd->clockFontPxlSize;
fontPxlSize = szd->fontPxlSize;
smallLayout = szd->smallLayout;
tinyLayout = szd->tinyLayout;
- }
-
- /* Now, using squareSize as a hint, find a good XPM/XIM set size */
- if (strlen(appData.pixmapDirectory) > 0) {
- p = ExpandPathName(appData.pixmapDirectory);
- if (!p) {
- fprintf(stderr, _("Error expanding path name \"%s\"\n"),
- appData.pixmapDirectory);
- exit(1);
- }
- if (appData.debugMode) {
- fprintf(stderr, _("\
-XBoard square size (hint): %d\n\
-%s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
- }
- squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
- if (appData.debugMode) {
- fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
- }
- }
-
- /* [HR] height treated separately (hacked) */
- boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ }
+ /* end figuring out what size to use */
+
+ 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,
- boardHeight + 2*(lineGap + squareSize));
- } else if (appData.showJail == 2) {
- /* Jail on sides */
- XtSetArg(boardArgs[1], XtNwidth,
- boardWidth + 2*(lineGap + squareSize));
- XtSetArg(boardArgs[2], XtNheight, boardHeight);
- } else {
- /* No jail */
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight, boardHeight);
- }
-
+
/*
* Determine what fonts to use.
*/
if (forceMono) {
fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
programName);
-
+
if (appData.bitmapDirectory == NULL ||
appData.bitmapDirectory[0] == NULLCHAR)
appData.bitmapDirectory = DEF_BITMAP_DIR;
vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
vFrom.size = strlen(appData.lowTimeWarningColor);
XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
- if (vTo.addr == NULL)
+ if (vTo.addr == NULL)
appData.monoMode = True;
else
lowTimeWarningColor = *(Pixel *) vTo.addr;
textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
textColors[ColorNone].attr = 0;
- XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
+ // XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
/*
* widget hierarchy
} else {
layoutName = "normalLayout";
}
- /* Outer layoutWidget is there only to provide a name for use in
- resources that depend on the layout style */
- layoutWidget =
- XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
- layoutArgs, XtNumber(layoutArgs));
- formWidget =
- XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
- 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);
- 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);
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainTop);
- XtSetValues(blackTimerWidget, args, 3);
if (appData.titleInWindow) {
- widgetList[j++] = titleWidget =
- XtCreateWidget("title", labelWidgetClass, formWidget,
- titleArgs, XtNumber(titleArgs));
- XtSetArg(args[0], XtNtop, XtChainTop);
- XtSetArg(args[1], XtNbottom, XtChainTop);
- XtSetValues(titleWidget, args, 2);
+ /* todo check what this appdata does */
}
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);
+ /* TODO hide button bar if requested */
}
- 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));
+ if (appData.titleInWindow)
+ {
+ if (smallLayout)
+ {
+ /* make it small */
+ if (appData.showButtonBar)
+ {
- XtManageChildren(widgetList, j);
+ }
+ }
+ else
+ {
+ if (appData.showButtonBar)
+ {
+ }
+ }
+ }
+ else
+ {
+ }
- 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);
+ /* set some checkboxes in the menu according to appData */
- if (appData.showButtonBar) {
- XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
- XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
- }
+ if (appData.alwaysPromoteToQueen)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Always Queen")),TRUE);
- /*
- * formWidget uses these constraints but they are stored
- * in the children.
- */
- i = 0;
- XtSetArg(args[i], XtNfromHoriz, 0); i++;
- XtSetValues(menuBarWidget, args, i);
- if (appData.titleInWindow) {
- if (smallLayout) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
- XtSetValues(titleWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- } else {
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
- XtSetValues(titleWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- }
- } else {
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetValues(whiteTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
- XtSetValues(blackTimerWidget, args, i);
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
- XtSetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
- XtSetValues(buttonBarWidget, args, i);
- }
- }
- i = 0;
- XtSetArg(args[0], XtNfromVert, messageWidget);
- XtSetArg(args[1], XtNtop, XtChainTop);
- XtSetArg(args[2], XtNbottom, XtChainBottom);
- XtSetArg(args[3], XtNleft, XtChainLeft);
- XtSetArg(args[4], XtNright, XtChainRight);
- XtSetValues(boardWidget, args, 5);
+ if (appData.animateDragging)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Animate Dragging")),TRUE);
- XtRealizeWidget(shellWidget);
+ if (appData.animate)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Animate Moving")),TRUE);
- /*
- * Correct the width of the message and title widgets.
- * It is not known why some systems need the extra fudge term.
- * The value "2" is probably larger than needed.
- */
- XawFormDoLayout(formWidget, False);
+ if (appData.autoComment)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Comment")),TRUE);
-#define WIDTH_FUDGE 2
- i = 0;
- XtSetArg(args[i], XtNborderWidth, &bor); i++;
- XtSetArg(args[i], XtNheight, &h); i++;
- XtGetValues(messageWidget, args, i);
- if (appData.showButtonBar) {
- i = 0;
- XtSetArg(args[i], XtNwidth, &w); i++;
- XtGetValues(buttonBarWidget, args, i);
- w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
- } else {
- w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
- }
+ if (appData.autoCallFlag)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Flag")),TRUE);
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
- programName, gres, w, h, wr, hr);
- }
+ if (appData.autoFlipView)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Flip View")),TRUE);
- /* !! 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! */
- w--;
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
- if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
- 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.autoObserve)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Observe")),TRUE);
- 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 - WIDTH_FUDGE;
- }
+ if (appData.autoRaiseBoard)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Raise Board")),TRUE);
- 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);
+ if (appData.autoSaveGames)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Save")),TRUE);
- xBoardWindow = XtWindow(boardWidget);
+ if (appData.saveGameFile[0] != NULLCHAR)
+ {
+ /* Can't turn this off from menu */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Auto Save")),TRUE);
+ gtk_action_set_sensitive(GTK_ACTION (gtk_builder_get_object (builder, "menuOptions.Auto Save")),FALSE);
+ }
- // [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
+ if (appData.blindfold)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Blindfold")),TRUE);
- /*
- * Create X checkmark bitmap and initialize option menu checks.
- */
- ReadBitmap(&xMarkPixmap, "checkmark.bm",
- checkmark_bits, checkmark_width, checkmark_height);
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- if (appData.alwaysPromoteToQueen) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
- args, 1);
- }
- if (appData.animateDragging) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Animate Dragging"),
- args, 1);
- }
- if (appData.animate) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
- args, 1);
- }
- if (appData.autoComment) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
- args, 1);
- }
- if (appData.autoCallFlag) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
- args, 1);
- }
- if (appData.autoFlipView) {
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
- args, 1);
- }
- if (appData.autoObserve) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
- args, 1);
- }
- if (appData.autoRaiseBoard) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Auto Raise Board"), args, 1);
- }
- if (appData.autoSaveGames) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
- }
- if (appData.saveGameFile[0] != NULLCHAR) {
- /* Can't turn this off from menu */
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- args, 1);
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
- False);
+ if (appData.flashCount > 0)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Flash Moves")),TRUE);
+
+ if (appData.getMoveList)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Get Move List")),TRUE);
- }
- if (appData.blindfold) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Blindfold"), args, 1);
- }
- if (appData.flashCount > 0) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Flash Moves"),
- args, 1);
- }
- if (appData.getMoveList) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
- args, 1);
- }
#if HIGHDRAG
- if (appData.highlightDragging) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Dragging"),
- args, 1);
- }
+ if (appData.highlightDragging)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Highlight Dragging")),TRUE);
#endif
- if (appData.highlightLastMove) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Highlight Last Move"),
- args, 1);
- }
- if (appData.icsAlarm) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
- args, 1);
- }
- if (appData.ringBellAfterMoves) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
- args, 1);
- }
- if (appData.oldSaveStyle) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Old Save Style"), args, 1);
- }
- 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);
- }
- if (appData.quietPlay) {
- XtSetValues(XtNameToWidget(menuBarWidget,
- "menuOptions.Quiet Play"), args, 1);
- }
- if (appData.showCoords) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
- args, 1);
- }
- if (appData.hideThinkingFromHuman) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
- args, 1);
- }
- if (appData.testLegality) {
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
- args, 1);
- }
- /*
- * Create an icon.
- */
- ReadBitmap(&wIconPixmap, "icon_white.bm",
- icon_white_bits, icon_white_width, icon_white_height);
- ReadBitmap(&bIconPixmap, "icon_black.bm",
- icon_black_bits, icon_black_width, icon_black_height);
- iconPixmap = wIconPixmap;
- i = 0;
- XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
- XtSetValues(shellWidget, args, i);
+ if (appData.highlightLastMove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Highlight Last Move")),TRUE);
- /*
- * Create a cursor for the board widget.
- */
- window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
- XChangeWindowAttributes(xDisplay, xBoardWindow,
- CWCursor, &window_attributes);
+ if (appData.icsAlarm)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.ICS Alarm")),TRUE);
- /*
- * Inhibit shell resizing.
- */
- shellArgs[0].value = (XtArgVal) &w;
- shellArgs[1].value = (XtArgVal) &h;
- XtGetValues(shellWidget, shellArgs, 2);
- 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;
+ if (appData.ringBellAfterMoves)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Move Sound")),TRUE);
- CatchDeleteWindow(shellWidget, "QuitProc");
+ if (appData.oldSaveStyle)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Old Save Style")),TRUE);
- CreateGCs();
- CreateGrid();
-#if HAVE_LIBXPM
- if (appData.bitmapDirectory[0] != NULLCHAR) {
- CreatePieces();
- } else {
- CreateXPMPieces();
- }
-#else
- CreateXIMPieces();
- /* Create regular pieces */
- if (!useImages) CreatePieces();
-#endif
+ if (appData.periodicUpdates)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Periodic Updates")),TRUE);
+
+ if (appData.ponderNextMove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Ponder Next Move")),TRUE);
+
+ if (appData.popupExitMessage)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Popup Exit Message")),TRUE);
+
+ if (appData.popupMoveErrors)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Popup Move Errors")),TRUE);
+
+ if (appData.premove)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Premove")),TRUE);
+
+ if (appData.quietPlay)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Quit Play")),TRUE);
+
+ if (appData.showCoords)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Show Coords")),TRUE);
+
+ if (appData.showThinking)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Show Thinking")),TRUE);
+
+ if (appData.testLegality)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuOptions.Test Legality")),TRUE);
+
+ /* end setting check boxes */
+
+ /* load square colors */
+ SVGLightSquare = load_pixbuf("svg/LightSquare.svg",squareSize);
+ SVGDarkSquare = load_pixbuf("svg/DarkSquare.svg",squareSize);
+ SVGNeutralSquare = load_pixbuf("svg/NeutralSquare.svg",squareSize);
+
+ /* use two icons to indicate if it is white's or black's turn */
+ WhiteIcon = load_pixbuf("svg/icon_white.svg",0);
+ BlackIcon = load_pixbuf("svg/icon_black.svg",0);
+ WindowIcon = WhiteIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
+
+ /* realize window */
+ gtk_widget_show (GUI_Window);
+
+ /* recalc boardsize */
+ CreateGCs();
+ CreatePieces();
CreatePieceMenus();
if (appData.animate || appData.animateDragging)
CreateAnimVars();
- XtAugmentTranslations(formWidget,
- XtParseTranslationTable(globalTranslations));
- XtAugmentTranslations(boardWidget,
- XtParseTranslationTable(boardTranslations));
- XtAugmentTranslations(whiteTimerWidget,
- XtParseTranslationTable(whiteTranslations));
- XtAugmentTranslations(blackTimerWidget,
- XtParseTranslationTable(blackTranslations));
-
- /* Why is the following needed on some versions of X instead
- * of a translation? */
- XtAddEventHandler(boardWidget, ExposureMask, False,
- (XtEventHandler) EventProc, NULL);
- /* end why */
-
InitBackEnd2();
if (errorExitStatus == -1) {
gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
InitPosition(TRUE);
- XtAppMainLoop(appContext);
+ /*
+ * Create a cursor for the board widget.
+ * (This needs to be called after the window has been created to have access to board-window)
+ */
+
+ BoardCursor = gdk_cursor_new(GDK_HAND2);
+ gdk_window_set_cursor(GUI_Board->window, BoardCursor);
+ gdk_cursor_destroy(BoardCursor);
+
+ /* end cursor */
+ gtk_main ();
+
if (appData.debugMode) fclose(debugFP); // [DM] debug
return 0;
}
unlink(gamePasteFilename);
}
+ RETSIGTYPE TermSizeSigHandler(int sig)
+ {
+ update_ics_width();
+ }
+
RETSIGTYPE
IntSigHandler(sig)
int sig;
return;
}
-typedef struct {
- char *name;
- Boolean value;
-} Enables;
-
void
SetMenuEnables(enab)
Enables *enab;
{
- Widget w;
- if (!menuBarWidget) return;
+ GObject *o;
+
+ if (!builder) return;
while (enab->name != NULL) {
- w = XtNameToWidget(menuBarWidget, enab->name);
- if (w == NULL) {
- DisplayError(enab->name, 0);
- } else {
- XtSetSensitive(w, enab->value);
- }
+ o = gtk_builder_get_object(builder, enab->name);
+ if(GTK_IS_WIDGET(o))
+ gtk_widget_set_sensitive(GTK_WIDGET (o),enab->value);
+ else
+ {
+ if(GTK_IS_ACTION(o))
+ gtk_action_set_sensitive(GTK_ACTION (o),enab->value);
+ else
+ DisplayError(enab->name, 0);
+ }
enab++;
}
}
-Enables icsEnables[] = {
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Machine White", False },
- { "menuMode.Analysis Mode", False },
- { "menuMode.Analyze File", False },
- { "menuMode.Two Machines", False },
-#ifndef ZIPPY
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
- { "menuStep.Move Now", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Hide Thinking", False },
- { "menuOptions.Ponder Next Move", False },
-#endif
- { NULL, False }
-};
-
-Enables ncpEnables[] = {
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { "menuMode.Machine White", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Analysis Mode", False },
- { "menuMode.Analyze File", False },
- { "menuMode.Two Machines", False },
- { "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
- { "Action", False },
- { "menuStep.Revert", False },
- { "menuStep.Move Now", False },
- { "menuStep.Retract Move", False },
- { "menuOptions.Auto Comment", False },
- { "menuOptions.Auto Flag", False },
- { "menuOptions.Auto Flip View", False },
- { "menuOptions.Auto Observe", False },
- { "menuOptions.Auto Raise Board", False },
- { "menuOptions.Get Move List", False },
- { "menuOptions.ICS Alarm", False },
- { "menuOptions.Move Sound", False },
- { "menuOptions.Quiet Play", False },
- { "menuOptions.Hide Thinking", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Ponder Next Move", False },
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
- { NULL, False }
-};
-
-Enables gnuEnables[] = {
- { "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
- { "menuAction.Accept", False },
- { "menuAction.Decline", False },
- { "menuAction.Rematch", False },
- { "menuAction.Adjourn", False },
- { "menuAction.Stop Examining", False },
- { "menuAction.Stop Observing", False },
- { "menuStep.Revert", False },
- { "menuOptions.Auto Comment", False },
- { "menuOptions.Auto Observe", False },
- { "menuOptions.Auto Raise Board", False },
- { "menuOptions.Get Move List", False },
- { "menuOptions.Premove", False },
- { "menuOptions.Quiet Play", False },
-
- /* The next two options rely on SetCmailMode being called *after* */
- /* SetGNUMode so that when GNU is being used to give hints these */
- /* menu options are still available */
-
- { "menuFile.Mail Move", False },
- { "menuFile.Reload CMail Message", False },
- { NULL, False }
-};
-
-Enables cmailEnables[] = {
- { "Action", True },
- { "menuAction.Call Flag", False },
- { "menuAction.Draw", True },
- { "menuAction.Adjourn", False },
- { "menuAction.Abort", False },
- { "menuAction.Stop Observing", False },
- { "menuAction.Stop Examining", False },
- { "menuFile.Mail Move", True },
- { "menuFile.Reload CMail Message", True },
- { NULL, False }
-};
-
-Enables trainingOnEnables[] = {
- { "menuMode.Edit Comment", False },
- { "menuMode.Pause", False },
- { "menuStep.Forward", False },
- { "menuStep.Backward", False },
- { "menuStep.Forward to End", False },
- { "menuStep.Back to Start", False },
- { "menuStep.Move Now", False },
- { "menuStep.Truncate Game", False },
- { NULL, False }
-};
-
-Enables trainingOffEnables[] = {
- { "menuMode.Edit Comment", True },
- { "menuMode.Pause", True },
- { "menuStep.Forward", True },
- { "menuStep.Backward", True },
- { "menuStep.Forward to End", True },
- { "menuStep.Back to Start", True },
- { "menuStep.Move Now", True },
- { "menuStep.Truncate Game", True },
- { NULL, False }
-};
-
-Enables machineThinkingEnables[] = {
- { "menuFile.Load Game", False },
- { "menuFile.Load Next Game", False },
- { "menuFile.Load Previous Game", False },
- { "menuFile.Reload Same Game", False },
- { "menuFile.Paste Game", False },
- { "menuFile.Load Position", False },
- { "menuFile.Load Next Position", False },
- { "menuFile.Load Previous Position", False },
- { "menuFile.Reload Same Position", False },
- { "menuFile.Paste Position", False },
- { "menuMode.Machine White", False },
- { "menuMode.Machine Black", False },
- { "menuMode.Two Machines", False },
- { "menuStep.Retract Move", False },
- { NULL, False }
-};
-
-Enables userThinkingEnables[] = {
- { "menuFile.Load Game", True },
- { "menuFile.Load Next Game", True },
- { "menuFile.Load Previous Game", True },
- { "menuFile.Reload Same Game", True },
- { "menuFile.Paste Game", True },
- { "menuFile.Load Position", True },
- { "menuFile.Load Next Position", True },
- { "menuFile.Load Previous Position", True },
- { "menuFile.Reload Same Position", True },
- { "menuFile.Paste Position", True },
- { "menuMode.Machine White", True },
- { "menuMode.Machine Black", True },
- { "menuMode.Two Machines", True },
- { "menuStep.Retract Move", True },
- { NULL, False }
-};
-
void SetICSMode()
{
SetMenuEnables(icsEnables);
#ifdef ZIPPY
if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
+ {}; // XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
#endif
}
{
SetMenuEnables(trainingOnEnables);
if (appData.showButtonBar) {
- XtSetSensitive(buttonBarWidget, False);
+ // XtSetSensitive(buttonBarWidget, False);
}
CommentPopDown();
}
{
SetMenuEnables(trainingOffEnables);
if (appData.showButtonBar) {
- XtSetSensitive(buttonBarWidget, True);
+ // XtSetSensitive(buttonBarWidget, True);
}
}
case MachinePlaysBlack:
case MachinePlaysWhite:
case TwoMachinesPlay:
- XtSetSensitive(XtNameToWidget(menuBarWidget,
- ModeToWidgetName(gameMode)), True);
+// XtSetSensitive(XtNameToWidget(menuBarWidget,
+// ModeToWidgetName(gameMode)), True);
break;
default:
break;
void CreateGCs()
{
+ /* GCs are not needed anymore for GTK just left them in here for the moment, since there is a lot of X-code still around that's wants them*/
+
XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
| GCBackground | GCFunction | GCPlaneMask;
XGCValues gc_values;
gc_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);
-
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);
gc_values.background = XBlackPixel(xDisplay, xScreen);
lightSquareGC = wbPieceGC
= XtGetGC(shellWidget, value_mask, &gc_values);
}
}
} else {
- gc_values.foreground = highlightSquareColor;
- gc_values.background = highlightSquareColor;
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
- gc_values.foreground = premoveHighlightColor;
- gc_values.background = premoveHighlightColor;
- prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
gc_values.foreground = lightSquareColor;
gc_values.background = darkSquareColor;
lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
}
}
-void loadXIM(xim, xmask, filename, dest, mask)
- XImage *xim;
- XImage *xmask;
- char *filename;
- Pixmap *dest;
- Pixmap *mask;
-{
- int x, y, w, h, p;
- FILE *fp;
- Pixmap temp;
- XGCValues values;
- GC maskGC;
-
- fp = fopen(filename, "rb");
- if (!fp) {
- 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);
- if (xmask)
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
- break;
- case 1:
- XPutPixel(xim, x, y, darkSquareColor);
- if (xmask)
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
- break;
- case 2:
- XPutPixel(xim, x, y, whitePieceColor);
- if (xmask)
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
- break;
- case 3:
- XPutPixel(xim, x, y, lightSquareColor);
- if (xmask)
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
- break;
- }
- }
- }
-
- /* create Pixmap of piece */
- *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, xim->depth);
- XPutImage(xDisplay, *dest, lightSquareGC, xim,
- 0, 0, 0, 0, w, h);
-
- /* 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. */
- if (xmask) {
- temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, xim->depth);
- XPutImage(xDisplay, temp, lightSquareGC, xmask,
- 0, 0, 0, 0, w, h);
-
- /* now create the 1-bit version */
- *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
- w, h, 1);
-
- values.foreground = 1;
- values.background = 0;
-
- /* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, *mask,
- GCForeground | GCBackground, &values);
- XCopyPlane(xDisplay, temp, *mask, maskGC,
- 0, 0, squareSize, squareSize, 0, 0, 1);
- XFreePixmap(xDisplay, temp);
- }
-}
-
-
-char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
-
-void CreateXIMPieces()
-{
- int piece, kind;
- char buf[MSG_SIZ];
- u_int ss;
- static char *ximkind[] = { "ll", "ld", "dl", "dd" };
- XImage *ximtemp;
-
- ss = squareSize;
-
- /* 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 */
-
- /* temp needed by loadXIM() */
- ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
-
- if (strlen(appData.pixmapDirectory) == 0) {
- useImages = 0;
- } else {
- useImages = 1;
- if (appData.monoMode) {
- DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
- 0, 2);
- ExitEvent(2);
- }
- fprintf(stderr, _("\nLoading XIMs...\n"));
- /* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- fprintf(stderr, "%d", piece+1);
- for (kind=0; kind<4; kind++) {
- fprintf(stderr, ".");
- snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
- ExpandPathName(appData.pixmapDirectory),
- 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],
- ximtemp, buf,
- &(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
- draw them with solid squares. */
- 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=
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
-
- loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
- fprintf(stderr, _("dark square "));
- snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
- ExpandPathName(appData.pixmapDirectory), ss);
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
- ximDarkSquare=
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),
- 0, 0, ss, ss, AllPlanes, XYPixmap);
- loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
- xpmJailSquare = xpmLightSquare;
- }
- fprintf(stderr, _("Done.\n"));
- }
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
-}
-
-#if HAVE_LIBXPM
-void CreateXPMPieces()
-{
- int piece, kind, r;
- char buf[MSG_SIZ];
- u_int ss = squareSize;
- XpmAttributes attr;
- static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
- XpmColorSymbol symbols[4];
-
- /* 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;
- symbols[1].name = "dark_piece";
- symbols[1].value = appData.blackPieceColor;
- symbols[2].name = "light_square";
- symbols[2].value = appData.lightSquareColor;
- symbols[3].name = "dark_square";
- symbols[3].value = appData.darkSquareColor;
-
- attr.valuemask = XpmColorSymbols;
- attr.colorsymbols = symbols;
- attr.numsymbols = 4;
-
- if (appData.monoMode) {
- DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
- 0, 2);
- ExitEvent(2);
- }
- if (strlen(appData.pixmapDirectory) == 0) {
- XpmPieces* pieces = builtInXpms;
- useImages = 1;
- /* Load pieces */
- while (pieces->size != squareSize && pieces->size) pieces++;
- if (!pieces->size) {
- fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
- exit(1);
- }
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- for (kind=0; kind<4; kind++) {
-
- if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
- pieces->xpm[piece][kind],
- &(xpmPieceBitmap2[kind][piece]),
- NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
- r, buf);
- exit(1);
- }
- if(piece <= (int) WhiteKing)
- xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
- }
- }
- useImageSqs = 0;
- xpmJailSquare = xpmLightSquare;
- } else {
- useImages = 1;
-
- fprintf(stderr, _("\nLoading XPMs...\n"));
-
- /* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- fprintf(stderr, "%d ", piece+1);
- for (kind=0; kind<4; kind++) {
- snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
- ExpandPathName(appData.pixmapDirectory),
- piece > (int) WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- xpmkind[kind], ss);
- if (appData.debugMode) {
- fprintf(stderr, _("(File:%s:) "), buf);
- }
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &(xpmPieceBitmap2[kind][piece]),
- NULL, &attr)) != 0) {
- 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
- draw them with solid squares. */
- fprintf(stderr, _("light square "));
- snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
- if (access(buf, 0) != 0) {
- useImageSqs = 0;
- } else {
- useImageSqs = 1;
- if (appData.debugMode)
- fprintf(stderr, _("(File:%s:) "), buf);
-
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &xpmLightSquare, NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
- exit(1);
- }
- fprintf(stderr, _("dark square "));
- snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
- ExpandPathName(appData.pixmapDirectory), ss);
- if (appData.debugMode) {
- fprintf(stderr, _("(File:%s:) "), buf);
- }
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &xpmDarkSquare, NULL, &attr)) != 0) {
- fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
- exit(1);
- }
- }
- xpmJailSquare = xpmLightSquare;
- fprintf(stderr, _("Done.\n"));
- }
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
-}
-#endif /* HAVE_LIBXPM */
-
-#if HAVE_LIBXPM
-/* No built-in bitmaps */
void CreatePieces()
{
- 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 + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
- }
- }
+ int i;
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
-}
-#else
-/* With built-in bitmaps */
-void CreatePieces()
-{
- BuiltInBits* bib = builtInBits;
- 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 + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf,
- bib->bits[kind][piece], ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
- }
- }
-
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
-}
-#endif
-
-void ReadBitmap(pm, name, bits, wreq, hreq)
- Pixmap *pm;
- String name;
- unsigned char bits[];
- u_int wreq, hreq;
-{
- int x_hot, y_hot;
- 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:
- snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
- break;
- case BitmapFileInvalid:
- snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
- break;
- case BitmapNoMemory:
- snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
- fullname);
- break;
- default:
- snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
- errcode, fullname);
- break;
- }
- fprintf(stderr, _("%s: %s...using built-in\n"),
- programName, msg);
- } else if (w != wreq || h != hreq) {
- fprintf(stderr,
- _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
- programName, fullname, w, h, wreq, hreq);
- } else {
- return;
+ /* free if used
+ for(i=0;i<MAXPIECES;i++)
+ {
+ if(SVGpieces[i])
+ {
+ g_free(SVGpieces[i]);
+ SVGpieces[i]=NULL;
}
}
- if (bits != NULL) {
- *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
- wreq, hreq);
- }
-}
+ */
-void CreateGrid()
-{
- int i, j;
+ /* reload these */
+ SVGLightSquare = load_pixbuf("svg/LightSquare.svg",squareSize);
+ SVGDarkSquare = load_pixbuf("svg/DarkSquare.svg",squareSize);
+ SVGNeutralSquare = load_pixbuf("svg/NeutralSquare.svg",squareSize);
- if (lineGap == 0) return;
- /* [HR] Split this into 2 loops for non-square boards. */
+ /* get some defaults going */
+ for(i=WhitePawn; i<DemotePiece+1; i++)
+ SVGpieces[i] = load_pixbuf("svg/NeutralSquare.svg",squareSize);
+
+ SVGpieces[WhitePawn] = load_pixbuf("svg/WhitePawn.svg",squareSize);
+ SVGpieces[WhiteKnight] = load_pixbuf("svg/WhiteKnight.svg",squareSize);
+ SVGpieces[WhiteBishop] = load_pixbuf("svg/WhiteBishop.svg",squareSize);
+ SVGpieces[WhiteRook] = load_pixbuf("svg/WhiteRook.svg",squareSize);
+ SVGpieces[WhiteQueen] = load_pixbuf("svg/WhiteQueen.svg",squareSize);
+ SVGpieces[WhiteKing] = load_pixbuf("svg/WhiteKing.svg",squareSize);
- 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));
- }
+ SVGpieces[BlackPawn] = load_pixbuf("svg/BlackPawn.svg",squareSize);
+ SVGpieces[BlackKnight] = load_pixbuf("svg/BlackKnight.svg",squareSize);
+ SVGpieces[BlackBishop] = load_pixbuf("svg/BlackBishop.svg",squareSize);
+ SVGpieces[BlackRook] = load_pixbuf("svg/BlackRook.svg",squareSize);
+ SVGpieces[BlackQueen] = load_pixbuf("svg/BlackQueen.svg",squareSize);
+ SVGpieces[BlackKing] = load_pixbuf("svg/BlackKing.svg",squareSize);
- 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));
- }
+ return;
}
+
static void MenuBarSelect(w, addr, index)
Widget w;
caddr_t addr;
return menuBar;
}
-Widget CreateButtonBar(mi)
- MenuItem *mi;
-{
- int j;
- Widget button, buttonBar;
- Arg args[16];
-
- j = 0;
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
- if (tinyLayout) {
- XtSetArg(args[j], XtNhSpace, 0); j++;
- }
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- XtSetArg(args[j], XtNvSpace, 0); j++;
- buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,
- formWidget, args, j);
-
- while (mi->string != NULL) {
- j = 0;
- if (tinyLayout) {
- XtSetArg(args[j], XtNinternalWidth, 2); j++;
- XtSetArg(args[j], XtNborderWidth, 0); j++;
- }
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
- button = XtCreateManagedWidget(mi->string, commandWidgetClass,
- buttonBar, args, j);
- XtAddCallback(button, XtNcallback,
- (XtCallbackProc) MenuBarSelect,
- (caddr_t) mi->proc);
- mi++;
- }
- return buttonBar;
-}
Widget
CreatePieceMenu(name, color)
Arg args[16];
ChessSquare selection;
- whitePieceMenu = CreatePieceMenu("menuW", 0);
- blackPieceMenu = CreatePieceMenu("menuB", 1);
-
- XtRegisterGrabAction(PieceMenuPopup, True,
- (unsigned)(ButtonPressMask|ButtonReleaseMask),
- GrabModeAsync, GrabModeAsync);
-
- XtSetArg(args[0], XtNlabel, _("Drop"));
- dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,
- 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)));
- entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- dropMenu, args, 1);
- selection = dropMenuTranslation[i];
- XtAddCallback(entry, XtNcallback,
- (XtCallbackProc) DropMenuSelect,
- (caddr_t) selection);
- }
- }
+// whitePieceMenu = CreatePieceMenu("menuW", 0);
+// blackPieceMenu = CreatePieceMenu("menuB", 1);
+//
+// XtRegisterGrabAction(PieceMenuPopup, True,
+// (unsigned)(ButtonPressMask|ButtonReleaseMask),
+// GrabModeAsync, GrabModeAsync);
+//
+// XtSetArg(args[0], XtNlabel, _("Drop"));
+// dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,
+// 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)));
+// entry = XtCreateManagedWidget(item, smeBSBObjectClass,
+// dropMenu, args, 1);
+// selection = dropMenuTranslation[i];
+// XtAddCallback(entry, XtNcallback,
+// (XtCallbackProc) DropMenuSelect,
+// (caddr_t) selection);
+// }
+// }
}
void SetupDropMenu()
DropMenuEvent(piece, pmFromX, pmFromY);
}
-void WhiteClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetWhiteToPlayEvent();
- } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {
- CallFlagEvent();
- }
-}
-
-void BlackClock(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == EditPosition || gameMode == IcsExamining) {
- SetBlackToPlayEvent();
- } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {
- CallFlagEvent();
- }
-}
-
-
/*
* If the user selects on a border boundary, return -1; if off the board,
* return -2. Otherwise map the event coordinate to the square.
TimeDelay(msec);
}
-static void drawHighlight(file, rank, gc)
- int file, rank;
- GC gc;
+static void drawHighlight(file, rank, line_type)
+ int file, rank, line_type;
{
int x, y;
+ cairo_t *cr;
if (lineGap == 0 || appData.blindfold) return;
- if (flipView) {
+ if (flipView)
+ {
x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
(squareSize + lineGap);
y = lineGap/2 + rank * (squareSize + lineGap);
- } else {
+ }
+ else
+ {
x = lineGap/2 + file * (squareSize + lineGap);
y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
(squareSize + lineGap);
- }
+ }
+
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
+
+ /* draw the highlight */
+ cairo_move_to (cr, x, y);
+ cairo_rel_line_to (cr, 0,squareSize+lineGap);
+ cairo_rel_line_to (cr, squareSize+lineGap,0);
+ cairo_rel_line_to (cr, 0,-squareSize-lineGap);
+ cairo_close_path (cr);
+
+ cairo_set_line_width (cr, lineGap);
+ switch(line_type)
+ {
+ /* TODO: use appdata colors */
+ case LINE_TYPE_HIGHLIGHT:
+ cairo_set_source_rgba (cr, 1, 1, 0, 1.0);
+ break;
+ case LINE_TYPE_PRE:
+ cairo_set_source_rgba (cr, 1, 0, 0, 1.0);
+ break;
+ case LINE_TYPE_NORMAL:
+ default:
+ cairo_set_source_rgba (cr, 0, 1, 0, 1.0);
+ }
+
+ cairo_stroke (cr);
+
+ /* free memory */
+ cairo_destroy (cr);
- XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
- squareSize+lineGap, squareSize+lineGap);
+ return;
}
int hi1X = -1, hi1Y = -1, hi2X = -1, hi2Y = -1;
SetHighlights(fromX, fromY, toX, toY)
int fromX, fromY, toX, toY;
{
- if (hi1X != fromX || hi1Y != fromY) {
- if (hi1X >= 0 && hi1Y >= 0) {
- drawHighlight(hi1X, hi1Y, lineGC);
- }
- if (fromX >= 0 && fromY >= 0) {
- drawHighlight(fromX, fromY, highlineGC);
- }
- }
- if (hi2X != toX || hi2Y != toY) {
- if (hi2X >= 0 && hi2Y >= 0) {
- drawHighlight(hi2X, hi2Y, lineGC);
- }
- if (toX >= 0 && toY >= 0) {
- drawHighlight(toX, toY, highlineGC);
- }
- }
+ if (hi1X != fromX || hi1Y != fromY)
+ {
+ if (hi1X >= 0 && hi1Y >= 0)
+ {
+ drawHighlight(hi1X, hi1Y, LINE_TYPE_NORMAL);
+ }
+ if (fromX >= 0 && fromY >= 0)
+ {
+ drawHighlight(fromX, fromY, LINE_TYPE_HIGHLIGHT);
+ }
+ }
+ if (hi2X != toX || hi2Y != toY)
+ {
+ if (hi2X >= 0 && hi2Y >= 0)
+ {
+ drawHighlight(hi2X, hi2Y, LINE_TYPE_NORMAL);
+ }
+ if (toX >= 0 && toY >= 0)
+ {
+ drawHighlight(toX, toY, LINE_TYPE_HIGHLIGHT);
+ }
+ }
hi1X = fromX;
hi1Y = fromY;
hi2X = toX;
hi2Y = toY;
+
+ return;
}
void
SetPremoveHighlights(fromX, fromY, toX, toY)
int fromX, fromY, toX, toY;
{
- if (pm1X != fromX || pm1Y != fromY) {
- if (pm1X >= 0 && pm1Y >= 0) {
- drawHighlight(pm1X, pm1Y, lineGC);
- }
- if (fromX >= 0 && fromY >= 0) {
- drawHighlight(fromX, fromY, prelineGC);
- }
- }
- if (pm2X != toX || pm2Y != toY) {
- if (pm2X >= 0 && pm2Y >= 0) {
- drawHighlight(pm2X, pm2Y, lineGC);
- }
- if (toX >= 0 && toY >= 0) {
- drawHighlight(toX, toY, prelineGC);
- }
- }
+ if (pm1X != fromX || pm1Y != fromY)
+ {
+ if (pm1X >= 0 && pm1Y >= 0)
+ {
+ drawHighlight(pm1X, pm1Y, LINE_TYPE_NORMAL);
+ }
+ if (fromX >= 0 && fromY >= 0)
+ {
+ drawHighlight(fromX, fromY, LINE_TYPE_PRE);
+ }
+ }
+ if (pm2X != toX || pm2Y != toY)
+ {
+ if (pm2X >= 0 && pm2Y >= 0)
+ {
+ drawHighlight(pm2X, pm2Y, LINE_TYPE_NORMAL);
+ }
+ if (toX >= 0 && toY >= 0)
+ {
+ drawHighlight(toX, toY, LINE_TYPE_PRE);
+ }
+ }
+
pm1X = fromX;
pm1Y = fromY;
pm2X = toX;
pm2Y = toY;
+
+ return;
}
void
ChessSquare piece;
Drawable dest;
{
- if (useImages && useImageSqs) {
- Pixmap pm;
- switch (color) {
- case 1: /* light */
- pm = xpmLightSquare;
- break;
- case 0: /* dark */
- pm = xpmDarkSquare;
- break;
- case 2: /* neutral */
- default:
- pm = xpmJailSquare;
- break;
- }
- XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- } else {
- GC gc;
- switch (color) {
- case 1: /* light */
- gc = lightSquareGC;
- break;
- case 0: /* dark */
- gc = darkSquareGC;
- break;
- case 2: /* neutral */
- default:
- gc = jailSquareGC;
- break;
- }
- XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);
- }
-}
-
-/*
- I split out the routines to draw a piece so that I could
- make a generic flash routine.
-*/
-static void monoDrawPiece_1bit(piece, square_color, x, y, dest)
- ChessSquare piece;
- int square_color, x, y;
- Drawable dest;
-{
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToOutline(piece)
- : *pieceToSolid(piece),
- dest, bwPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- break;
- case 0: /* dark */
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToSolid(piece)
- : *pieceToOutline(piece),
- dest, wbPieceGC, 0, 0,
- squareSize, squareSize, x, y);
- break;
- }
-}
-
-static void monoDrawPiece(piece, square_color, x, y, dest)
- ChessSquare piece;
- int square_color, x, y;
- Drawable dest;
-{
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToOutline(piece)
- : *pieceToSolid(piece),
- dest, bwPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 0: /* dark */
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
- ? *pieceToSolid(piece)
- : *pieceToOutline(piece),
- dest, wbPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- }
-}
+ GdkPixbuf *pb;
-static void colorDrawPiece(piece, square_color, x, y, dest)
- ChessSquare piece;
- 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),
- dest, (int) piece < (int) BlackPawn
- ? wlPieceGC : blPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 0: /* dark */
- XCopyPlane(xDisplay, *pieceToSolid(piece),
- dest, (int) piece < (int) BlackPawn
- ? wdPieceGC : bdPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- case 2: /* neutral */
- default:
- XCopyPlane(xDisplay, *pieceToSolid(piece),
- dest, (int) piece < (int) BlackPawn
- ? wjPieceGC : bjPieceGC, 0, 0,
- squareSize, squareSize, x, y, 1);
- break;
- }
+ switch (color)
+ {
+ case 0: /* dark */
+ pb = SVGDarkSquare;
+ break;
+ case 1: /* light */
+ pb = SVGLightSquare;
+ break;
+ case 2: /* neutral */
+ default:
+ pb = SVGNeutralSquare;
+ break;
+ }
+ gdk_draw_pixbuf(GDK_WINDOW(GUI_Board->window),NULL,pb,0,0,x,y,-1,-1, GDK_RGB_DITHER_NORMAL, 0, 0);
+ return;
}
-static void colorDrawPieceImage(piece, square_color, x, y, dest)
+static void DrawPiece(piece, square_color, x, y, dest)
ChessSquare piece;
int square_color, x, y;
Drawable dest;
{
- int kind;
-
- switch (square_color) {
- case 1: /* light */
- case 2: /* neutral */
- default:
- if ((int)piece < (int) BlackPawn) {
- kind = 0;
- } else {
- kind = 2;
- piece -= BlackPawn;
- }
- break;
- case 0: /* dark */
- if ((int)piece < (int) BlackPawn) {
- kind = 1;
- } else {
- kind = 3;
- piece -= BlackPawn;
- }
- break;
- }
- XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
- dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
-}
-
-typedef void (*DrawFunc)();
+ /* redraw background, since piece might be transparent in some areas */
+ BlankSquare(x,y,square_color,piece,dest);
-DrawFunc ChooseDrawFunc()
-{
- if (appData.monoMode) {
- if (DefaultDepth(xDisplay, xScreen) == 1) {
- return monoDrawPiece_1bit;
- } else {
- return monoDrawPiece;
- }
- } else {
- if (useImages)
- return colorDrawPieceImage;
- else
- return colorDrawPiece;
- }
+ /* draw piece */
+ gdk_draw_pixbuf(GDK_WINDOW(GUI_Board->window),NULL,
+ GDK_PIXBUF(SVGpieces[piece]),0,0,x,y,-1,-1,
+ GDK_RGB_DITHER_NORMAL, 0, 0);
+ return ;
}
/* [HR] determine square color depending on chess variant. */
int row, column, do_flash;
ChessSquare piece;
{
- int square_color, x, y, direction, font_ascent, font_descent;
+ int square_color, x, y;
int i;
char string[2];
- XCharStruct overall;
- DrawFunc drawfunc;
int flash_delay;
/* Calculate delay in milliseconds (2-delays per complete flash) */
flash_delay = 500 / appData.flashRate;
- if (flipView) {
+ /* calculate x and y coordinates from row and column */
+ if (flipView)
+ {
x = lineGap + ((BOARD_WIDTH-1)-column) *
(squareSize + lineGap);
y = lineGap + row * (squareSize + lineGap);
- } else {
+ }
+ else
+ {
x = lineGap + column * (squareSize + lineGap);
y = lineGap + ((BOARD_HEIGHT-1)-row) *
(squareSize + lineGap);
- }
+ }
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);
- }
- }
+ // [HGM] holdings: blank out area between board and holdings
+ if ( 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);
- string[1] = NULLCHAR;
- 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,
- y + squareSize - font_descent - 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
- y + squareSize - font_descent - 1, string, 1);
- }
- }
- 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,
- x + 2, y + font_ascent + 1, string, 1);
- } else {
- XDrawString(xDisplay, xBoardWindow, coordGC,
- x + 2, y + font_ascent + 1, string, 1);
- }
- }
-}
+ // [HGM] print piece counts next to holdings
+ string[1] = NULLCHAR;
+ if(piece > 1)
+ {
+ cairo_text_extents_t extents;
+ cairo_t *cr;
+ int xpos, ypos;
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
-/* Why is this needed on some versions of X? */
-void EventProc(widget, unused, event)
- Widget widget;
- caddr_t unused;
- XEvent *event;
-{
- if (!XtIsRealized(widget))
- return;
+ string[0] = '0' + piece;
- switch (event->type) {
- case Expose:
- if (event->xexpose.count > 0) return; /* no clipping is done */
- XDrawPosition(widget, True, NULL);
- break;
- default:
- return;
- }
-}
-/* end why */
+ /* TODO this has to go into the font-selection */
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
-void DrawPosition(fullRedraw, board)
- /*Boolean*/int fullRedraw;
- Board board;
-{
- XDrawPosition(boardWidget, fullRedraw, board);
+ cairo_set_font_size (cr, 12.0);
+ cairo_text_extents (cr, string, &extents);
+
+ if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) )
+ {
+ xpos= x + squareSize - extents.width - 2;
+ ypos= y + extents.y_bearing + 1;
+ }
+ if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1)
+ {
+ xpos= x + 2;
+ ypos = y + extents.y_bearing + 1;
+ }
+
+ /* TODO mono mode? */
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 1.0, 1.0, 1);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+ }
+ }
+ else
+ {
+ /* square on the board */
+ if (piece == EmptySquare || appData.blindfold)
+ {
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ }
+ else
+ {
+ if (do_flash && appData.flashCount > 0)
+ {
+ for (i=0; i<appData.flashCount; ++i)
+ {
+
+ DrawPiece(piece, square_color, x, y, xBoardWindow);
+ do_flash_delay(flash_delay);
+
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ do_flash_delay(flash_delay);
+ }
+ }
+ DrawPiece(piece, square_color, x, y, xBoardWindow);
+ }
+ }
+
+ /* show coordinates if necessary */
+ if(appData.showCoords)
+ {
+ cairo_text_extents_t extents;
+ cairo_t *cr;
+ int xpos, ypos;
+
+ /* TODO this has to go into the font-selection */
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
+ cairo_set_font_size (cr, 12.0);
+
+ string[1] = NULLCHAR;
+
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
+
+ if (row == (flipView ? BOARD_HEIGHT-1 : 0) &&
+ column >= BOARD_LEFT && column < BOARD_RGHT)
+ {
+ string[0] = 'a' + column - BOARD_LEFT;
+ cairo_text_extents (cr, string, &extents);
+
+ xpos = x + squareSize - extents.width - 2;
+ ypos = y + squareSize - extents.height - extents.y_bearing - 1;
+
+ if (appData.monoMode)
+ { /*TODO*/
+ }
+ else
+ {
+ }
+
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 1.0, 0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+ }
+ if ( column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT))
+ {
+
+ string[0] = ONE + row;
+ cairo_text_extents (cr, string, &extents);
+
+ xpos = x + 2;
+ ypos = y + extents.height + 1;
+
+ if (appData.monoMode)
+ { /*TODO*/
+ }
+ else
+ {
+ }
+
+ cairo_move_to (cr, xpos, ypos);
+ cairo_text_path (cr, string);
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ cairo_fill_preserve (cr);
+ cairo_set_source_rgb (cr, 0, 0, 1.0);
+ cairo_set_line_width (cr, 0.1);
+ cairo_stroke (cr);
+
+ }
+ /* free memory */
+ cairo_destroy (cr);
+ }
+
+ return;
}
+
/* Returns 1 if there are "too many" differences between b1 and b2
(i.e. more than 1 move was made) */
static int too_many_diffs(b1, b2)
/*
* event handler for redrawing the board
*/
-void XDrawPosition(w, repaint, board)
- Widget w;
+void DrawPosition( repaint, board)
/*Boolean*/int repaint;
- Board board;
+ Board board;
{
- int i, j, do_flash;
- static int lastFlipView = 0;
- static int lastBoardValid = 0;
- static Board lastBoard;
- Arg args[16];
- int rrow, rcol;
+ int i, j, do_flash;
+ static int lastFlipView = 0;
+ static int lastBoardValid = 0;
+ static Board lastBoard;
+ int rrow, rcol;
- if (board == NULL) {
- if (!lastBoardValid) return;
- board = lastBoard;
- }
- if (!lastBoardValid || lastFlipView != flipView) {
- XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
- args, 1);
- }
-
- /*
- * It would be simpler to clear the window with XClearWindow()
- * but this causes a very distracting flicker.
- */
+ if (board == NULL) {
+ if (!lastBoardValid) return;
+ board = lastBoard;
+ }
+ if (!lastBoardValid || lastFlipView != flipView) {
+ // XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
+ // XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
+ // args, 1);
+ }
- if (!repaint && lastBoardValid && lastFlipView == flipView) {
+ /*
+ * It would be simpler to clear the window with XClearWindow()
+ * but this causes a very distracting flicker.
+ */
- /* If too much changes (begin observing new game, etc.), don't
- do flashing */
- do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
+ if (!repaint && lastBoardValid && lastFlipView == flipView)
+ {
+ /* If too much changes (begin observing new game, etc.), don't
+ do flashing */
+ do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
- /* Special check for castling so we don't flash both the king
- and the rook (just flash the king). */
- if (do_flash) {
- if (check_castle_draw(board, lastBoard, &rrow, &rcol)) {
- /* Draw rook with NO flashing. King will be drawn flashing later */
- DrawSquare(rrow, rcol, board[rrow][rcol], 0);
- lastBoard[rrow][rcol] = board[rrow][rcol];
+ /* Special check for castling so we don't flash both the king
+ and the rook (just flash the king). */
+ if (do_flash)
+ {
+ if (check_castle_draw(board, lastBoard, &rrow, &rcol))
+ {
+ /* Draw rook with NO flashing. King will be drawn flashing later */
+ DrawSquare(rrow, rcol, board[rrow][rcol], 0);
+ lastBoard[rrow][rcol] = board[rrow][rcol];
}
}
- /* 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_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);
- damage[i][j] = False;
+ /* 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_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);
+ damage[i][j] = False;
}
- /* Second pass -- Draw piece(s) in new position and flash them */
- for (i = 0; i < BOARD_HEIGHT; i++)
- for (j = 0; j < BOARD_WIDTH; j++)
- if (board[i][j] != lastBoard[i][j]) {
- DrawSquare(i, j, board[i][j], do_flash);
+ /* Second pass -- Draw piece(s) in new position and flash them */
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ if (board[i][j] != lastBoard[i][j])
+ {
+ DrawSquare(i, j, board[i][j], do_flash);
}
- } else {
- if (lineGap > 0)
- XDrawSegments(xDisplay, xBoardWindow, lineGC,
- gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
+ }
+ else
+ {
+ /* redraw Grid */
+ if (lineGap > 0)
+ {
+ int x1,x2,y1,y2;
+ cairo_t *cr;
- 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;
+ /* get a cairo_t */
+ cr = gdk_cairo_create (GDK_WINDOW(GUI_Board->window));
+
+ cairo_set_line_width (cr, lineGap);
+
+ /* TODO: use appdata colors */
+ cairo_set_source_rgba (cr, 0, 1, 0, 1.0);
+
+ cairo_stroke (cr);
+
+ for (i = 0; i < BOARD_HEIGHT + 1; i++)
+ {
+ x1 = 0;
+ x2 = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ y1 = y2 = lineGap / 2 + (i * (squareSize + lineGap));
+
+ cairo_move_to (cr, x1, y1);
+ cairo_rel_line_to (cr, x2,0);
+ cairo_stroke (cr);
+ }
+
+ for (j = 0; j < BOARD_WIDTH + 1; j++)
+ {
+ y1 = 0;
+ y2 = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ x1 = x2 = lineGap / 2 + (j * (squareSize + lineGap));
+
+ cairo_move_to (cr, x1, y1);
+ cairo_rel_line_to (cr, 0, y2);
+ cairo_stroke (cr);
+ }
+
+ /* free memory */
+ cairo_destroy (cr);
+ }
+
+ /* draw pieces */
+ 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;
}
}
- CopyBoard(lastBoard, board);
- lastBoardValid = 1;
- lastFlipView = flipView;
+ CopyBoard(lastBoard, board);
+ lastBoardValid = 1;
+ lastFlipView = flipView;
- /* Draw highlights */
- if (pm1X >= 0 && pm1Y >= 0) {
- drawHighlight(pm1X, pm1Y, prelineGC);
+ /* Draw highlights */
+ if (pm1X >= 0 && pm1Y >= 0)
+ {
+ drawHighlight(pm1X, pm1Y, LINE_TYPE_PRE);
}
- if (pm2X >= 0 && pm2Y >= 0) {
- drawHighlight(pm2X, pm2Y, prelineGC);
+ if (pm2X >= 0 && pm2Y >= 0)
+ {
+ drawHighlight(pm2X, pm2Y, LINE_TYPE_PRE);
}
- if (hi1X >= 0 && hi1Y >= 0) {
- drawHighlight(hi1X, hi1Y, highlineGC);
+ if (hi1X >= 0 && hi1Y >= 0)
+ {
+ drawHighlight(hi1X, hi1Y, LINE_TYPE_HIGHLIGHT);
}
- if (hi2X >= 0 && hi2Y >= 0) {
- drawHighlight(hi2X, hi2Y, highlineGC);
+ if (hi2X >= 0 && hi2Y >= 0)
+ {
+ drawHighlight(hi2X, hi2Y, LINE_TYPE_HIGHLIGHT);
}
- /* If piece being dragged around board, must redraw that too */
- DrawDragPiece();
-
- XSync(xDisplay, False);
-}
+ /* If piece being dragged around board, must redraw that too */
+ DrawDragPiece();
-
-/*
- * event handler for redrawing the board
- */
-void DrawPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- XDrawPosition(w, True, NULL);
+ return;
}
-
/*
* event handler for parsing user moves
*/
if (promotionUp) {
if (event->type == ButtonPress) {
- XtPopdown(promotionShell);
- XtDestroyWidget(promotionShell);
+// XtPopdown(promotionShell);
+// XtDestroyWidget(promotionShell);
promotionUp = False;
ClearHighlights();
fromX = fromY = -1;
/* [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) )
+ && ( 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) {
commentUp = True;
}
- void AnalysisPopUp(title, text)
- char *title, *text;
- {
- Arg args[16];
- int j;
- Widget edit;
-
- if (analysisShell == NULL) {
- analysisShell = MiscCreate(title, text, False, NULL, 4);
- XtRealizeWidget(analysisShell);
- CatchDeleteWindow(analysisShell, "AnalysisPopDown");
-
- } else {
- edit = XtNameToWidget(analysisShell, "*form.text");
- j = 0;
- XtSetArg(args[j], XtNstring, text); j++;
- XtSetValues(edit, args, j);
- j = 0;
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;
- XtSetValues(analysisShell, args, j);
- }
-
- if (!analysisUp) {
- XtPopup(analysisShell, XtGrabNone);
- }
- XSync(xDisplay, False);
-
- analysisUp = True;
- }
-
void CommentCallback(w, client_data, call_data)
Widget w;
XtPointer client_data, call_data;
commentUp = False;
}
- void AnalysisPopDown()
- {
- if (!analysisUp) return;
- XtPopdown(analysisShell);
- XSync(xDisplay, False);
- analysisUp = False;
- if (appData.icsEngineAnalyze) ExitAnalyzeMode(); /* [DM] icsEngineAnalyze */
- }
-
-
void FileNamePopUp(label, def, proc, openMode)
char *label;
char *def;
XawDialogAddButton(dialog, _("King"), PromotionCallback,
(XtPointer) dialog);
}
- if(gameInfo.variant == VariantCapablanca ||
- gameInfo.variant == VariantGothic ||
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
gameInfo.variant == VariantCapaRandom) {
XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
(XtPointer) dialog);
{
if (!errorUp) return;
errorUp = False;
- XtPopdown(errorShell);
- XtDestroyWidget(errorShell);
+
+ if(GUI_Error)
+ gtk_widget_destroy(GTK_WIDGET(GUI_Error));
+
if (errorExitStatus != -1) ExitEvent(errorExitStatus);
+
+ return;
}
void ErrorPopUp(title, label, modal)
char *title, *label;
int modal;
{
- Arg args[16];
- Widget dialog, layout;
- Position x, y;
- int xx, yy;
- Window junk;
- 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 =
- 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);
- i = 0;
- XtSetArg(args[i], XtNwidth, &pw_width); i++;
- XtSetArg(args[i], XtNheight, &pw_height); i++;
- XtGetValues(errorShell, args, i);
-
-#ifdef NOTDEF
- /* This code seems to tickle an X bug if it is executed too soon
- after xboard starts up. The coordinates get transformed as if
- the main window was positioned at (0, 0).
- */
- XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
- 0 - pw_height + squareSize / 3, &x, &y);
-#else
- XTranslateCoordinates(xDisplay, XtWindow(boardWidget),
- RootWindowOfScreen(XtScreen(boardWidget)),
- (bw_width - pw_width) / 2,
- 0 - pw_height + squareSize / 3, &xx, &yy, &junk);
- x = xx;
- y = yy;
-#endif
- if (y < 0) y = 0; /*avoid positioning top offscreen*/
+ GUI_Error = gtk_message_dialog_new(GTK_WINDOW(GUI_Window),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_CLOSE,
+ (gchar *)label);
- i = 0;
- XtSetArg(args[i], XtNx, x); i++;
- XtSetArg(args[i], XtNy, y); i++;
- XtSetValues(errorShell, args, i);
+ gtk_window_set_title(GTK_WINDOW(GUI_Error),(gchar *) title);
+ if(modal)
+ {
+ gtk_dialog_run(GTK_DIALOG(GUI_Error));
+ gtk_widget_destroy(GTK_WIDGET(GUI_Error));
+ }
+ else
+ {
+ g_signal_connect_swapped (GUI_Error, "response",
+ G_CALLBACK (ErrorPopDownProc),
+ GUI_Error);
+ errorUp = True;
+ gtk_widget_show(GTK_WIDGET(GUI_Error));
+ }
- errorUp = True;
- XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);
+ return;
}
/* Disable all user input other than deleting the window */
{
if (frozen) return;
/* Grab by a widget that doesn't accept input */
- XtAddGrab(messageWidget, TRUE, FALSE);
+ // XtAddGrab(messageWidget, TRUE, FALSE);
frozen = 1;
}
void ThawUI()
{
if (!frozen) return;
- XtRemoveGrab(messageWidget);
+ // XtRemoveGrab(messageWidget);
frozen = 0;
}
void ModeHighlight()
{
- Arg args[16];
static int oldPausing = FALSE;
static GameMode oldmode = (GameMode) -1;
char *wname;
- if (!boardWidget || !XtIsRealized(boardWidget)) return;
+ // todo this toggling of the pause button doesn't seem to work?
+ // e.g. select pause from buttonbar doesn't activate menumode.pause
+
+ // if (!boardWidget || !XtIsRealized(boardWidget)) return;
if (pausing != oldPausing) {
- oldPausing = pausing;
+ oldPausing = pausing;
+ gtk_button_set_relief(GTK_BUTTON (gtk_builder_get_object (builder, "menuMode.Pause")),pausing?GTK_RELIEF_NORMAL:GTK_RELIEF_NONE);
+ /* toggle background color in showbuttonbar */
+ if (appData.showButtonBar) {
if (pausing) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ gtk_button_pressed(GTK_BUTTON (gtk_builder_get_object (builder, "buttonbar.Pause")));
} else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Pause"),
- args, 1);
-
- if (appData.showButtonBar) {
- /* Always toggle, don't set. Previous code messes up when
- invoked while the button is pressed, as releasing it
- toggles the state again. */
- {
- Pixel oldbg, oldfg;
- XtSetArg(args[0], XtNbackground, &oldbg);
- XtSetArg(args[1], XtNforeground, &oldfg);
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),
- args, 2);
- XtSetArg(args[0], XtNbackground, oldfg);
- XtSetArg(args[1], XtNforeground, oldbg);
- }
- XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
+ gtk_button_released(GTK_BUTTON (gtk_builder_get_object (builder, "buttonbar.Pause")));
}
+ }
}
wname = ModeToWidgetName(oldmode);
- if (wname != NULL) {
- XtSetArg(args[0], XtNleftBitmap, None);
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
- }
- wname = ModeToWidgetName(gameMode);
- if (wname != NULL) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
- }
+ if(wname)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, wname)),True);
+
oldmode = gameMode;
/* Maybe all the enables should be handled here, not just this one */
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Training"),
- gameMode == Training || gameMode == PlayFromGameFile);
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (gtk_builder_get_object (builder, "menuMode.Training")),
+ gameMode == Training || gameMode == PlayFromGameFile);
}
/*
* Button/menu procedures
*/
-void ResetProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ResetGameEvent();
- EngineOutputPopDown();
-}
int LoadGamePopUp(f, gameNumber, title)
FILE *f;
char *title;
{
cmailMsgLoaded = FALSE;
- if (gameNumber == 0) {
+
+ if (gameNumber == 0)
+ {
int error = GameListBuild(f);
- if (error) {
+
+ if (error)
+ {
DisplayError(_("Cannot build game list"), error);
- } else if (!ListEmpty(&gameList) &&
- ((ListGame *) gameList.tailPred)->number > 1) {
+ }
+ else if (!ListEmpty(&gameList)
+ && ((ListGame *) gameList.tailPred)->number > 1)
+ {
GameListPopUp(f, title);
return TRUE;
- }
+ };
+
GameListDestroy();
gameNumber = 1;
- }
- return LoadGame(f, gameNumber, title, FALSE);
-}
-
-void LoadGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
- Reset(FALSE, TRUE);
- }
- FileNamePopUp(_("Load game file name?"), "", LoadGamePopUp, "rb");
-}
-
-void LoadNextGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(1);
-}
-
-void LoadPrevGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(-1);
-}
-
-void ReloadGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadGame(0);
-}
-
-void LoadNextPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(1);
-}
-
-void LoadPrevPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(-1);
-}
+ };
-void ReloadPositionProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ReloadPosition(0);
+ return LoadGame(f, gameNumber, title, FALSE);
}
void LoadPositionProc(w, event, prms, nprms)
SaveGameProc(NULL, NULL, NULL, NULL);
}
-
-void QuitProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ExitEvent(0);
-}
-
-void PauseProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- PauseEvent();
-}
-
-
-void MachineBlackProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MachineBlackEvent();
-}
-
-void MachineWhiteProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MachineWhiteEvent();
-}
-
void AnalyzeModeProc(w, event, prms, nprms)
Widget w;
XEvent *event;
fprintf(debugFP, _("ICS engine analyze starting... \n"));
}
if (!appData.showThinking)
- ShowThinkingProc(w,event,prms,nprms);
+ ShowThinkingProc(NULL,NULL);
AnalyzeModeEvent();
}
Reset(FALSE, TRUE);
if (!appData.showThinking)
- ShowThinkingProc(w,event,prms,nprms);
+ ShowThinkingProc(NULL,NULL);
AnalyzeFileEvent();
FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
AnalysisPeriodicEvent(1);
}
-void TwoMachinesProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- TwoMachinesEvent();
-}
-
-void IcsClientProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- IcsClientEvent();
-}
void EditGameProc(w, event, prms, nprms)
Widget w;
}
}
-void AcceptProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AcceptEvent();
-}
-
-void DeclineProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- DeclineEvent();
-}
-
-void RematchProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RematchEvent();
-}
-
-void CallFlagProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- CallFlagEvent();
-}
-
-void DrawProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- DrawEvent();
-}
-
-void AbortProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AbortEvent();
-}
-
-void AdjournProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- AdjournEvent();
-}
-
-void ResignProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- 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;
ICSInputSendText();
}
-void StopObservingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- StopObservingEvent();
-}
-
-void StopExaminingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- StopExaminingEvent();
-}
-
-
-void ForwardProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ForwardEvent();
-}
-
-
-void BackwardProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- BackwardEvent();
-}
-
-void ToStartProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ToStartEvent();
-}
-
-void ToEndProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- ToEndEvent();
-}
-
-void RevertProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RevertEvent();
-}
-
-void TruncateGameProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- TruncateGameEvent();
-}
-void RetractMoveProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- RetractMoveEvent();
-}
-
-void MoveNowProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- MoveNowEvent();
-}
-
-
void AlwaysQueenProc(w, event, prms, nprms)
Widget w;
XEvent *event;
args, 1);
}
-void AutocommProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoComment = !appData.autoComment;
-
- if (appData.autoComment) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
- args, 1);
-}
-
-
-void AutoflagProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoCallFlag = !appData.autoCallFlag;
-
- if (appData.autoCallFlag) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
- args, 1);
-}
-
-void AutoflipProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.autoFlipView = !appData.autoFlipView;
-
- if (appData.autoFlipView) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),
- args, 1);
-}
-
void AutobsProc(w, event, prms, nprms)
Widget w;
XEvent *event;
args, 1);
}
-void FlipViewProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- flipView = !flipView;
- DrawPosition(True, NULL);
-}
-
-void GetMoveListProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.getMoveList = !appData.getMoveList;
-
- if (appData.getMoveList) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- GetMoveListEvent();
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
- args, 1);
-}
-
#if HIGHDRAG
void HighlightDraggingProc(w, event, prms, nprms)
Widget w;
args, 1);
}
-void ShowCoordsProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.showCoords = !appData.showCoords;
-
- if (appData.showCoords) {
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
- } else {
- XtSetArg(args[0], XtNleftBitmap, None);
- }
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
- args, 1);
-
- DrawPosition(True, NULL);
-}
-
-void ShowThinkingProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- Arg args[16];
-
- appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
- ShowThinkingEvent();
-}
-
-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)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
- INFODIR, INFOFILE);
- system(buf);
-}
-
-void ManProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
- String name;
- if (nprms && *nprms > 0)
- name = prms[0];
- else
- name = "xboard";
- snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
- system(buf);
-}
-
-void HintProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- HintEvent();
-}
-
-void BookProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- BookEvent();
-}
-
-void AboutProc(w, event, prms, nprms)
- Widget w;
- XEvent *event;
- String *prms;
- Cardinal *nprms;
-{
- char buf[MSG_SIZ];
-#if ZIPPY
- char *zippy = " (with Zippy code)";
-#else
- char *zippy = "";
-#endif
- 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-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);
-}
-
void DebugProc(w, event, prms, nprms)
Widget w;
XEvent *event;
}
void DisplayMessage(message, extMessage)
- char *message, *extMessage;
+ gchar *message, *extMessage;
{
- /* display a message in the message widget */
-
- char buf[MSG_SIZ];
- Arg arg;
-
- if (extMessage)
- {
- if (*message)
- {
- snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
- message = buf;
- }
- else
- {
- message = extMessage;
- };
- };
-
- /* need to test if messageWidget already exists, since this function
- can also be called during the startup, if for example a Xresource
- is not set up correctly */
- if(messageWidget)
- {
- XtSetArg(arg, XtNlabel, message);
- XtSetValues(messageWidget, &arg, 1);
- };
-
- return;
+ char buf[MSG_SIZ];
+ Arg arg;
+
+ if (extMessage) {
+ if (*message) {
+ snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
+ message = buf;
+ } else {
+ message = extMessage;
+ }
+ }
+ gtk_label_set_text( GTK_LABEL(gtk_builder_get_object (builder, "Messages")),message);
+
+ return;
}
void DisplayTitle(text)
char *text;
{
- Arg args[16];
- int i;
- char title[MSG_SIZ];
- char icon[MSG_SIZ];
+ gchar title[MSG_SIZ];
if (text == NULL) text = "";
- if (appData.titleInWindow) {
- i = 0;
- XtSetArg(args[i], XtNlabel, text); i++;
- XtSetValues(titleWidget, args, i);
- }
+ if (appData.titleInWindow)
+ {
+ /* TODO */
+ }
- if (*text != NULLCHAR) {
- strcpy(icon, text);
+ if (*text != NULLCHAR)
+ {
strcpy(title, text);
- } else if (appData.icsActive) {
- snprintf(icon, sizeof(icon), "%s", appData.icsHost);
+ }
+ else if (appData.icsActive)
+ {
snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
- } else if (appData.cmailGameName[0] != NULLCHAR) {
- snprintf(icon, sizeof(icon), "%s", "CMail");
+ }
+ else if (appData.cmailGameName[0] != NULLCHAR)
+ {
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);
+ }
+ else if (gameInfo.variant == VariantGothic)
+ {
strcpy(title, GOTHIC);
#endif
#ifdef FALCON
- } else if (gameInfo.variant == VariantFalcon) {
- strcpy(icon, programName);
+ }
+ else if (gameInfo.variant == VariantFalcon)
+ {
strcpy(title, FALCON);
#endif
- } else if (appData.noChessProgram) {
- strcpy(icon, programName);
+ }
+ else if (appData.noChessProgram)
+ {
strcpy(title, programName);
- } else {
- strcpy(icon, first.tidy);
+ }
+ else
+ {
snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
- }
- i = 0;
- XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
- XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;
- XtSetValues(shellWidget, args, i);
+ }
+ gtk_window_set_title(GTK_WINDOW(GUI_Window),title);
+
+ return;
}
#endif /* not HAVE_GETHOSTNAME */
}
-XtIntervalId delayedEventTimerXID = 0;
+guint delayedEventTimerTag = 0;
DelayedEventCallback delayedEventCallback = 0;
void
-FireDelayedEvent()
+FireDelayedEvent(data)
+ gpointer data;
{
- delayedEventTimerXID = 0;
- delayedEventCallback();
+ /* remove timer */
+ g_source_remove(delayedEventTimerTag);
+ delayedEventTimerTag = 0;
+
+ /* call function */
+ delayedEventCallback();
+
+ return;
}
void
ScheduleDelayedEvent(cb, millisec)
- DelayedEventCallback cb; long millisec;
+ DelayedEventCallback cb; guint millisec;
{
- if(delayedEventTimerXID && delayedEventCallback == cb)
+ if(delayedEventTimerTag && delayedEventCallback == cb)
// [HGM] alive: replace, rather than add or flush identical event
- XtRemoveTimeOut(delayedEventTimerXID);
+ g_source_remove(delayedEventTimerTag);
delayedEventCallback = cb;
- delayedEventTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
+ delayedEventTimerTag = g_timeout_add(millisec,(GSourceFunc) FireDelayedEvent, NULL);
+ return;
}
DelayedEventCallback
GetDelayedEvent()
{
- if (delayedEventTimerXID) {
- return delayedEventCallback;
- } else {
- return NULL;
- }
+ if (delayedEventTimerTag)
+ {
+ return delayedEventCallback;
+ }
+ else
+ {
+ return NULL;
+ }
}
void
CancelDelayedEvent()
{
- if (delayedEventTimerXID) {
- XtRemoveTimeOut(delayedEventTimerXID);
- delayedEventTimerXID = 0;
- }
+ if (delayedEventTimerTag)
+ {
+ g_source_remove(delayedEventTimerTag);
+ delayedEventTimerTag = 0;
+ }
+
+ return;
}
-XtIntervalId loadGameTimerXID = 0;
+guint loadGameTimerTag = 0;
int LoadGameTimerRunning()
{
- return loadGameTimerXID != 0;
+ return loadGameTimerTag != 0;
}
int StopLoadGameTimer()
{
- if (loadGameTimerXID != 0) {
- XtRemoveTimeOut(loadGameTimerXID);
- loadGameTimerXID = 0;
+ if (loadGameTimerTag != 0) {
+ g_source_remove(loadGameTimerTag);
+ loadGameTimerTag = 0;
return TRUE;
} else {
return FALSE;
}
void
-LoadGameTimerCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+LoadGameTimerCallback(data)
+ gpointer data;
{
- loadGameTimerXID = 0;
- AutoPlayGameLoop();
+ /* remove timer */
+ g_source_remove(loadGameTimerTag);
+ loadGameTimerTag = 0;
+
+ AutoPlayGameLoop();
+ return;
}
void
StartLoadGameTimer(millisec)
long millisec;
{
- loadGameTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) LoadGameTimerCallback,
- (XtPointer) 0);
+ loadGameTimerTag =
+ g_timeout_add( millisec, (GSourceFunc) LoadGameTimerCallback, NULL);
+ return;
}
-XtIntervalId analysisClockXID = 0;
+guint analysisClockTag = 0;
-void
-AnalysisClockCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+gboolean
+AnalysisClockCallback(data)
+ gpointer data;
{
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
- || appData.icsEngineAnalyze) { // [DM]
+ || appData.icsEngineAnalyze)
+ {
AnalysisPeriodicEvent(0);
- StartAnalysisClock();
- }
+ return 1; /* keep on going */
+ }
+ return 0; /* stop timer */
}
void
StartAnalysisClock()
{
- analysisClockXID =
- XtAppAddTimeOut(appContext, 2000,
- (XtTimerCallbackProc) AnalysisClockCallback,
- (XtPointer) 0);
+ analysisClockTag =
+ g_timeout_add( 2000,(GSourceFunc) AnalysisClockCallback, NULL);
+ return;
}
-XtIntervalId clockTimerXID = 0;
+guint clockTimerTag = 0;
int ClockTimerRunning()
{
- return clockTimerXID != 0;
+ return clockTimerTag != 0;
}
int StopClockTimer()
{
- if (clockTimerXID != 0) {
- XtRemoveTimeOut(clockTimerXID);
- clockTimerXID = 0;
+ if (clockTimerTag != 0)
+ {
+ g_source_remove(clockTimerTag);
+ clockTimerTag = 0;
return TRUE;
- } else {
+ }
+ else
+ {
return FALSE;
- }
+ }
}
void
-ClockTimerCallback(arg, id)
- XtPointer arg;
- XtIntervalId *id;
+ClockTimerCallback(data)
+ gpointer data;
{
- clockTimerXID = 0;
- DecrementClocks();
+ /* remove timer */
+ g_source_remove(clockTimerTag);
+ clockTimerTag = 0;
+
+ DecrementClocks();
+ return;
}
void
StartClockTimer(millisec)
long millisec;
{
- clockTimerXID =
- XtAppAddTimeOut(appContext, millisec,
- (XtTimerCallbackProc) ClockTimerCallback,
- (XtPointer) 0);
+ clockTimerTag = g_timeout_add(millisec,(GSourceFunc) ClockTimerCallback,NULL);
+ return;
}
void
DisplayTimerLabel(w, color, timer, highlight)
- Widget w;
+ GtkWidget *w;
char *color;
long timer;
int highlight;
{
- char buf[MSG_SIZ];
- Arg args[16];
-
- /* check for low time warning */
- Pixel foregroundOrWarningColor = timerForegroundPixel;
+ gchar buf[MSG_SIZ];
- 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);
- } else {
- sprintf(buf, "%s ", color);
- XtSetArg(args[0], XtNlabel, buf);
- }
-
- if (highlight) {
-
- XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
- XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
- } else {
- XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
- XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
- }
-
- XtSetValues(w, args, 3);
+ if (appData.clockMode) {
+ sprintf(buf, "%s: %s", color, TimeString(timer));
+ } else {
+ sprintf(buf, "%s ", color);
+ }
+ gtk_label_set_text(GTK_LABEL(w),buf);
+
+ /* 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);
+// } else {
+// sprintf(buf, "%s ", color);
+// XtSetArg(args[0], XtNlabel, buf);
+// }
+//
+// if (highlight) {
+//
+// XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
+// XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
+// } else {
+// XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
+// XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
+// }
+//
+// XtSetValues(w, args, 3);
+//
}
void
long timeRemaining;
int highlight;
{
- Arg args[16];
+ if(appData.noGUI) return;
- if(appData.noGUI) return;
- DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
- if (highlight && iconPixmap == bIconPixmap) {
- iconPixmap = wIconPixmap;
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);
- XtSetValues(shellWidget, args, 1);
+ DisplayTimerLabel(GUI_Whiteclock, _("White"), timeRemaining, highlight);
+ if (highlight && WindowIcon == BlackIcon)
+ {
+ WindowIcon = WhiteIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
}
}
long timeRemaining;
int highlight;
{
- Arg args[16];
-
if(appData.noGUI) return;
- DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
- if (highlight && iconPixmap == wIconPixmap) {
- iconPixmap = bIconPixmap;
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);
- XtSetValues(shellWidget, args, 1);
- }
+
+ DisplayTimerLabel(GUI_Blackclock, _("Black"), timeRemaining, highlight);
+ if (highlight && WindowIcon == WhiteIcon)
+ {
+ WindowIcon = BlackIcon;
+ gtk_window_set_icon(GTK_WINDOW(GUI_Window),WindowIcon);
+ }
}
#define CPNone 0
SetUpChildIO(to_prog, from_prog);
+ #ifdef SIGWINCH
+ signal(SIGWINCH, TermSizeSigHandler);
+ #endif
+
if ((pid = fork()) == 0) {
/* Child process */
// [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
int lineByLine;
char *unused;
InputCallback func;
- XtInputId xid;
+ guint sid;
char buf[INPUT_SOURCE_BUF_SIZE];
VOIDSTAR closure;
} InputSource;
void
-DoInputCallback(closure, source, xid)
- caddr_t closure;
- int *source;
- XtInputId *xid;
+DoInputCallback(io,cond,data)
+ GIOChannel *io;
+ GIOCondition cond;
+ gpointer *data;
{
- InputSource *is = (InputSource *) closure;
- int count;
- int error;
- char *p, *q;
+ /* read input from one of the input source (for example a chess program, ICS, etc).
+ * and call a function that will handle the input
+ */
- if (is->lineByLine) {
- count = read(is->fd, is->unused,
- INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
- if (count <= 0) {
- (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
- return;
+ int count; /* how many bytes did we read */
+ int error;
+ char *p, *q;
+
+ /* All information (callback function, file descriptor, etc) is
+ * saved in an InputSource structure
+ */
+ InputSource *is = (InputSource *) data;
+
+ if (is->lineByLine)
+ {
+ count = read(is->fd, is->unused,
+ INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
+
+ if (count <= 0)
+ {
+ (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
+ return;
}
- is->unused += count;
- p = is->buf;
- while (p < is->unused) {
- q = memchr(p, '\n', is->unused - p);
- if (q == NULL) break;
- q++;
- (is->func)(is, is->closure, p, q - p, 0);
- p = q;
+ is->unused += count;
+ p = is->buf;
+ /* break input into lines and call the callback function on each
+ * line
+ */
+ while (p < is->unused)
+ {
+ q = memchr(p, '\n', is->unused - p);
+ if (q == NULL) break;
+ q++;
+ (is->func)(is, is->closure, p, q - p, 0);
+ p = q;
}
- q = is->buf;
- while (p < is->unused) {
- *q++ = *p++;
+ /* remember not yet used part of the buffer */
+ q = is->buf;
+ while (p < is->unused)
+ {
+ *q++ = *p++;
}
- is->unused = q;
- } else {
- count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
- if (count == -1)
- error = errno;
- else
- error = 0;
- (is->func)(is, is->closure, is->buf, count, error);
+ is->unused = q;
}
+ else
+ {
+ /* read maximum length of input buffer and send the whole buffer
+ * to the callback function
+ */
+ count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+ }
+
+ return;
}
InputSourceRef AddInputSource(pr, lineByLine, func, closure)
VOIDSTAR closure;
{
InputSource *is;
+ GIOChannel *channel;
ChildProc *cp = (ChildProc *) pr;
is = (InputSource *) calloc(1, sizeof(InputSource));
is->kind = cp->kind;
is->fd = cp->fdFrom;
}
- if (lineByLine) {
- is->unused = is->buf;
- }
+ if (lineByLine)
+ is->unused = is->buf;
+ else
+ is->unused = NULL;
+
+// is->xid = XtAppAddInput(appContext, is->fd,
+// (XtPointer) (XtInputReadMask),
+// (XtInputCallbackProc) DoInputCallback,
+// (XtPointer) is);
+//
+
+ /* TODO: will this work on windows?*/
+ printf("DEBUG: fd=%d %d\n",is->fd,is);
- is->xid = XtAppAddInput(appContext, is->fd,
- (XtPointer) (XtInputReadMask),
- (XtInputCallbackProc) DoInputCallback,
- (XtPointer) is);
+ channel = g_io_channel_unix_new(is->fd);
+ g_io_channel_set_close_on_unref (channel, TRUE);
+ is->sid = g_io_add_watch(channel, G_IO_IN,(GIOFunc) DoInputCallback, is);
is->closure = closure;
return (InputSourceRef) is;
}
{
InputSource *is = (InputSource *) isr;
- if (is->xid == 0) return;
- XtRemoveInput(is->xid);
- is->xid = 0;
+ if (is->sid == 0) return;
+ g_source_remove(is->sid);
+ is->sid = 0;
+ return;
}
int OutputToProcess(pr, message, count, outError)
unsigned long plane;
XGCValues values;
+ /* just return for gtk at the moment */
+ return;
+
/* Need a bitmap just to get a GC with right depth */
buf = XCreatePixmap(xDisplay, xBoardWindow,
8, 8, 1);
XGCValues values;
/* Each buffer is square size, same depth as window */
- anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, info->depth);
- anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, info->depth);
-
- /* Create a plain GC for blitting */
- mask = GCForeground | GCBackground | GCFunction |
- GCPlaneMask | GCGraphicsExposures;
- values.foreground = XBlackPixel(xDisplay, xScreen);
- values.background = XWhitePixel(xDisplay, xScreen);
- values.function = GXcopy;
- values.plane_mask = AllPlanes;
- values.graphics_exposures = False;
- anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
-
- /* Piece will be copied from an existing context at
- the start of each new animation/drag. */
- anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
-
- /* Outline will be a read-only copy of an existing */
- anim->outlineGC = None;
+// anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, info->depth);
+// anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
+// squareSize, squareSize, info->depth);
+//
+// /* Create a plain GC for blitting */
+// mask = GCForeground | GCBackground | GCFunction |
+// GCPlaneMask | GCGraphicsExposures;
+// values.foreground = XBlackPixel(xDisplay, xScreen);
+// values.background = XWhitePixel(xDisplay, xScreen);
+// values.function = GXcopy;
+// values.plane_mask = AllPlanes;
+// values.graphics_exposures = False;
+// anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
+//
+// /* Piece will be copied from an existing context at
+// the start of each new animation/drag. */
+// anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
+//
+// /* Outline will be a read-only copy of an existing */
+// anim->outlineGC = None;
}
static void
static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
XWindowAttributes info;
+ /* for gtk at the moment just ... */
+ return;
+
if (xpmDone && gameInfo.variant == old) return;
if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
- XGetWindowAttributes(xDisplay, xBoardWindow, &info);
+ // XGetWindowAttributes(xDisplay, xBoardWindow, &info);
- InitAnimState(&game, &info);
- InitAnimState(&player, &info);
+ // InitAnimState(&game, &info);
+ // InitAnimState(&player, &info);
/* For XPM pieces, we need bitmaps to use as masks. */
- if (useImages)
- CreateAnimMasks(info.depth);
+ // if (useImages)
+ // CreateAnimMasks(info.depth);
xpmDone = 1;
}
FrameDelay (time)
int time;
{
- XSync(xDisplay, False);
+ // XSync(xDisplay, False);
if (time > 0)
usleep(time * 1000);
}
else
source = blPieceGC;
}
- XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
+ // XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
/* Outline only used in mono mode and is not modified */
if (White(piece))
if (!useImages) {
/* Draw solid rectangle which will be clipped to shape of piece */
- XFillRectangle(xDisplay, dest, clip,
- 0, 0, squareSize, squareSize);
+// XFillRectangle(xDisplay, dest, clip,
+// 0, 0, squareSize, squareSize)
+;
if (appData.monoMode)
/* Also draw outline in contrasting color for black
on black / white on white cases */
- XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
- 0, 0, squareSize, squareSize, 0, 0, 1);
+// XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
+// 0, 0, squareSize, squareSize, 0, 0, 1)
+;
} else {
/* Copy the piece */
if (White(piece))
kind = 0;
else
kind = 2;
- XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
- dest, clip,
- 0, 0, squareSize, squareSize,
- 0, 0);
+// XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
+// dest, clip,
+// 0, 0, squareSize, squareSize,
+// 0, 0);
}
}
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);
+// SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
+// XSetClipMask(xDisplay, anim->pieceGC, mask);
}
static void
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);
+// 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,
the contents in newBuf are wrong. */
- XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
- overlap.x, overlap.y,
- overlap.width, overlap.height,
- pt.x, pt.y);
+// XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
+// overlap.x, overlap.y,
+// overlap.width, overlap.height,
+// pt.x, pt.y);
/* Repaint the areas in the old that don't overlap new */
CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);
for (i = 0; i < count; i++)
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- updates[i].x - anim->prevFrame.x,
- updates[i].y - anim->prevFrame.y,
- updates[i].width, updates[i].height,
- updates[i].x, updates[i].y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// updates[i].x - anim->prevFrame.x,
+// updates[i].y - anim->prevFrame.y,
+// updates[i].width, updates[i].height,
+// updates[i].x, updates[i].y)
+;
} else {
/* Easy when no overlap */
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- anim->prevFrame.x, anim->prevFrame.y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// anim->prevFrame.x, anim->prevFrame.y);
}
/* Save this frame for next time round */
- XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
- 0, 0, squareSize, squareSize,
- 0, 0);
+// XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
+// 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);
- XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- frame->x, frame->y);
+// XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// frame->x, frame->y);
}
static void
if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {
CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);
for (i = 0; i < count; i++)
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- updates[i].x - anim->prevFrame.x,
- updates[i].y - anim->prevFrame.y,
- updates[i].width, updates[i].height,
- updates[i].x, updates[i].y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// updates[i].x - anim->prevFrame.x,
+// updates[i].y - anim->prevFrame.y,
+// updates[i].width, updates[i].height,
+// updates[i].x, updates[i].y)
+;
} else {
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
- 0, 0, squareSize, squareSize,
- anim->prevFrame.x, anim->prevFrame.y);
+// XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
+// 0, 0, squareSize, squareSize,
+// anim->prevFrame.x, anim->prevFrame.y);
}
}
if (!appData.animate || appData.blindfold)
return;
- if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
- board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
+ if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
+ board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
damage[toY][toX] = True;
}
-static void
+void
DragPieceBegin(x, y)
int x; int y;
{
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
+// 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;
#endif
}
-static void
+void
DragPieceEnd(x, y)
int x; int y;
{
// [HGM] done, but perhaps backend should call this directly?
EngineOutputUpdate( stats );
}
+
+ #include <sys/ioctl.h>
+ int get_term_width()
+ {
+ int fd, default_width;
+
+ fd = STDIN_FILENO;
+ default_width = 79; // this is FICS default anyway...
+
+ #if !defined(TIOCGWINSZ) && defined(TIOCGSIZE)
+ struct ttysize win;
+ if (!ioctl(fd, TIOCGSIZE, &win))
+ default_width = win.ts_cols;
+ #elif defined(TIOCGWINSZ)
+ struct winsize win;
+ if (!ioctl(fd, TIOCGWINSZ, &win))
+ default_width = win.ws_col;
+ #endif
+ return default_width;
+ }
+
+ void update_ics_width()
+ {
+ static int old_width = 0;
+ int new_width = get_term_width();
+
+ if (old_width != new_width)
+ ics_printf("set width %d\n", new_width);
+ old_width = new_width;
+ }
+
+ void NotifyFrontendLogin()
+ {
+ update_ics_width();
+ }
projects / xboard.git / commitdiff