* 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, 2010 Free Software Foundation, Inc.
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
+#include <math.h>
#if !OMIT_SOCKETS
# if HAVE_SYS_SOCKET_H
#include "frontend.h"
#include "backend.h"
+#include "backendz.h"
#include "moves.h"
#include "xboard.h"
#include "childio.h"
typedef struct {
String string;
+ String ref;
XtActionProc proc;
} MenuItem;
typedef struct {
String name;
+ String ref;
MenuItem *mi;
} Menu;
void CreateGCs P((void));
void CreateXIMPieces P((void));
void CreateXPMPieces P((void));
+void CreateXPMBoard P((char *s, int n));
void CreatePieces P((void));
void CreatePieceMenus P((void));
Widget CreateMenuBar P((Menu *mb));
void update_ics_width P(());
int get_term_width P(());
int CopyMemoProc P(());
+void DrawArrowHighlight P((int fromX, int fromY, int toX,int toY));
+Boolean IsDrawArrowEnabled P(());
+
/*
* XBoard depends on Xt R4 or higher
*/
Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
-int useImages, useImageSqs;
+Pixmap xpmBoardBitmap[2];
+int useImages, useImageSqs, useTexture, textureW[2], textureH[2];
XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
MenuItem fileMenu[] = {
- {N_("New Game"), ResetProc},
- {N_("New Shuffle Game ..."), ShuffleMenuProc},
- {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
- {"----", NothingProc},
- {N_("Load Game"), LoadGameProc},
- {N_("Load Next Game"), LoadNextGameProc},
- {N_("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_("Save Position"), SavePositionProc},
- {"----", NothingProc},
- {N_("Copy Position"), CopyPositionProc},
- {N_("Paste Position"), PastePositionProc},
- {"----", NothingProc},
- {N_("Mail Move"), MailMoveProc},
- {N_("Reload CMail Message"), ReloadCmailMsgProc},
- {"----", NothingProc},
- {N_("Exit"), QuitProc},
- {NULL, NULL}
+ {N_("New Game Ctrl+N"), "New Game", ResetProc},
+ {N_("New Shuffle Game ..."), "New Shuffle Game", ShuffleMenuProc},
+ {N_("New Variant ... Alt+Shift+V"), "New Variant", NewVariantProc}, // [HGM] variant: not functional yet
+ {"----", NULL, NothingProc},
+ {N_("Load Game Ctrl+O"), "Load Game", LoadGameProc},
+ {N_("Load Position Ctrl+Shift+O"), "Load Position", LoadPositionProc},
+// {N_("Load Next Game"), "Load Next Game", LoadNextGameProc},
+// {N_("Load Previous Game"), "Load Previous Game", LoadPrevGameProc},
+// {N_("Reload Same Game"), "Reload Same Game", ReloadGameProc},
+ {"----", NULL, NothingProc},
+// {N_("Load Next Position"), "Load Next Position", LoadNextPositionProc},
+// {N_("Load Previous Position"), "Load Previous Position", LoadPrevPositionProc},
+// {N_("Reload Same Position"), "Reload Same Position", ReloadPositionProc},
+ {N_("Save Game Ctrl+S"), "Save Game", SaveGameProc},
+ {N_("Save Position Ctrl+Shift+S"), "Save Position", SavePositionProc},
+ {"----", NULL, NothingProc},
+ {N_("Mail Move"), "Mail Move", MailMoveProc},
+ {N_("Reload CMail Message"), "Reload CMail Message", ReloadCmailMsgProc},
+ {"----", NULL, NothingProc},
+ {N_("Quit Ctr+Q"), "Exit", QuitProc},
+ {NULL, NULL, NULL}
+};
+
+MenuItem editMenu[] = {
+ {N_("Copy Game Ctrl+C"), "Copy Game", CopyGameProc},
+ {N_("Copy Position Ctrl+Shift+C"), "Copy Position", CopyPositionProc},
+ {"----", NULL, NothingProc},
+ {N_("Paste Game Ctrl+V"), "Paste Game", PasteGameProc},
+ {N_("Paste Position Ctrl+Shift+V"), "Paste Position", PastePositionProc},
+ {"----", NULL, NothingProc},
+ {N_("Edit Game Ctrl+E"), "Edit Game", EditGameProc},
+ {N_("Edit Position Ctrl+Shift+E"), "Edit Position", EditPositionProc},
+ {N_("Edit Tags"), "Edit Tags", EditTagsProc},
+ {N_("Edit Comment"), "Edit Comment", EditCommentProc},
+ {"----", NULL, NothingProc},
+ {N_("Revert Home"), "Revert", RevertProc},
+ {N_("Annotate"), "Annotate", AnnotateProc},
+ {N_("Truncate Game End"), "Truncate Game", TruncateGameProc},
+ {"----", NULL, NothingProc},
+ {N_("Backward Alt+Left"), "Backward", BackwardProc},
+ {N_("Forward Alt+Right"), "Forward", ForwardProc},
+ {N_("Back to Start Alt+Home"), "Back to Start", ToStartProc},
+ {N_("Forward to End Alt+End"), "Forward to End", ToEndProc},
+ {NULL, NULL, NULL}
+};
+
+MenuItem viewMenu[] = {
+ {N_("Flip View F2"), "Flip View", FlipViewProc},
+ {"----", NULL, NothingProc},
+ {N_("Engine Output Alt+Shift+O"), "Show Engine Output", EngineOutputProc},
+ {N_("Move History Alt+Shift+H"), "Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
+ {N_("Evaluation Graph Alt+Shift+E"), "Show Evaluation Graph", EvalGraphProc},
+ {N_("Game List Alt+Shift+G"), "Show Game List", ShowGameListProc},
+ {"----", NULL, NothingProc},
+ {N_("Tags"), "Show Tags", EditTagsProc},
+ {N_("Comments"), "Show Comments", EditCommentProc},
+ {N_("ICS Input Box"), "ICS Input Box", IcsInputBoxProc},
+ {NULL, NULL, NULL}
};
MenuItem modeMenu[] = {
- {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_("Edit Game"), EditGameProc},
- {N_("Edit Position"), EditPositionProc},
- {N_("Training"), TrainingProc},
- {"----", NothingProc},
- {N_("Show Engine Output"), EngineOutputProc},
- {N_("Show Evaluation Graph"), EvalGraphProc},
- {N_("Show Game List"), ShowGameListProc},
- {N_("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}
+ {N_("Machine White Ctrl+W"), "Machine White", MachineWhiteProc},
+ {N_("Machine Black Ctrl+B"), "Machine Black", MachineBlackProc},
+ {N_("Two Machines Ctrl+T"), "Two Machines", TwoMachinesProc},
+ {N_("Analysis Mode Ctrl+A"), "Analysis Mode", AnalyzeModeProc},
+ {N_("Analyze File Ctrl+F"), "Analyze File", AnalyzeFileProc },
+ {N_("Edit Game Ctrl+E"), "Edit Game", EditGameProc},
+ {N_("Edit Position Ctrl+Shift+E"), "Edit Position", EditPositionProc},
+ {N_("Training"), "Training", TrainingProc},
+ {N_("ICS Client"), "ICS Client", IcsClientProc},
+ {"----", NULL, NothingProc},
+ {N_("Pause Pause"), "Pause", PauseProc},
+ {NULL, 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},
- {N_("Upload to Examine"), UploadProc},
- {"----", NothingProc},
- {N_("Adjudicate to White"), AdjuWhiteProc},
- {N_("Adjudicate to Black"), AdjuBlackProc},
- {N_("Adjudicate Draw"), AdjuDrawProc},
- {NULL, NULL}
+ {N_("Accept F3"), "Accept", AcceptProc},
+ {N_("Decline F4"), "Decline", DeclineProc},
+ {N_("Rematch F12"), "Rematch", RematchProc},
+ {"----", NULL, NothingProc},
+ {N_("Call Flag F5"), "Call Flag", CallFlagProc},
+ {N_("Draw F6"), "Draw", DrawProc},
+ {N_("Adjourn F7"), "Adjourn", AdjournProc},
+ {N_("Abort F8"),"Abort", AbortProc},
+ {N_("Resign F9"), "Resign", ResignProc},
+ {"----", NULL, NothingProc},
+ {N_("Stop Observing F10"), "Stop Observing", StopObservingProc},
+ {N_("Stop Examining F11"), "Stop Examining", StopExaminingProc},
+ {N_("Upload to Examine"), "Upload to Examine", UploadProc},
+ {"----", NULL, NothingProc},
+ {N_("Adjudicate to White"), "Adjudicate to White", AdjuWhiteProc},
+ {N_("Adjudicate to Black"), "Adjudicate to Black", AdjuBlackProc},
+ {N_("Adjudicate Draw"), "Adjudicate Draw", AdjuDrawProc},
+ {NULL, NULL, NULL}
};
-MenuItem stepMenu[] = {
- {N_("Backward"), BackwardProc},
- {N_("Forward"), ForwardProc},
- {N_("Back to Start"), ToStartProc},
- {N_("Forward to End"), ToEndProc},
- {N_("Revert"), RevertProc},
- {N_("Annotate"), AnnotateProc},
- {N_("Truncate Game"), TruncateGameProc},
- {"----", NothingProc},
- {N_("Move Now"), MoveNowProc},
- {N_("Retract Move"), RetractMoveProc},
- {NULL, NULL}
+MenuItem engineMenu[] = {
+ {N_("Engine #1 Settings ..."), "Engine #1 Settings", FirstSettingsProc},
+ {N_("Engine #2 Settings ..."), "Engine #2 Settings", SecondSettingsProc},
+ {"----", NULL, NothingProc},
+ {N_("Hint"), "Hint", HintProc},
+ {N_("Book"), "Book", BookProc},
+ {"----", NULL, NothingProc},
+ {N_("Move Now Ctrl+M"), "Move Now", MoveNowProc},
+ {N_("Retract Move Ctrl+X"), "Retract Move", RetractMoveProc},
+ {NULL, NULL, NULL}
};
MenuItem optionsMenu[] = {
- {N_("Flip View"), FlipViewProc},
- {"----", NothingProc},
- {N_("Adjudications ..."), EngineMenuProc},
- {N_("General Settings ..."), UciMenuProc},
- {N_("Engine #1 Settings ..."), FirstSettingsProc},
- {N_("Engine #2 Settings ..."), SecondSettingsProc},
- {N_("Time Control ..."), TimeControlProc},
- {N_("Game List ..."), GameListOptionsPopUp},
- {"----", NothingProc},
- {N_("Always Queen"), AlwaysQueenProc},
- {N_("Animate Dragging"), AnimateDraggingProc},
- {N_("Animate Moving"), AnimateMovingProc},
- {N_("Auto Comment"), AutocommProc},
- {N_("Auto Flag"), AutoflagProc},
- {N_("Auto Flip View"), AutoflipProc},
- {N_("Auto Observe"), AutobsProc},
- {N_("Auto Raise Board"), AutoraiseProc},
- {N_("Auto Save"), AutosaveProc},
- {N_("Blindfold"), BlindfoldProc},
- {N_("Flash Moves"), FlashMovesProc},
- {N_("Get Move List"), GetMoveListProc},
+ {N_("Time Control ... Alt+Shift+T"), "Time Control", TimeControlProc},
+ {N_("Common Engine ... Alt+Shift+U"), "Common Engine", UciMenuProc},
+ {N_("Adjudications ... Alt+Shift+J"), "Adjudications", EngineMenuProc},
+ {N_("Game List ..."), "Game List", GameListOptionsPopUp},
+ {"----", NULL, NothingProc},
+ {N_("Always Queen Ctrl+Shift+Q"), "Always Queen", AlwaysQueenProc},
+ {N_("Animate Dragging"), "Animate Dragging", AnimateDraggingProc},
+ {N_("Animate Moving Ctrl+Shift+A"), "Animate Moving", AnimateMovingProc},
+ {N_("Auto Comment"), "Auto Comment", AutocommProc},
+ {N_("Auto Flag Ctrl+Shift+F"), "Auto Flag", AutoflagProc},
+ {N_("Auto Flip View"), "Auto Flip View", AutoflipProc},
+ {N_("Auto Observe"), "Auto Observe", AutobsProc},
+ {N_("Auto Raise Board"), "Auto Raise Board", AutoraiseProc},
+ {N_("Auto Save"), "Auto Save", AutosaveProc},
+ {N_("Blindfold"), "Blindfold", BlindfoldProc},
+ {N_("Flash Moves"), "Flash Moves", FlashMovesProc},
+ {N_("Get Move List"), "Get Move List", GetMoveListProc},
#if HIGHDRAG
- {N_("Highlight Dragging"), HighlightDraggingProc},
+ {N_("Highlight Dragging"), "Highlight Dragging", HighlightDraggingProc},
#endif
- {N_("Highlight Last Move"), HighlightLastMoveProc},
- {N_("Move Sound"), MoveSoundProc},
- {N_("ICS Alarm"), IcsAlarmProc},
- {N_("Old Save Style"), OldSaveStyleProc},
- {N_("Periodic Updates"), PeriodicUpdatesProc},
- {N_("Ponder Next Move"), PonderNextMoveProc},
- {N_("Popup Exit Message"), PopupExitMessageProc},
- {N_("Popup Move Errors"), PopupMoveErrorsProc},
- {N_("Premove"), PremoveProc},
- {N_("Quiet Play"), QuietPlayProc},
- {N_("Show Coords"), ShowCoordsProc},
- {N_("Hide Thinking"), HideThinkingProc},
- {N_("Test Legality"), TestLegalityProc},
- {"----", NothingProc},
- {N_("Save Settings Now"), SaveSettingsProc},
- {N_("Save Settings on Exit"), SaveOnExitProc},
- {NULL, NULL}
+ {N_("Highlight Last Move"), "Highlight Last Move", HighlightLastMoveProc},
+ {N_("Move Sound"), "Move Sound", MoveSoundProc},
+ {N_("ICS Alarm"), "ICS Alarm", IcsAlarmProc},
+ {N_("Old Save Style"), "Old Save Style", OldSaveStyleProc},
+ {N_("Periodic Updates"), "Periodic Updates", PeriodicUpdatesProc},
+ {N_("Ponder Next Move Ctrl+Shift+P"), "Ponder Next Move", PonderNextMoveProc},
+ {N_("Popup Exit Message"), "Popup Exit Message", PopupExitMessageProc},
+ {N_("Popup Move Errors"), "Popup Move Errors", PopupMoveErrorsProc},
+ {N_("Premove"), "Premove", PremoveProc},
+ {N_("Quiet Play"), "Quiet Play", QuietPlayProc},
+ {N_("Show Coords"), "Show Coords", ShowCoordsProc},
+ {N_("Hide Thinking Ctrl+Shift+H"), "Hide Thinking", HideThinkingProc},
+ {N_("Test Legality Ctrl+Shift+L"), "Test Legality", TestLegalityProc},
+ {"----", NULL, NothingProc},
+ {N_("Save Settings Now"), "Save Settings Now", SaveSettingsProc},
+ {N_("Save Settings on Exit"), "Save Settings on Exit", SaveOnExitProc},
+ {NULL, NULL, NULL}
};
MenuItem helpMenu[] = {
- {N_("Info XBoard"), InfoProc},
- {N_("Man XBoard"), ManProc},
- {"----", NothingProc},
- {N_("Hint"), HintProc},
- {N_("Book"), BookProc},
- {"----", NothingProc},
- {N_("About XBoard"), AboutProc},
- {NULL, NULL}
+ {N_("Info XBoard"), "Info XBoard", InfoProc},
+ {N_("Man XBoard F1"), "Man XBoard", ManProc},
+ {"----", NULL, NothingProc},
+ {N_("About XBoard"), "About XBoard", AboutProc},
+ {NULL, NULL, NULL}
};
Menu menuBar[] = {
- {N_("File"), fileMenu},
- {N_("Mode"), modeMenu},
- {N_("Action"), actionMenu},
- {N_("Step"), stepMenu},
- {N_("Options"), optionsMenu},
- {N_("Help"), helpMenu},
- {NULL, NULL}
+ {N_("File"), "File", fileMenu},
+ {N_("Edit"), "Edit", editMenu},
+ {N_("View"), "View", viewMenu},
+ {N_("Mode"), "Mode", modeMenu},
+ {N_("Action"), "Action", actionMenu},
+ {N_("Engine"), "Engine", engineMenu},
+ {N_("Options"), "Options", optionsMenu},
+ {N_("Help"), "Help", helpMenu},
+ {NULL, NULL, NULL}
};
-#define PAUSE_BUTTON N_("P")
+#define PAUSE_BUTTON "P"
MenuItem buttonBar[] = {
- {"<<", ToStartProc},
- {"<", BackwardProc},
- {PAUSE_BUTTON, PauseProc},
- {">", ForwardProc},
- {">>", ToEndProc},
- {NULL, NULL}
+ {"<<", "<<", ToStartProc},
+ {"<", "<", BackwardProc},
+ {PAUSE_BUTTON, PAUSE_BUTTON, PauseProc},
+ {">", ">", ForwardProc},
+ {">>", ">>", ToEndProc},
+ {NULL, 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 },
};
:Meta<Key>Right: ForwardProc() \n \
:Meta<Key>Home: ToStartProc() \n \
:Meta<Key>Left: BackwardProc() \n \
+ :<Key>Home: RevertProc() \n \
+ :<Key>End: TruncateGameProc() \n \
:Ctrl<Key>m: MoveNowProc() \n \
:Ctrl<Key>x: RetractMoveProc() \n \
:Meta<Key>J: EngineMenuProc() \n \
\"Send to second chess program:\",,2) \n";
char boardTranslations[] =
- "<Btn1Down>: HandleUserMove() \n \
- <Btn1Up>: HandleUserMove() \n \
+ "<Btn1Down>: HandleUserMove(0) \n \
+ Shift<Btn1Up>: HandleUserMove(1) \n \
+ <Btn1Up>: HandleUserMove(0) \n \
<Btn1Motion>: AnimateUserMove() \n \
<Btn3Motion>: HandlePV() \n \
<Btn3Up>: PieceMenuPopup(menuB) \n \
void *
colorVariable[] = {
- &appData.whitePieceColor,
- &appData.blackPieceColor,
+ &appData.whitePieceColor,
+ &appData.blackPieceColor,
&appData.lightSquareColor,
- &appData.darkSquareColor,
+ &appData.darkSquareColor,
&appData.highlightSquareColor,
&appData.premoveHighlightColor,
&appData.lowTimeWarningColor,
void
ParseTextAttribs(ColorClass cc, char *s)
-{
+{
(&appData.colorShout)[cc] = strdup(s);
}
void
SaveFontArg(FILE *f, ArgDescriptor *ad)
{
- char *name, buf[MSG_SIZ];
+ char *name;
int i, n = (int)ad->argLoc;
switch(n) {
case 0: // CLOCK_FONT
break;
}
for(i=0; i<MAX_SIZE; i++) if(fontValid[n][i]) // [HGM] font: store all standard fonts
- fprintf(f, OPTCHAR "%s" SEPCHAR "size%d:%s\n", ad->argName, i, fontTable[n][i]);
+ fprintf(f, OPTCHAR "%s" SEPCHAR "size%d:%s\n", ad->argName, i, fontTable[n][i]);
}
void
int i;
if(!wg) return;
-
+
i = 0;
XtSetArg(args[i], XtNx, &x); i++;
XtSetArg(args[i], XtNy, &y); i++;
MySearchPath(char *installDir, char *name, char *fullname)
{ // just append installDir and name. Perhaps ExpandPath should be used here?
name = ExpandPathName(name);
- if(name && name[0] == '/') strcpy(fullname, name); else {
+ if(name && name[0] == '/')
+ safeStrCpy(fullname, name, MSG_SIZ );
+ else {
sprintf(fullname, "%s%c%s", installDir, '/', name);
}
return 1;
MyGetFullPathName(char *name, char *fullname)
{ // should use ExpandPath?
name = ExpandPathName(name);
- strcpy(fullname, name);
+ safeStrCpy(fullname, name, MSG_SIZ );
return 1;
}
PopUpStartupDialog()
{ // start menu not implemented in XBoard
}
+
char *
ConvertToLine(int argc, char **argv)
{
int i;
line[0] = NULLCHAR;
- for(i=1; i<argc; i++) {
- if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
- && argv[i][0] != '{' )
- sprintf(buf, "{%s} ", argv[i]);
- else sprintf(buf, "%s ", argv[i]);
- strcat(line, buf);
- }
- line[strlen(line)-1] = NULLCHAR;
+ for(i=1; i<argc; i++)
+ {
+ if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
+ && argv[i][0] != '{' )
+ snprintf(buf, sizeof(buf)/sizeof(buf[0]), "{%s} ", argv[i]);
+ else
+ snprintf(buf, sizeof(buf)/sizeof(buf[0]), "%s ", argv[i]);
+ strncat(line, buf, 128*1024 - strlen(line) - 1 );
+ }
+
+ line[strlen(line)-1] = NULLCHAR;
return line;
}
xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
}
#endif
+ if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ xpmPieceBitmap[i][(int)WhiteAngel] = xpmPieceBitmap2[i][(int)WhiteFalcon];
+ xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteAlfil];
+ }
#if !HAVE_LIBXPM
// [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
for(p=0; p<=(int)WhiteKing; p++)
ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
}
#endif
+ if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ ximMaskPm[(int)WhiteAngel] = ximMaskPm2[(int)WhiteFalcon];
+ ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteAlfil];
+ }
#endif
}
} else {
pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
}
#endif
+ if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ pieceBitmap[i][(int)WhiteAngel] = pieceBitmap2[i][(int)WhiteFalcon];
+ pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteAlfil];
+ }
}
}
#if HAVE_LIBXPM
fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
}
}
+ if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
/* [HR] height treated separately (hacked) */
boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
if (forceMono) {
fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
programName);
-
+
if (appData.bitmapDirectory == NULL ||
appData.bitmapDirectory[0] == NULLCHAR)
appData.bitmapDirectory = DEF_BITMAP_DIR;
vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
vFrom.size = strlen(appData.lowTimeWarningColor);
XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
- if (vTo.addr == NULL)
+ if (vTo.addr == NULL)
appData.monoMode = True;
else
lowTimeWarningColor = *(Pixel *) vTo.addr;
CreatePieces();
} else {
CreateXPMPieces();
+ CreateXPMBoard(appData.liteBackTextureFile, 1);
+ CreateXPMBoard(appData.darkBackTextureFile, 0);
}
#else
CreateXIMPieces();
HistoryPopUp();
}
- if( wpEvalGraph.visible )
+ if( wpEvalGraph.visible )
{
EvalGraphPopUp();
};
-
+
if( wpEngineOutput.visible ) {
EngineOutputPopUp();
}
void
ICSInitScript()
{
- FILE *f;
- char buf[MSG_SIZ];
- char *p;
+ /* try to open the icsLogon script, either in the location given
+ * or in the users HOME directory
+ */
- f = fopen(appData.icsLogon, "r");
- if (f == NULL) {
- p = getenv("HOME");
- if (p != NULL) {
- strcpy(buf, p);
- strcat(buf, "/");
- strcat(buf, appData.icsLogon);
- f = fopen(buf, "r");
+ FILE *f;
+ char buf[MSG_SIZ];
+ char *homedir;
+
+ f = fopen(appData.icsLogon, "r");
+ if (f == NULL)
+ {
+ homedir = getenv("HOME");
+ if (homedir != NULL)
+ {
+ safeStrCpy(buf, homedir, sizeof(buf)/sizeof(buf[0]) );
+ strncat(buf, "/", MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, appData.icsLogon, MSG_SIZ - strlen(buf) - 1);
+ f = fopen(buf, "r");
}
}
- if (f != NULL)
- ProcessICSInitScript(f);
+
+ if (f != NULL)
+ ProcessICSInitScript(f);
+ else
+ printf("Warning: Couldn't open icsLogon file (checked %s and %s).\n", appData.icsLogon, buf);
+
+ return;
}
void
{
Widget w;
if (!menuBarWidget) return;
- w = XtNameToWidget(menuBarWidget, "menuStep.Revert");
+ w = XtNameToWidget(menuBarWidget, "menuEdit.Revert");
if (w == NULL) {
- DisplayError("menuStep.Revert", 0);
+ DisplayError("menuEdit.Revert", 0);
} else {
XtSetSensitive(w, !grey);
}
- w = XtNameToWidget(menuBarWidget, "menuStep.Annotate");
+ w = XtNameToWidget(menuBarWidget, "menuEdit.Annotate");
if (w == NULL) {
- DisplayError("menuStep.Annotate", 0);
+ DisplayError("menuEdit.Annotate", 0);
} else {
XtSetSensitive(w, !grey);
}
{ "menuMode.Analyze File", False },
{ "menuMode.Two Machines", False },
#ifndef ZIPPY
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
- { "menuStep.Move Now", False },
+ { "menuEngine.Hint", False },
+ { "menuEngine.Book", False },
+ { "menuEngine.Move Now", False },
{ "menuOptions.Periodic Updates", False },
{ "menuOptions.Hide Thinking", False },
{ "menuOptions.Ponder Next Move", False },
+ { "menuEngine.Engine #1 Settings", False },
#endif
- { "menuStep.Annotate", False },
+ { "menuEngine.Engine #2 Settings", False },
+ { "menuEdit.Annotate", False },
{ NULL, False }
};
{ "menuMode.Analyze File", False },
{ "menuMode.Two Machines", False },
{ "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
+ { "menuView.ICS Input Box", False },
{ "Action", False },
- { "menuStep.Revert", False },
- { "menuStep.Annotate", False },
- { "menuStep.Move Now", False },
- { "menuStep.Retract Move", False },
+ { "menuEdit.Revert", False },
+ { "menuEdit.Annotate", False },
+ { "menuEngine.Engine #1 Settings", False },
+ { "menuEngine.Engine #2 Settings", False },
+ { "menuEngine.Move Now", False },
+ { "menuEngine.Retract Move", False },
{ "menuOptions.Auto Comment", False },
{ "menuOptions.Auto Flag", False },
{ "menuOptions.Auto Flip View", False },
{ "menuOptions.Hide Thinking", False },
{ "menuOptions.Periodic Updates", False },
{ "menuOptions.Ponder Next Move", False },
- { "menuHelp.Hint", False },
- { "menuHelp.Book", False },
+ { "menuEngine.Hint", False },
+ { "menuEngine.Book", False },
{ NULL, False }
};
Enables gnuEnables[] = {
{ "menuMode.ICS Client", False },
- { "menuMode.ICS Input Box", False },
+ { "menuView.ICS Input Box", False },
{ "menuAction.Accept", False },
{ "menuAction.Decline", False },
{ "menuAction.Rematch", False },
{ "menuAction.Stop Examining", False },
{ "menuAction.Stop Observing", False },
{ "menuAction.Upload to Examine", False },
- { "menuStep.Revert", False },
- { "menuStep.Annotate", False },
+ { "menuEdit.Revert", False },
+ { "menuEdit.Annotate", False },
{ "menuOptions.Auto Comment", False },
{ "menuOptions.Auto Observe", False },
{ "menuOptions.Auto Raise Board", 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 },
+ { "menuEdit.Forward", False },
+ { "menuEdit.Backward", False },
+ { "menuEdit.Forward to End", False },
+ { "menuEdit.Back to Start", False },
+ { "menuEngine.Move Now", False },
+ { "menuEdit.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 },
+ { "menuEdit.Forward", True },
+ { "menuEdit.Backward", True },
+ { "menuEdit.Forward to End", True },
+ { "menuEdit.Back to Start", True },
+ { "menuEngine.Move Now", True },
+ { "menuEdit.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 Next Game", False },
+// { "menuFile.Load Previous Game", False },
+// { "menuFile.Reload Same Game", False },
+ { "menuEdit.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 },
+// { "menuFile.Load Next Position", False },
+// { "menuFile.Load Previous Position", False },
+// { "menuFile.Reload Same Position", False },
+ { "menuEdit.Paste Position", False },
{ "menuMode.Machine White", False },
{ "menuMode.Machine Black", False },
{ "menuMode.Two Machines", False },
- { "menuStep.Retract Move", False },
+ { "menuEngine.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 Next Game", True },
+// { "menuFile.Load Previous Game", True },
+// { "menuFile.Reload Same Game", True },
+ { "menuEdit.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 },
+// { "menuFile.Load Next Position", True },
+// { "menuFile.Load Previous Position", True },
+// { "menuFile.Reload Same Position", True },
+ { "menuEdit.Paste Position", True },
{ "menuMode.Machine White", True },
{ "menuMode.Machine Black", True },
{ "menuMode.Two Machines", True },
- { "menuStep.Retract Move", True },
+ { "menuEngine.Retract Move", True },
{ NULL, False }
};
{
SetMenuEnables(icsEnables);
-#ifdef ZIPPY
+#if ZIPPY
if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
#endif
}
// [HGM] code borrowed from winboard.c (which should thus go to backend.c!)
-#define HISTORY_SIZE 64\r
-static char *history[HISTORY_SIZE];\r
-int histIn = 0, histP = 0;\r
-\r
-void\r
-SaveInHistory(char *cmd)\r
-{\r
- if (history[histIn] != NULL) {\r
- free(history[histIn]);\r
- history[histIn] = NULL;\r
- }\r
- if (*cmd == NULLCHAR) return;\r
- history[histIn] = StrSave(cmd);\r
- histIn = (histIn + 1) % HISTORY_SIZE;\r
- if (history[histIn] != NULL) {\r
- free(history[histIn]);\r
- history[histIn] = NULL;\r
- }\r
- histP = histIn;\r
-}\r
-\r
-char *\r
-PrevInHistory(char *cmd)\r
-{\r
- int newhp;\r
- if (histP == histIn) {\r
- if (history[histIn] != NULL) free(history[histIn]);\r
- history[histIn] = StrSave(cmd);\r
- }\r
- newhp = (histP - 1 + HISTORY_SIZE) % HISTORY_SIZE;\r
- if (newhp == histIn || history[newhp] == NULL) return NULL;\r
- histP = newhp;\r
- return history[histP];\r
-}\r
-\r
-char *\r
-NextInHistory()\r
-{\r
- if (histP == histIn) return NULL;\r
- histP = (histP + 1) % HISTORY_SIZE;\r
- return history[histP]; \r
-}
-// end of borrowed code\r
-\r
+#define HISTORY_SIZE 64
+static char *history[HISTORY_SIZE];
+int histIn = 0, histP = 0;
+
+void
+SaveInHistory(char *cmd)
+{
+ if (history[histIn] != NULL) {
+ free(history[histIn]);
+ history[histIn] = NULL;
+ }
+ if (*cmd == NULLCHAR) return;
+ history[histIn] = StrSave(cmd);
+ histIn = (histIn + 1) % HISTORY_SIZE;
+ if (history[histIn] != NULL) {
+ free(history[histIn]);
+ history[histIn] = NULL;
+ }
+ histP = histIn;
+}
+
+char *
+PrevInHistory(char *cmd)
+{
+ int newhp;
+ if (histP == histIn) {
+ if (history[histIn] != NULL) free(history[histIn]);
+ history[histIn] = StrSave(cmd);
+ }
+ newhp = (histP - 1 + HISTORY_SIZE) % HISTORY_SIZE;
+ if (newhp == histIn || history[newhp] == NULL) return NULL;
+ histP = newhp;
+ return history[histP];
+}
+
+char *
+NextInHistory()
+{
+ if (histP == histIn) return NULL;
+ histP = (histP + 1) % HISTORY_SIZE;
+ return history[histP];
+}
+// end of borrowed code
+
#define Abs(n) ((n)<0 ? -(n) : (n))
/*
* The return value should be freed with XtFree when no
* longer needed.
*/
-char *FindFont(pattern, targetPxlSize)
+char *
+FindFont(pattern, targetPxlSize)
char *pattern;
int targetPxlSize;
{
XFontStruct **fnt_list;
base_fnt_lst = calloc(1, strlen(pattern) + 3);
- sprintf(strInt, "%d", targetPxlSize);
+ snprintf(strInt, sizeof(strInt)/sizeof(strInt[0]), "%d", targetPxlSize);
p = strstr(pattern, "--");
strncpy(base_fnt_lst, pattern, p - pattern + 2);
strcat(base_fnt_lst, strInt);
while (isdigit(*scalableTail)) scalableTail++;
sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
} else {
- p = (char *) XtMalloc(strlen(best) + 1);
- strcpy(p, best);
+ p = (char *) XtMalloc(strlen(best) + 2);
+ safeStrCpy(p, best, strlen(best)+1 );
}
if (appData.debugMode) {
fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
}
#if HAVE_LIBXPM
+void CreateXPMBoard(char *s, int kind)
+{
+ XpmAttributes attr;
+ attr.valuemask = 0;
+ if(s == NULL || *s == 0 || *s == '*') return;
+ if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
+ useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
+ }
+}
+
void CreateXPMPieces()
{
int piece, kind, r;
exit(1);
}
}
- if(piece <= (int) WhiteKing)
+ if(piece <= (int) WhiteKing)
xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
}
}
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
+ snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
+ ss, kind == SOLID ? 's' : 'o');
+ ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
- sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
- pieceBitmapNames[piece],
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap2[kind][piece], buf,
- bib->bits[kind][piece], ss, ss);
- if(piece <= (int)WhiteKing)
- pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
+ snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
+ ss, kind == SOLID ? 's' : 'o');
+ ReadBitmap(&pieceBitmap2[kind][piece], buf,
+ bib->bits[kind][piece], ss, ss);
+ if(piece <= (int)WhiteKing)
+ pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
}
}
char msg[MSG_SIZ], fullname[MSG_SIZ];
if (*appData.bitmapDirectory != NULLCHAR) {
- strcpy(fullname, appData.bitmapDirectory);
- strcat(fullname, "/");
- strcat(fullname, name);
- errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
- &w, &h, pm, &x_hot, &y_hot);
- fprintf(stderr, "load %s\n", name);
+ safeStrCpy(fullname, appData.bitmapDirectory, sizeof(fullname)/sizeof(fullname[0]) );
+ strncat(fullname, "/", MSG_SIZ - strlen(fullname) - 1);
+ strncat(fullname, name, MSG_SIZ - strlen(fullname) - 1);
+ errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
+ &w, &h, pm, &x_hot, &y_hot);
+ fprintf(stderr, "load %s\n", name);
if (errcode != BitmapSuccess) {
switch (errcode) {
case BitmapOpenFailed:
entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
menu, args, j);
} else {
- XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
- entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
+ XtSetArg(args[j], XtNlabel, XtNewString(mi->string));
+ entry = XtCreateManagedWidget(mi->ref, smeBSBObjectClass,
menu, args, j+1);
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) MenuBarSelect,
formWidget, args, j);
while (mb->name != NULL) {
- strcpy(menuName, "menu");
- strcat(menuName, mb->name);
+ safeStrCpy(menuName, "menu", sizeof(menuName)/sizeof(menuName[0]) );
+ strncat(menuName, mb->ref, MSG_SIZ - strlen(menuName) - 1);
j = 0;
XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;
if (tinyLayout) {
char shortName[2];
- shortName[0] = _(mb->name)[0];
+ shortName[0] = mb->name[0];
shortName[1] = NULLCHAR;
XtSetArg(args[j], XtNlabel, XtNewString(shortName)); j++;
}
else {
- XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name))); j++;
+ XtSetArg(args[j], XtNlabel, XtNewString(mb->name)); j++;
}
XtSetArg(args[j], XtNborderWidth, 0); j++;
{
String whichMenu; int menuNr;
if (event->type == ButtonRelease)
- menuNr = RightClick(Release, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
+ menuNr = RightClick(Release, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
else if (event->type == ButtonPress)
menuNr = RightClick(Press, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
switch(menuNr) {
{
int x, y;
- if (lineGap == 0 || appData.blindfold) return;
+ if (lineGap == 0) return;
if (flipView) {
x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
SetPremoveHighlights(-1, -1, -1, -1);
}
-static void BlankSquare(x, y, color, piece, dest)
- int x, y, color;
+static int CutOutSquare(x, y, x0, y0, kind)
+ int x, y, *x0, *y0, kind;
+{
+ int W = BOARD_WIDTH, H = BOARD_HEIGHT;
+ int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
+ *x0 = 0; *y0 = 0;
+ if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
+ if(textureW[kind] < W*squareSize)
+ *x0 = (textureW[kind] - squareSize) * nx/(W-1);
+ else
+ *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
+ if(textureH[kind] < H*squareSize)
+ *y0 = (textureH[kind] - squareSize) * ny/(H-1);
+ else
+ *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
+ return 1;
+}
+
+static void BlankSquare(x, y, color, piece, dest, fac)
+ int x, y, color, fac;
ChessSquare piece;
Drawable dest;
-{
+{ // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
+ int x0, y0;
+ if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
+ XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
+ squareSize, squareSize, x*fac, y*fac);
+ } else
if (useImages && useImageSqs) {
Pixmap pm;
switch (color) {
break;
}
XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
+ squareSize, squareSize, x*fac, y*fac);
} else {
GC gc;
switch (color) {
gc = jailSquareGC;
break;
}
- XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);
+ XFillRectangle(xDisplay, dest, gc, x*fac, y*fac, squareSize, squareSize);
}
}
int square_color, x, y;
Drawable dest;
{
- int kind;
+ int kind, p = piece;
switch (square_color) {
case 1: /* light */
}
break;
}
+ if(appData.upsideDown && flipView) kind ^= 2; // swap white and black pieces
+ if(useTexture & square_color+1) {
+ BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+ XSetClipMask(xDisplay, wlPieceGC, xpmMask[p]);
+ XSetClipOrigin(xDisplay, wlPieceGC, x, y);
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece], dest, wlPieceGC, 0, 0, squareSize, squareSize, x, y);
+ XSetClipMask(xDisplay, wlPieceGC, None);
+ XSetClipOrigin(xDisplay, wlPieceGC, 0, 0);
+ } else
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, wlPieceGC, 0, 0,
squareSize, squareSize, x, y);
column == BOARD_LEFT-1 || column == BOARD_RGHT
|| (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
|| (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
- BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
+ BlankSquare(x, y, 2, EmptySquare, xBoardWindow, 1);
// [HGM] print piece counts next to holdings
string[1] = NULLCHAR;
}
} else {
if (piece == EmptySquare || appData.blindfold) {
- BlankSquare(x, y, square_color, piece, xBoardWindow);
+ BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
} else {
drawfunc = ChooseDrawFunc();
if (do_flash && appData.flashCount > 0) {
XSync(xDisplay, False);
do_flash_delay(flash_delay);
- BlankSquare(x, y, square_color, piece, xBoardWindow);
+ BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
XSync(xDisplay, False);
do_flash_delay(flash_delay);
}
}
}
if(!partnerUp && marker[row][column]) {
- XFillArc(xDisplay, xBoardWindow, marker[row][column] == 2 ? prelineGC : highlineGC,
+ XFillArc(xDisplay, xBoardWindow, marker[row][column] == 2 ? prelineGC : highlineGC,
x + squareSize/4, y+squareSize/4, squareSize/2, squareSize/2, 0, 64*360);
}
}
}
break;
case MotionNotify:
- if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;\r
+ if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;
default:
return;
}
return 0;
}
-// [HGM] seekgraph: some low-level drawing routines cloned from xevalgraph
+// [HGM] seekgraph: some low-level drawing routines cloned from xevalgraph
void DrawSeekAxis( int x, int y, int xTo, int yTo )
{
XDrawLine(xDisplay, xBoardWindow, lineGC, x, y, xTo, yTo);
XFillRectangle(xDisplay, xBoardWindow, color,
x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
else
- XFillArc(xDisplay, xBoardWindow, color,
+ XFillArc(xDisplay, xBoardWindow, color,
x-squareSize/8, y-squareSize/8, squareSize/4, squareSize/4, 0, 64*360);
}
if(DrawSeekGraph()) return; // [HGM] seekgraph: suppress any drawing if seek graph up
if (board == NULL) {
- if (!lastBoardValid) return;
+ if (!lastBoardValid[nr]) return;
board = lastBoard[nr];
}
if (!lastBoardValid[nr] || (nr == 0 && lastFlipView != flipView)) {
XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuView.Flip View"),
args, 1);
}
* but this causes a very distracting flicker.
*/
+ if ( lineGap && IsDrawArrowEnabled()) repaint = True;
if (!repaint && lastBoardValid[nr] && (nr == 1 || lastFlipView == flipView)) {
/* If too much changes (begin observing new game, etc.), don't
if (hi2X >= 0 && hi2Y >= 0) {
drawHighlight(hi2X, hi2Y, highlineGC);
}
+ DrawArrowHighlight(hi1X, hi1Y, hi2X, hi2Y);
}
/* If piece being dragged around board, must redraw that too */
DrawDragPiece();
Cardinal *nprms;
{
if (w != boardWidget || errorExitStatus != -1) return;
+ if(nprms) shiftKey = !strcmp(prms[0], "1");
if (promotionUp) {
if (event->type == ButtonPress) {
editUp = True;
j = 0;
XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuEdit.Edit Comment"),
+ args, j);
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuView.Show Comments"),
args, j);
}
editUp = False;
j = 0;
XtSetArg(args[j], XtNleftBitmap, None); j++;
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuEdit.Edit Comment"),
+ args, j);
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuView.Show Comments"),
args, j);
}
ICSInputBoxUp = True;
j = 0;
XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuView.ICS Input Box"),
args, j);
}
ICSInputBoxUp = False;
j = 0;
XtSetArg(args[j], XtNleftBitmap, None); j++;
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuView.ICS Input Box"),
args, j);
}
FileProc proc;
char *openMode;
{
- Arg args[16];
- Widget popup, layout, dialog, edit;
- Window root, child;
- int x, y, i;
- int win_x, win_y;
- unsigned int mask;
-
fileProc = proc; /* I can't see a way not */
fileOpenMode = openMode; /* to use globals here */
{ // [HGM] use file-selector dialog stolen from Ghostview
int index; // this is not supported yet
FILE *f;
if(f = XsraSelFile(shellWidget, label, NULL, NULL, "could not open: ",
- NULL, openMode, NULL, &name))
- (void) (*fileProc)(f, index=0, name);
+ def, openMode, NULL, &name))
+ (void) (*fileProc)(f, index=0, name);
}
}
name = XawDialogGetValueString(w = XtParent(w));
if ((name != NULL) && (*name != NULLCHAR)) {
- strcpy(buf, name);
+ safeStrCpy(buf, name, sizeof(buf)/sizeof(buf[0]) );
XtPopdown(w = XtParent(XtParent(w)));
XtDestroyWidget(w);
filenameUp = False;
XawDialogAddButton(dialog, _("King"), PromotionCallback,
(XtPointer) dialog);
}
- if(gameInfo.variant == VariantCapablanca ||
- gameInfo.variant == VariantGothic ||
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
gameInfo.variant == VariantCapaRandom) {
XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
(XtPointer) dialog);
* automatically call XtFree on the value returned. So have to
* make a copy of it allocated with XtMalloc */
selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
- strcpy(selection_tmp, selected_fen_position);
+ safeStrCpy(selection_tmp, selected_fen_position, strlen(selected_fen_position)+16 );
*value_return=selection_tmp;
*length_return=strlen(selection_tmp);
String *prms;
Cardinal *nprms;
{
- XtGetSelectionValue(menuBarWidget,
+ XtGetSelectionValue(menuBarWidget,
appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
/* (XtSelectionCallbackProc) */ PastePositionCB,
NULL, /* client_data passed to PastePositionCB */
/* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
if (appData.icsActive) {
if (gameMode != IcsObserving) {
- sprintf(buf,_("You are not observing a game"));
+ snprintf(buf, MSG_SIZ, _("You are not observing a game"));
DisplayError(buf, 0);
/* secure check */
if (appData.icsEngineAnalyze) {
char *message, *extMessage;
{
/* display a message in the message widget */
-
+
char buf[MSG_SIZ];
Arg arg;
-
- if (extMessage)
+
+ if (extMessage)
{
- if (*message)
+ if (*message)
{
snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
message = buf;
- }
- else
+ }
+ 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 */
XtSetArg(arg, XtNlabel, message);
XtSetValues(messageWidget, &arg, 1);
};
-
+
return;
}
}
if (*text != NULLCHAR) {
- strcpy(icon, text);
- strcpy(title, text);
+ safeStrCpy(icon, text, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, text, sizeof(title)/sizeof(title[0]) );
} else if (appData.icsActive) {
snprintf(icon, sizeof(icon), "%s", appData.icsHost);
snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
#ifdef GOTHIC
// [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
} else if (gameInfo.variant == VariantGothic) {
- strcpy(icon, programName);
- strcpy(title, GOTHIC);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, GOTHIC, sizeof(title)/sizeof(title[0]) );
#endif
#ifdef FALCON
} else if (gameInfo.variant == VariantFalcon) {
- strcpy(icon, programName);
- strcpy(title, FALCON);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, FALCON, sizeof(title)/sizeof(title[0]) );
#endif
} else if (appData.noChessProgram) {
- strcpy(icon, programName);
- strcpy(title, programName);
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, programName, sizeof(title)/sizeof(title[0]) );
} else {
- strcpy(icon, first.tidy);
+ safeStrCpy(icon, first.tidy, sizeof(icon)/sizeof(icon[0]) );
snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
}
i = 0;
}
-void DisplayError(message, error)
+void
+DisplayError(message, error)
String message;
int error;
{
String reply;
reply = XawDialogGetValueString(w = XtParent(w));
- strcpy(buf, pendingReplyPrefix);
- if (*buf) strcat(buf, " ");
- strcat(buf, reply);
- strcat(buf, "\n");
+ safeStrCpy(buf, pendingReplyPrefix, sizeof(buf)/sizeof(buf[0]) );
+ if (*buf) strncat(buf, " ", MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, reply, MSG_SIZ - strlen(buf) - 1);
+ strncat(buf, "\n", MSG_SIZ - strlen(buf) - 1);
OutputToProcess(pendingReplyPR, buf, strlen(buf), &err);
AskQuestionPopDown();
int win_x, win_y;
unsigned int mask;
- strcpy(pendingReplyPrefix, replyPrefix);
+ safeStrCpy(pendingReplyPrefix, replyPrefix, sizeof(pendingReplyPrefix)/sizeof(pendingReplyPrefix[0]) );
pendingReplyPR = pr;
i = 0;
if (textColors[(int)cc].bg > 0) {
if (textColors[(int)cc].fg > 0) {
- sprintf(buf, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
- textColors[(int)cc].fg, textColors[(int)cc].bg);
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
+ textColors[(int)cc].fg, textColors[(int)cc].bg);
} else {
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
- textColors[(int)cc].bg);
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%dm", textColors[(int)cc].attr,
+ textColors[(int)cc].bg);
}
} else {
if (textColors[(int)cc].fg > 0) {
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
+ snprintf(buf, MSG_SIZ, "\033[0;%d;%dm", textColors[(int)cc].attr,
textColors[(int)cc].fg);
} else {
- sprintf(buf, "\033[0;%dm", textColors[(int)cc].attr);
+ snprintf(buf, MSG_SIZ, "\033[0;%dm", textColors[(int)cc].attr);
}
}
count = strlen(buf);
return getpwuid(getuid())->pw_name;
}
-static char *ExpandPathName(path)
+static char *
+ExpandPathName(path)
char *path;
{
- static char static_buf[2000];
- char *d, *s, buf[2000];
+ static char static_buf[4*MSG_SIZ];
+ char *d, *s, buf[4*MSG_SIZ];
struct passwd *pwd;
s = path;
if (*s == '~') {
if (*(s+1) == '/') {
- strcpy(d, getpwuid(getuid())->pw_dir);
- strcat(d, s+1);
+ safeStrCpy(d, getpwuid(getuid())->pw_dir, 4*MSG_SIZ );
+ strcat(d, s+1);
}
else {
- strcpy(buf, s+1);
- *strchr(buf, '/') = 0;
- pwd = getpwnam(buf);
- if (!pwd)
- {
- fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
- buf, path);
- return NULL;
- }
- strcpy(d, pwd->pw_dir);
- strcat(d, strchr(s+1, '/'));
+ safeStrCpy(buf, s+1, sizeof(buf)/sizeof(buf[0]) );
+ { char *p; if(p = strchr(buf, '/')) *p = 0; }
+ pwd = getpwnam(buf);
+ if (!pwd)
+ {
+ fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
+ buf, path);
+ return NULL;
+ }
+ safeStrCpy(d, pwd->pw_dir, 4*MSG_SIZ );
+ strcat(d, strchr(s+1, '/'));
}
}
else
- strcpy(d, s);
+ safeStrCpy(d, s, 4*MSG_SIZ );
return static_buf;
}
Pixel foregroundOrWarningColor = timerForegroundPixel;
if (timer > 0 &&
- appData.lowTimeWarning &&
+ appData.lowTimeWarning &&
(timer / 1000) < appData.icsAlarmTime)
foregroundOrWarningColor = lowTimeWarningColor;
if (appData.clockMode) {
- sprintf(buf, "%s: %s", color, TimeString(timer));
- XtSetArg(args[0], XtNlabel, buf);
+ snprintf(buf, MSG_SIZ, "%s: %s", color, TimeString(timer));
+ XtSetArg(args[0], XtNlabel, buf);
} else {
- sprintf(buf, "%s ", color);
- XtSetArg(args[0], XtNlabel, buf);
+ snprintf(buf, MSG_SIZ, "%s ", color);
+ XtSetArg(args[0], XtNlabel, buf);
}
if (highlight) {
most simple-minded way possible.
*/
i = 0;
- strcpy(buf, cmdLine);
+ safeStrCpy(buf, cmdLine, sizeof(buf)/sizeof(buf[0]) );
p = buf;
for (;;) {
while(*p == ' ') p++;
kind = 0;
else
kind = 2;
+ if(appData.upsideDown && flipView) kind ^= 2;
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, clip,
0, 0, squareSize, squareSize,
Pixmap mask;
/* The old buffer is initialised with the start square (empty) */
- BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
+ BlankSquare(start->x, start->y, startColor, EmptySquare, anim->saveBuf, 0);
anim->prevFrame = *start;
/* The piece will be drawn using its own bitmap as a matte */
EndAnimation(anim, finish);
}
+void
+AnimateAtomicCapture(Board board, int fromX, int fromY, int toX, int toY)
+{
+ int i, x, y;
+ ChessSquare piece = board[fromY][toY];
+ board[fromY][toY] = EmptySquare;
+ DrawPosition(FALSE, board);
+ if (flipView) {
+ x = lineGap + ((BOARD_WIDTH-1)-toX) * (squareSize + lineGap);
+ y = lineGap + toY * (squareSize + lineGap);
+ } else {
+ x = lineGap + toX * (squareSize + lineGap);
+ y = lineGap + ((BOARD_HEIGHT-1)-toY) * (squareSize + lineGap);
+ }
+ for(i=1; i<4*kFactor; i++) {
+ int r = squareSize * 9 * i/(20*kFactor - 5);
+ XFillArc(xDisplay, xBoardWindow, highlineGC,
+ x + squareSize/2 - r, y+squareSize/2 - r, 2*r, 2*r, 0, 64*360);
+ FrameDelay(appData.animSpeed);
+ }
+ board[fromY][toY] = piece;
+}
+
/* Main control logic for deciding what to animate and how */
void
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;
#if DONT_HOP
hop = FALSE;
#else
- hop = (piece == WhiteKnight || piece == BlackKnight);
+ hop = abs(fromX-toX) == 1 && abs(fromY-toY) == 2 || abs(fromX-toX) == 2 && abs(fromY-toY) == 1;
#endif
if (appData.debugMode) {
ScreenSquare(toX, toY, &finish, &endColor);
if (hop) {
- /* Knight: make diagonal movement then straight */
+ /* Knight: make straight movement then diagonal */
if (abs(toY - fromY) < abs(toX - fromX)) {
mid.x = start.x + (finish.x - start.x) / 2;
- mid.y = finish.y;
+ mid.y = start.y;
} else {
- mid.x = finish.x;
+ mid.x = start.x;
mid.y = start.y + (finish.y - start.y) / 2;
}
} else {
else
Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
+ if(Explode(board, fromX, fromY, toX, toY)) { // mark as damaged
+ int i,j;
+ for(i=0; i<BOARD_WIDTH; i++) for(j=0; j<BOARD_HEIGHT; j++)
+ if((i-toX)*(i-toX) + (j-toY)*(j-toY) < 6) damage[0][j][i] = True;
+ }
/* Be sure end square is redrawn */
damage[0][toY][toX] = True;
XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
corner.x, corner.y, squareSize, squareSize,
0, 0); // [HGM] zh: unstack in stead of grab
+ if(gatingPiece != EmptySquare) {
+ /* Kludge alert: When gating we want the introduced
+ piece to appear on the from square. To generate an
+ image of it, we draw it on the board, copy the image,
+ and draw the original piece again. */
+ ChessSquare piece = boards[currentMove][boardY][boardX];
+ DrawSquare(boardY, boardX, gatingPiece, 0);
+ XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
+ corner.x, corner.y, squareSize, squareSize, 0, 0);
+ DrawSquare(boardY, boardX, piece, 0);
+ }
damage[0][boardY][boardX] = True;
} else {
player.dragActive = False;
it's being dragged around the board. So we erase the square
that the piece is on and draw it at the last known drag point. */
BlankSquare(player.startSquare.x, player.startSquare.y,
- player.startColor, EmptySquare, xBoardWindow);
+ player.startColor, EmptySquare, xBoardWindow, 1);
AnimationFrame(&player, &player.prevFrame, player.dragPiece);
damage[0][player.startBoardY][player.startBoardX] = TRUE;
}
return default_width;
}
-void update_ics_width()
+void
+update_ics_width()
{
- static int old_width = 0;
- int new_width = get_term_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;
+ if (old_width != new_width)
+ ics_printf("set width %d\n", new_width);
+ old_width = new_width;
}
void NotifyFrontendLogin()
{
update_ics_width();
}
+
+/* [AS] Arrow highlighting support */
+
+static double A_WIDTH = 5; /* Width of arrow body */
+
+#define A_HEIGHT_FACTOR 6 /* Length of arrow "point", relative to body width */
+#define A_WIDTH_FACTOR 3 /* Width of arrow "point", relative to body width */
+
+static double Sqr( double x )
+{
+ return x*x;
+}
+
+static int Round( double x )
+{
+ return (int) (x + 0.5);
+}
+
+void SquareToPos(int rank, int file, int *x, int *y)
+{
+ if (flipView) {
+ *x = lineGap + ((BOARD_WIDTH-1)-file) * (squareSize + lineGap);
+ *y = lineGap + rank * (squareSize + lineGap);
+ } else {
+ *x = lineGap + file * (squareSize + lineGap);
+ *y = lineGap + ((BOARD_HEIGHT-1)-rank) * (squareSize + lineGap);
+ }
+}
+
+/* Draw an arrow between two points using current settings */
+void DrawArrowBetweenPoints( int s_x, int s_y, int d_x, int d_y )
+{
+ XPoint arrow[7];
+ double dx, dy, j, k, x, y;
+
+ if( d_x == s_x ) {
+ int h = (d_y > s_y) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
+
+ arrow[0].x = s_x + A_WIDTH + 0.5;
+ arrow[0].y = s_y;
+
+ arrow[1].x = s_x + A_WIDTH + 0.5;
+ arrow[1].y = d_y - h;
+
+ arrow[2].x = arrow[1].x + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
+ arrow[2].y = d_y - h;
+
+ arrow[3].x = d_x;
+ arrow[3].y = d_y;
+
+ arrow[5].x = arrow[1].x - 2*A_WIDTH + 0.5;
+ arrow[5].y = d_y - h;
+
+ arrow[4].x = arrow[5].x - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
+ arrow[4].y = d_y - h;
+
+ arrow[6].x = arrow[1].x - 2*A_WIDTH + 0.5;
+ arrow[6].y = s_y;
+ }
+ else if( d_y == s_y ) {
+ int w = (d_x > s_x) ? +A_WIDTH*A_HEIGHT_FACTOR : -A_WIDTH*A_HEIGHT_FACTOR;
+
+ arrow[0].x = s_x;
+ arrow[0].y = s_y + A_WIDTH + 0.5;
+
+ arrow[1].x = d_x - w;
+ arrow[1].y = s_y + A_WIDTH + 0.5;
+
+ arrow[2].x = d_x - w;
+ arrow[2].y = arrow[1].y + A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
+
+ arrow[3].x = d_x;
+ arrow[3].y = d_y;
+
+ arrow[5].x = d_x - w;
+ arrow[5].y = arrow[1].y - 2*A_WIDTH + 0.5;
+
+ arrow[4].x = d_x - w;
+ arrow[4].y = arrow[5].y - A_WIDTH*(A_WIDTH_FACTOR-1) + 0.5;
+
+ arrow[6].x = s_x;
+ arrow[6].y = arrow[1].y - 2*A_WIDTH + 0.5;
+ }
+ else {
+ /* [AS] Needed a lot of paper for this! :-) */
+ dy = (double) (d_y - s_y) / (double) (d_x - s_x);
+ dx = (double) (s_x - d_x) / (double) (s_y - d_y);
+
+ j = sqrt( Sqr(A_WIDTH) / (1.0 + Sqr(dx)) );
+
+ k = sqrt( Sqr(A_WIDTH*A_HEIGHT_FACTOR) / (1.0 + Sqr(dy)) );
+
+ x = s_x;
+ y = s_y;
+
+ arrow[0].x = Round(x - j);
+ arrow[0].y = Round(y + j*dx);
+
+ arrow[1].x = Round(arrow[0].x + 2*j); // [HGM] prevent width to be affected by rounding twice
+ arrow[1].y = Round(arrow[0].y - 2*j*dx);
+
+ if( d_x > s_x ) {
+ x = (double) d_x - k;
+ y = (double) d_y - k*dy;
+ }
+ else {
+ x = (double) d_x + k;
+ y = (double) d_y + k*dy;
+ }
+
+ x = Round(x); y = Round(y); // [HGM] make sure width of shaft is rounded the same way on both ends
+
+ arrow[6].x = Round(x - j);
+ arrow[6].y = Round(y + j*dx);
+
+ arrow[2].x = Round(arrow[6].x + 2*j);
+ arrow[2].y = Round(arrow[6].y - 2*j*dx);
+
+ arrow[3].x = Round(arrow[2].x + j*(A_WIDTH_FACTOR-1));
+ arrow[3].y = Round(arrow[2].y - j*(A_WIDTH_FACTOR-1)*dx);
+
+ arrow[4].x = d_x;
+ arrow[4].y = d_y;
+
+ arrow[5].x = Round(arrow[6].x - j*(A_WIDTH_FACTOR-1));
+ arrow[5].y = Round(arrow[6].y + j*(A_WIDTH_FACTOR-1)*dx);
+ }
+
+ XFillPolygon(xDisplay, xBoardWindow, highlineGC, arrow, 7, Nonconvex, CoordModeOrigin);
+// Polygon( hdc, arrow, 7 );
+}
+
+/* [AS] Draw an arrow between two squares */
+void DrawArrowBetweenSquares( int s_col, int s_row, int d_col, int d_row )
+{
+ int s_x, s_y, d_x, d_y, hor, vert, i;
+
+ if( s_col == d_col && s_row == d_row ) {
+ return;
+ }
+
+ /* Get source and destination points */
+ SquareToPos( s_row, s_col, &s_x, &s_y);
+ SquareToPos( d_row, d_col, &d_x, &d_y);
+
+ if( d_y > s_y ) {
+ d_y += squareSize / 2 - squareSize / 4; // [HGM] round towards same centers on all sides!
+ }
+ else if( d_y < s_y ) {
+ d_y += squareSize / 2 + squareSize / 4;
+ }
+ else {
+ d_y += squareSize / 2;
+ }
+
+ if( d_x > s_x ) {
+ d_x += squareSize / 2 - squareSize / 4;
+ }
+ else if( d_x < s_x ) {
+ d_x += squareSize / 2 + squareSize / 4;
+ }
+ else {
+ d_x += squareSize / 2;
+ }
+
+ s_x += squareSize / 2;
+ s_y += squareSize / 2;
+
+ /* Adjust width */
+ A_WIDTH = squareSize / 14.; //[HGM] make float
+
+ DrawArrowBetweenPoints( s_x, s_y, d_x, d_y );
+
+ if(lineGap == 0) {
+ // this is a good idea, but it only works when lineGap == 0, because 'damage' on grid lines is not repaired
+ hor = 64*s_col + 32; vert = 64*s_row + 32;
+ for(i=0; i<= 64; i++) {
+ damage[0][vert+6>>6][hor+6>>6] = True;
+ damage[0][vert-6>>6][hor+6>>6] = True;
+ damage[0][vert+6>>6][hor-6>>6] = True;
+ damage[0][vert-6>>6][hor-6>>6] = True;
+ hor += d_col - s_col; vert += d_row - s_row;
+ }
+ }
+}
+
+Boolean IsDrawArrowEnabled()
+{
+ return appData.highlightMoveWithArrow && squareSize >= 32;
+}
+
+void DrawArrowHighlight(int fromX, int fromY, int toX,int toY)
+{
+ if( IsDrawArrowEnabled() && fromX >= 0 && fromY >= 0 && toX >= 0 && toY >= 0)
+ DrawArrowBetweenSquares(fromX, fromY, toX, toY);
+}