/*
* xboard.c -- X front end for XBoard
- * $Id$
*
- * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
- * Enhancements Copyright 1992-2001 Free Software Foundation, Inc.
+ * Copyright 1991 by Digital Equipment Corporation, Maynard,
+ * Massachusetts.
+ *
+ * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
+ * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
*
* The following terms apply to Digital Equipment Corporation's copyright
* interest in XBoard:
* SOFTWARE.
* ------------------------------------------------------------------------
*
- * The following terms apply to the enhanced version of XBoard distributed
- * by the Free Software Foundation:
+ * The following terms apply to the enhanced version of XBoard
+ * distributed by the Free Software Foundation:
* ------------------------------------------------------------------------
- * This program is free software; you can redistribute it and/or modify
+ *
+ * GNU XBoard is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
*
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * GNU XBoard is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- * ------------------------------------------------------------------------
+ * along with this program. If not, see http://www.gnu.org/licenses/. *
*
- * See the file ChangeLog for a revision history.
- */
+ *------------------------------------------------------------------------
+ ** See the file ChangeLog for a revision history. */
+
+#define HIGHDRAG 1
#include "config.h"
# endif
#endif
+
+# if HAVE_LIBREADLINE /* add gnu-readline support */
+#include <readline/readline.h>
+#include <readline/history.h>
+# endif
+
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>
#include <X11/cursorfont.h>
#include <X11/Xatom.h>
+#include <X11/Xmu/Atoms.h>
#if USE_XAW3D
#include <X11/Xaw3d/Dialog.h>
#include <X11/Xaw3d/Form.h>
#include <X11/Xaw/AsciiText.h>
#endif
+// [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
+#include "common.h"
+
#if HAVE_LIBXPM
#include <X11/xpm.h>
#include "pixmaps/pixmaps.h"
#include "bitmaps/icon_black.bm"
#include "bitmaps/checkmark.bm"
-#include "common.h"
#include "frontend.h"
#include "backend.h"
+#include "backendz.h"
#include "moves.h"
#include "xboard.h"
#include "childio.h"
#include "xgamelist.h"
#include "xhistory.h"
#include "xedittags.h"
+#include "gettext.h"
+
+// must be moved to xengineoutput.h
+
+void EngineOutputProc P((Widget w, XEvent *event,
+ String *prms, Cardinal *nprms));
+void EvalGraphProc P((Widget w, XEvent *event,
+ String *prms, Cardinal *nprms));
+
#ifdef __EMX__
#ifndef HAVE_USLEEP
#define usleep(t) _sleep2(((t)+500)/1000)
#endif
+#ifdef ENABLE_NLS
+# define _(s) gettext (s)
+# define N_(s) gettext_noop (s)
+#else
+# define _(s) (s)
+# define N_(s) s
+#endif
+
typedef struct {
String string;
XtActionProc proc;
} Menu;
int main P((int argc, char **argv));
+FILE * XsraSelFile P((Widget w, char *prompt, char *ok, char *cancel, char *failed,
+ char *init_path, char *mode, int (*show_entry)(), char **name_return));
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));
String *prms, Cardinal *nprms));
void AnimateUserMove P((Widget w, XEvent * event,
String * params, Cardinal * nParams));
+void HandlePV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void SelectPV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void StopPV 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,
+void XDrawPosition P((Widget w, /*Boolean*/int repaint,
Board board));
+void CommentClick P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
void CommentPopUp P((char *title, char *label));
void CommentPopDown P((void));
void CommentCallback P((Widget w, XtPointer client_data,
void AskQuestionProc P((Widget w, XEvent *event,
String *prms, Cardinal *nprms));
void AskQuestionPopDown P((void));
-void PromotionPopUp P((void));
void PromotionPopDown P((void));
void PromotionCallback P((Widget w, XtPointer client_data,
XtPointer call_data));
void 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 UpKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void DownKeyProc 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 UploadProc 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 AnnotateProc 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 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 SaveSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SaveOnExitProc 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 ErrorPopDown P((void));
static char *ExpandPathName P((char *path));
static void CreateAnimVars P((void));
-static void DragPieceBegin P((int x, int y));
static void DragPieceMove P((int x, int y));
-static void DragPieceEnd P((int x, int y));
static void DrawDragPiece P((void));
char *ModeToWidgetName P((GameMode mode));
+void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void GameListOptionsPopUp P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void GameListOptionsPopDown P(());
+void ShufflePopDown P(());
+void EnginePopDown P(());
+void UciPopDown P(());
+void TimeControlPopDown P(());
+void NewVariantPopDown P(());
+void SettingsPopDown P(());
+void update_ics_width P(());
+int get_term_width P(());
+int CopyMemoProc P(());
+
+# if HAVE_LIBREADLINE /* add gnu-readline support */
+static void ReadlineCompleteHandler P((char *));
+# endif
/*
* XBoard depends on Xt R4 or higher
Window xBoardWindow;
Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
jailSquareColor, highlightSquareColor, premoveHighlightColor;
+Pixel lowTimeWarningColor;
GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
- wjPieceGC, bjPieceGC, prelineGC;
+ wjPieceGC, bjPieceGC, prelineGC, countGC;
Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
- whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
+Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
+ whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
ICSInputShell, fileNameShell, askQuestionShell;
-XSegment gridSegments[(BOARD_SIZE + 1) * 2];
-XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
-Font clockFontID, coordFontID;
-XFontStruct *clockFontStruct, *coordFontStruct;
+Widget historyShell, evalGraphShell, gameListShell;
+int hOffset; // [HGM] dual
+XSegment secondSegments[BOARD_RANKS + BOARD_FILES + 2];
+XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
+Font clockFontID, coordFontID, countFontID;
+XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
XtAppContext appContext;
char *layoutName;
char *oldICSInteractionTitle;
FileProc fileProc;
char *fileOpenMode;
+char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
+
+# if HAVE_LIBREADLINE /* gnu readline support */
+static char* readline_buffer;
+static int readline_complete=0;
+extern int sending_ICS_login;
+extern int sending_ICS_password;
+#endif
Position commentX = -1, commentY = -1;
Dimension commentW, commentH;
+typedef unsigned int BoardSize;
+BoardSize boardSize;
+Boolean chessProgram;
+int minX, minY; // [HGM] placement: volatile limits on upper-left corner
int squareSize, smallLayout = 0, tinyLayout = 0,
+ marginW, marginH, // [HGM] for run-time resizing
fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
ICSInputBoxUp = False, askQuestionUp = False,
filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
Pixel buttonForegroundPixel, buttonBackgroundPixel;
char *chessDir, *programName, *programVersion,
*gameCopyFilename, *gamePasteFilename;
+Boolean alwaysOnTop = False;
+Boolean saveSettingsOnExit;
+char *settingsFileName;
+char *icsTextMenuString;
+char *icsNames;
+char *firstChessProgramNames;
+char *secondChessProgramNames;
+
+WindowPlacement wpMain;
+WindowPlacement wpConsole;
+WindowPlacement wpComment;
+WindowPlacement wpMoveHistory;
+WindowPlacement wpEvalGraph;
+WindowPlacement wpEngineOutput;
+WindowPlacement wpGameList;
+WindowPlacement wpTags;
#define SOLID 0
#define OUTLINE 1
-Pixmap pieceBitmap[2][6];
-Pixmap xpmPieceBitmap[4][6]; /* LL, LD, DL, DD */
+Pixmap pieceBitmap[2][(int)BlackPawn];
+Pixmap pieceBitmap2[2][(int)BlackPawn+4]; /* [HGM] pieces */
+Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
+Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
int useImages, useImageSqs;
-XImage *ximPieceBitmap[4][6]; /* LL, LD, DL, DD */
-Pixmap ximMaskPm[6]; /* clipmasks, used for XIM pieces */
+XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
+Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
+Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
XImage *ximLightSquare, *ximDarkSquare;
XImage *xim_Cross;
-#define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % 6]
-#define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % 6]
+#define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
+#define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
#define White(piece) ((int)(piece) < (int)BlackPawn)
SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
MenuItem fileMenu[] = {
- {"Reset Game", ResetProc},
+ {N_("New Game"), ResetProc},
+ {N_("New Shuffle Game ..."), ShuffleMenuProc},
+ {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
{"----", NothingProc},
- {"Load Game", LoadGameProc},
- {"Load Next Game", LoadNextGameProc},
- {"Load Previous Game", LoadPrevGameProc},
- {"Reload Same Game", ReloadGameProc},
- {"Save Game", SaveGameProc},
+ {N_("Load Game"), LoadGameProc},
+ {N_("Load Next Game"), LoadNextGameProc},
+ {N_("Load Previous Game"), LoadPrevGameProc},
+ {N_("Reload Same Game"), ReloadGameProc},
+ {N_("Save Game"), SaveGameProc},
{"----", NothingProc},
- {"Copy Game", CopyGameProc},
- {"Paste Game", PasteGameProc},
+ {N_("Copy Game"), CopyGameProc},
+ {N_("Paste Game"), PasteGameProc},
{"----", NothingProc},
- {"Load Position", LoadPositionProc},
- {"Load Next Position", LoadNextPositionProc},
- {"Load Previous Position", LoadPrevPositionProc},
- {"Reload Same Position", ReloadPositionProc},
- {"Save Position", SavePositionProc},
+ {N_("Load Position"), LoadPositionProc},
+ {N_("Load Next Position"), LoadNextPositionProc},
+ {N_("Load Previous Position"), LoadPrevPositionProc},
+ {N_("Reload Same Position"), ReloadPositionProc},
+ {N_("Save Position"), SavePositionProc},
{"----", NothingProc},
- {"Copy Position", CopyPositionProc},
- {"Paste Position", PastePositionProc},
+ {N_("Copy Position"), CopyPositionProc},
+ {N_("Paste Position"), PastePositionProc},
{"----", NothingProc},
- {"Mail Move", MailMoveProc},
- {"Reload CMail Message", ReloadCmailMsgProc},
+ {N_("Mail Move"), MailMoveProc},
+ {N_("Reload CMail Message"), ReloadCmailMsgProc},
{"----", NothingProc},
- {"Exit", QuitProc},
+ {N_("Exit"), QuitProc},
{NULL, NULL}
};
MenuItem modeMenu[] = {
- {"Machine White", MachineWhiteProc},
- {"Machine Black", MachineBlackProc},
- {"Two Machines", TwoMachinesProc},
- {"Analysis Mode", AnalyzeModeProc},
- {"Analyze File", AnalyzeFileProc },
- {"ICS Client", IcsClientProc},
- {"Edit Game", EditGameProc},
- {"Edit Position", EditPositionProc},
- {"Training", TrainingProc},
+ {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},
- {"Show Game List", ShowGameListProc},
- {"Show Move List", HistoryShowProc},
- {"Edit Tags", EditTagsProc},
- {"Edit Comment", EditCommentProc},
- {"ICS Input Box", IcsInputBoxProc},
- {"Pause", PauseProc},
+ {N_("Edit Tags"), EditTagsProc},
+ {N_("Edit Comment"), EditCommentProc},
+ {N_("ICS Input Box"), IcsInputBoxProc},
+ {N_("Pause"), PauseProc},
{NULL, NULL}
};
MenuItem actionMenu[] = {
- {"Accept", AcceptProc},
- {"Decline", DeclineProc},
- {"Rematch", RematchProc},
- {"----", NothingProc},
- {"Call Flag", CallFlagProc},
- {"Draw", DrawProc},
- {"Adjourn", AdjournProc},
- {"Abort", AbortProc},
- {"Resign", ResignProc},
- {"----", NothingProc},
- {"Stop Observing", StopObservingProc},
- {"Stop Examining", StopExaminingProc},
+ {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}
};
MenuItem stepMenu[] = {
- {"Backward", BackwardProc},
- {"Forward", ForwardProc},
- {"Back to Start", ToStartProc},
- {"Forward to End", ToEndProc},
- {"Revert", RevertProc},
- {"Truncate Game", TruncateGameProc},
- {"----", NothingProc},
- {"Move Now", MoveNowProc},
- {"Retract Move", RetractMoveProc},
+ {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 optionsMenu[] = {
- {"Always Queen", AlwaysQueenProc},
- {"Animate Dragging", AnimateDraggingProc},
- {"Animate Moving", AnimateMovingProc},
- {"Auto Comment", AutocommProc},
- {"Auto Flag", AutoflagProc},
- {"Auto Flip View", AutoflipProc},
- {"Auto Observe", AutobsProc},
- {"Auto Raise Board", AutoraiseProc},
- {"Auto Save", AutosaveProc},
- {"Blindfold", BlindfoldProc},
- {"Flash Moves", FlashMovesProc},
- {"Flip View", FlipViewProc},
- {"Get Move List", GetMoveListProc},
+ {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},
#if HIGHDRAG
- {"Highlight Dragging", HighlightDraggingProc},
+ {N_("Highlight Dragging"), HighlightDraggingProc},
#endif
- {"Highlight Last Move", HighlightLastMoveProc},
- {"Move Sound", MoveSoundProc},
- {"ICS Alarm", IcsAlarmProc},
- {"Old Save Style", OldSaveStyleProc},
- {"Periodic Updates", PeriodicUpdatesProc},
- {"Ponder Next Move", PonderNextMoveProc},
- {"Popup Exit Message", PopupExitMessageProc},
- {"Popup Move Errors", PopupMoveErrorsProc},
- {"Premove", PremoveProc},
- {"Quiet Play", QuietPlayProc},
- {"Show Coords", ShowCoordsProc},
- {"Show Thinking", ShowThinkingProc},
- {"Test Legality", TestLegalityProc},
+ {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}
};
MenuItem helpMenu[] = {
- {"Info XBoard", InfoProc},
- {"Man XBoard", ManProc},
+ {N_("Info XBoard"), InfoProc},
+ {N_("Man XBoard"), ManProc},
{"----", NothingProc},
- {"Hint", HintProc},
- {"Book", BookProc},
+ {N_("Hint"), HintProc},
+ {N_("Book"), BookProc},
{"----", NothingProc},
- {"About XBoard", AboutProc},
+ {N_("About XBoard"), AboutProc},
{NULL, NULL}
};
Menu menuBar[] = {
- {"File", fileMenu},
- {"Mode", modeMenu},
- {"Action", actionMenu},
- {"Step", stepMenu},
- {"Options", optionsMenu},
- {"Help", helpMenu},
+ {N_("File"), fileMenu},
+ {N_("Mode"), modeMenu},
+ {N_("Action"), actionMenu},
+ {N_("Step"), stepMenu},
+ {N_("Options"), optionsMenu},
+ {N_("Help"), helpMenu},
{NULL, NULL}
};
-#define PAUSE_BUTTON "P"
+#define PAUSE_BUTTON N_("P")
MenuItem buttonBar[] = {
{"<<", ToStartProc},
{"<", BackwardProc},
{NULL, NULL}
};
-#define PIECE_MENU_SIZE 11
+#define PIECE_MENU_SIZE 18
String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
- { "White", "----", "Pawn", "Knight", "Bishop", "Rook", "Queen", "King",
- "----", "Empty square", "Clear board" },
- { "Black", "----", "Pawn", "Knight", "Bishop", "Rook", "Queen", "King",
- "----", "Empty square", "Clear board" },
- };
+ { 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_("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_("Empty square"), N_("Clear board") }
+};
/* must be in same order as PieceMenuStrings! */
ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
{ WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
- WhiteRook, WhiteQueen, WhiteKing,
- (ChessSquare) 0, EmptySquare, ClearBoard },
+ WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
+ WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
+ PromotePiece, DemotePiece, EmptySquare, ClearBoard },
{ BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
- BlackRook, BlackQueen, BlackKing,
- (ChessSquare) 0, EmptySquare, ClearBoard },
+ BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
+ BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
+ PromotePiece, DemotePiece, EmptySquare, ClearBoard },
};
#define DROP_MENU_SIZE 6
String dropMenuStrings[DROP_MENU_SIZE] = {
- "----", "Pawn", "Knight", "Bishop", "Rook", "Queen"
+ "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
};
/* must be in same order as PieceMenuStrings! */
ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
};
XtResource clientResources[] = {
- { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, whitePieceColor), XtRString,
- WHITE_PIECE_COLOR },
- { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, blackPieceColor), XtRString,
- BLACK_PIECE_COLOR },
- { "lightSquareColor", "lightSquareColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
- XtRString, LIGHT_SQUARE_COLOR },
- { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
- XtOffset(AppDataPtr, darkSquareColor), XtRString,
- DARK_SQUARE_COLOR },
- { "highlightSquareColor", "highlightSquareColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
- XtRString, HIGHLIGHT_SQUARE_COLOR },
- { "premoveHighlightColor", "premoveHighlightColor", XtRString,
- sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
- XtRString, PREMOVE_HIGHLIGHT_COLOR },
- { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
- (XtPointer) MOVES_PER_SESSION },
- { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
- (XtPointer) TIME_INCREMENT },
- { "initString", "initString", XtRString, sizeof(String),
- XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
- { "secondInitString", "secondInitString", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
- { "firstComputerString", "firstComputerString", XtRString,
- sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
- COMPUTER_STRING },
- { "secondComputerString", "secondComputerString", XtRString,
- sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
- COMPUTER_STRING },
- { "firstChessProgram", "firstChessProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
- XtRString, FIRST_CHESS_PROGRAM },
- { "secondChessProgram", "secondChessProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
- XtRString, SECOND_CHESS_PROGRAM },
- { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
- XtRImmediate, (XtPointer) False },
- { "noChessProgram", "noChessProgram", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
- XtRImmediate, (XtPointer) False },
- { "firstHost", "firstHost", XtRString, sizeof(String),
- XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
- { "secondHost", "secondHost", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
- { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, firstDirectory), XtRString, "" },
- { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
- XtOffset(AppDataPtr, secondDirectory), XtRString, "" },
- { "bitmapDirectory", "bitmapDirectory", XtRString,
- sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
- XtRString, "" },
- { "remoteShell", "remoteShell", XtRString, sizeof(String),
- XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
- { "remoteUser", "remoteUser", XtRString, sizeof(String),
- XtOffset(AppDataPtr, remoteUser), XtRString, "" },
- { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
- XtOffset(AppDataPtr, timeDelay), XtRString,
- (XtPointer) TIME_DELAY_QUOTE },
- { "timeControl", "timeControl", XtRString, sizeof(String),
- XtOffset(AppDataPtr, timeControl), XtRString,
- (XtPointer) TIME_CONTROL },
- { "internetChessServerMode", "internetChessServerMode",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsActive), XtRImmediate,
- (XtPointer) False },
- { "internetChessServerHost", "internetChessServerHost",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsHost),
- XtRString, (XtPointer) ICS_HOST },
- { "internetChessServerPort", "internetChessServerPort",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsPort), XtRString,
- (XtPointer) ICS_PORT },
- { "internetChessServerCommPort", "internetChessServerCommPort",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsCommPort), XtRString,
- ICS_COMM_PORT },
- { "internetChessServerLogonScript", "internetChessServerLogonScript",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsLogon), XtRString,
- ICS_LOGON },
- { "internetChessServerHelper", "internetChessServerHelper",
- XtRString, sizeof(String),
- XtOffset(AppDataPtr, icsHelper), XtRString, "" },
- { "internetChessServerInputBox", "internetChessServerInputBox",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
- (XtPointer) False },
- { "icsAlarm", "icsAlarm",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
- (XtPointer) True },
- { "icsAlarmTime", "icsAlarmTime",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
- (XtPointer) 5000 },
- { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, useTelnet), XtRImmediate,
- (XtPointer) False },
- { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
- XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
- { "gateway", "gateway", XtRString, sizeof(String),
- XtOffset(AppDataPtr, gateway), XtRString, "" },
- { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
- XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
- { "loadGameIndex", "loadGameIndex",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
- (XtPointer) 0 },
- { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
- XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
- { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
- XtRImmediate, (XtPointer) True },
- { "autoSaveGames", "autoSaveGames", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
- XtRImmediate, (XtPointer) False },
- { "blindfold", "blindfold", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
- XtRImmediate, (XtPointer) False },
- { "loadPositionFile", "loadPositionFile", XtRString,
- sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
- XtRString, "" },
- { "loadPositionIndex", "loadPositionIndex",
- XtRInt, sizeof(int),
- XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
- (XtPointer) 1 },
- { "savePositionFile", "savePositionFile", XtRString,
- sizeof(String), XtOffset(AppDataPtr, savePositionFile),
- XtRString, "" },
- { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
- { "matchGames", "matchGames", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, matchGames), XtRImmediate,
- (XtPointer) 0 },
- { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, monoMode), XtRImmediate,
- (XtPointer) False },
- { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, debugMode), XtRImmediate,
- (XtPointer) False },
- { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, clockMode), XtRImmediate,
- (XtPointer) True },
- { "boardSize", "boardSize", XtRString, sizeof(String),
- XtOffset(AppDataPtr, boardSize), XtRString, "" },
- { "searchTime", "searchTime", XtRString, sizeof(String),
- XtOffset(AppDataPtr, searchTime), XtRString,
- (XtPointer) "" },
- { "searchDepth", "searchDepth", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, searchDepth), XtRImmediate,
- (XtPointer) 0 },
- { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, showCoords), XtRImmediate,
- (XtPointer) False },
- { "showJail", "showJail", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, showJail), XtRImmediate,
- (XtPointer) 0 },
- { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, showThinking), XtRImmediate,
- (XtPointer) False },
- { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
- (XtPointer) True },
- { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
- (XtPointer) True },
- { "clockFont", "clockFont", XtRString, sizeof(String),
- XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
- { "coordFont", "coordFont", XtRString, sizeof(String),
- XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
- { "font", "font", XtRString, sizeof(String),
- XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
- { "ringBellAfterMoves", "ringBellAfterMoves",
- XtRBoolean, sizeof(Boolean),
- XtOffset(AppDataPtr, ringBellAfterMoves),
- XtRImmediate, (XtPointer) False },
- { "autoCallFlag", "autoCallFlag", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
- XtRImmediate, (XtPointer) False },
- { "autoFlipView", "autoFlipView", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
- XtRImmediate, (XtPointer) True },
- { "autoObserve", "autoObserve", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
- XtRImmediate, (XtPointer) False },
- { "autoComment", "autoComment", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
- XtRImmediate, (XtPointer) False },
- { "getMoveList", "getMoveList", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
- XtRImmediate, (XtPointer) True },
-#if HIGHDRAG
- { "highlightDragging", "highlightDragging", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
- XtRImmediate, (XtPointer) False },
-#endif
- { "highlightLastMove", "highlightLastMove", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
- XtRImmediate, (XtPointer) False },
- { "premove", "premove", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, premove),
- XtRImmediate, (XtPointer) True },
- { "testLegality", "testLegality", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
- XtRImmediate, (XtPointer) True },
- { "flipView", "flipView", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, flipView),
- XtRImmediate, (XtPointer) False },
- { "cmail", "cmailGameName", XtRString, sizeof(String),
- XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
- { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
- XtRImmediate, (XtPointer) False },
- { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
- XtRImmediate, (XtPointer) False },
- { "quietPlay", "quietPlay", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
- XtRImmediate, (XtPointer) False },
- { "titleInWindow", "titleInWindow", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
- XtRImmediate, (XtPointer) False },
- { "localLineEditing", "localLineEditing", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
- XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
-#ifdef ZIPPY
- { "zippyTalk", "zippyTalk", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
- XtRImmediate, (XtPointer) ZIPPY_TALK },
- { "zippyPlay", "zippyPlay", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
- XtRImmediate, (XtPointer) ZIPPY_PLAY },
- { "zippyLines", "zippyLines", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
- { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
- { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
- { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
- { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
- ZIPPY_WRONG_PASSWORD },
- { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
- { "zippyUseI", "zippyUseI", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
- XtRImmediate, (XtPointer) ZIPPY_USE_I },
- { "zippyBughouse", "zippyBughouse", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
- XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
- { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
- XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
- { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
- { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
- { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
- XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
- { "zippyAbort", "zippyAbort", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
- XtRImmediate, (XtPointer) ZIPPY_ABORT },
- { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
- XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
- { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
- (XtPointer) ZIPPY_MAX_GAMES },
- { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
- (XtPointer) ZIPPY_REPLAY_TIMEOUT },
-#endif
{ "flashCount", "flashCount", XtRInt, sizeof(int),
XtOffset(AppDataPtr, flashCount), XtRImmediate,
(XtPointer) FLASH_COUNT },
- { "flashRate", "flashRate", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, flashRate), XtRImmediate,
- (XtPointer) FLASH_RATE },
- { "pixmapDirectory", "pixmapDirectory", XtRString,
- sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
- XtRString, "" },
- { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
- XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
- (XtPointer) MS_LOGIN_DELAY },
- { "colorizeMessages", "colorizeMessages", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, colorize),
- XtRImmediate, (XtPointer) False },
- { "colorShout", "colorShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorShout),
- XtRString, COLOR_SHOUT },
- { "colorSShout", "colorSShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorSShout),
- XtRString, COLOR_SSHOUT },
- { "colorChannel1", "colorChannel1", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChannel1),
- XtRString, COLOR_CHANNEL1 },
- { "colorChannel", "colorChannel", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChannel),
- XtRString, COLOR_CHANNEL },
- { "colorKibitz", "colorKibitz", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorKibitz),
- XtRString, COLOR_KIBITZ },
- { "colorTell", "colorTell", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorTell),
- XtRString, COLOR_TELL },
- { "colorChallenge", "colorChallenge", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorChallenge),
- XtRString, COLOR_CHALLENGE },
- { "colorRequest", "colorRequest", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorRequest),
- XtRString, COLOR_REQUEST },
- { "colorSeek", "colorSeek", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorSeek),
- XtRString, COLOR_SEEK },
- { "colorNormal", "colorNormal", XtRString,
- sizeof(String), XtOffset(AppDataPtr, colorNormal),
- XtRString, COLOR_NORMAL },
- { "soundProgram", "soundProgram", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundProgram),
- XtRString, "play" },
- { "soundShout", "soundShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundShout),
- XtRString, "" },
- { "soundSShout", "soundSShout", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundSShout),
- XtRString, "" },
- { "soundChannel1", "soundChannel1", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChannel1),
- XtRString, "" },
- { "soundChannel", "soundChannel", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChannel),
- XtRString, "" },
- { "soundKibitz", "soundKibitz", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundKibitz),
- XtRString, "" },
- { "soundTell", "soundTell", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundTell),
- XtRString, "" },
- { "soundChallenge", "soundChallenge", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundChallenge),
- XtRString, "" },
- { "soundRequest", "soundRequest", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundRequest),
- XtRString, "" },
- { "soundSeek", "soundSeek", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundSeek),
- XtRString, "" },
- { "soundMove", "soundMove", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundMove),
- XtRString, "$" },
- { "soundIcsWin", "soundIcsWin", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
- XtRString, "" },
- { "soundIcsLoss", "soundIcsLoss", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
- XtRString, "" },
- { "soundIcsDraw", "soundIcsDraw", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
- XtRString, "" },
- { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
- XtRString, "" },
- { "soundIcsAlarm", "soundIcsAlarm", XtRString,
- sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
- XtRString, "$" },
- { "reuseFirst", "reuseFirst", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
- XtRImmediate, (XtPointer) True },
- { "reuseSecond", "reuseSecond", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
- XtRImmediate, (XtPointer) True },
- { "animateDragging", "animateDragging", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
- XtRImmediate, (XtPointer) True },
- { "animateMoving", "animateMoving", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, animate),
- XtRImmediate, (XtPointer) True },
- { "animateSpeed", "animateSpeed", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, animSpeed),
- XtRImmediate, (XtPointer)10 },
- { "popupExitMessage", "popupExitMessage", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
- XtRImmediate, (XtPointer) True },
- { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
- XtRImmediate, (XtPointer) False },
- { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
- XtRImmediate, (XtPointer)4 },
- { "initialMode", "initialMode", XtRString,
- sizeof(String), XtOffset(AppDataPtr, initialMode),
- XtRImmediate, (XtPointer) "" },
- { "variant", "variant", XtRString,
- sizeof(String), XtOffset(AppDataPtr, variant),
- XtRImmediate, (XtPointer) "normal" },
- { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
- XtRImmediate, (XtPointer)PROTOVER },
- { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
- sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
- XtRImmediate, (XtPointer)PROTOVER },
- { "showButtonBar", "showButtonBar", XtRBoolean,
- sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
- XtRImmediate, (XtPointer) True },
};
XrmOptionDescRec shellOptions[] = {
- { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
- { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
- { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
- { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
- { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
- { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
- { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
- { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
- { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
- { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
- { "-initString", "initString", XrmoptionSepArg, NULL },
- { "-firstInitString", "initString", XrmoptionSepArg, NULL },
- { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
- { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
- { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
- { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
- { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
- { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
- { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
- { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
- { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
- { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
- { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
- { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
- { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
- { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
- { "-fh", "firstHost", XrmoptionSepArg, NULL },
- { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
- { "-sh", "secondHost", XrmoptionSepArg, NULL },
- { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
- { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
- { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
- { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
- { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
- { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
- { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
- { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
- { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
- { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
- { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
- { "-td", "timeDelay", XrmoptionSepArg, NULL },
- { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
- { "-tc", "timeControl", XrmoptionSepArg, NULL },
- { "-internetChessServerMode", "internetChessServerMode",
- XrmoptionSepArg, NULL },
- { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
- { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
- { "-internetChessServerHost", "internetChessServerHost",
- XrmoptionSepArg, NULL },
- { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
- { "-internetChessServerPort", "internetChessServerPort",
- XrmoptionSepArg, NULL },
- { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
- { "-internetChessServerCommPort", "internetChessServerCommPort",
- XrmoptionSepArg, NULL },
- { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
- { "-internetChessServerLogonScript", "internetChessServerLogonScript",
- XrmoptionSepArg, NULL },
- { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
- { "-internetChessServerHelper", "internetChessServerHelper",
- XrmoptionSepArg, NULL },
- { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
- { "-internetChessServerInputBox", "internetChessServerInputBox",
- XrmoptionSepArg, NULL },
- { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
- { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
- { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
- { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
- { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
- { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
- { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
- { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
- { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
- { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
- { "-gateway", "gateway", XrmoptionSepArg, NULL },
- { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
- { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
- { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
- { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
- { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
- { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
- { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
- { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
- { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
- { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
- { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
- { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
- { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
- { "-blind", "blindfold", XrmoptionNoArg, "True" },
- { "-xblind", "blindfold", XrmoptionNoArg, "False" },
- { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
- { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
- { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
- { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
- { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
- { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
- { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
- { "-mm", "matchMode", XrmoptionNoArg, "True" },
- { "-xmm", "matchMode", XrmoptionNoArg, "False" },
- { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
- { "-mg", "matchGames", XrmoptionSepArg, NULL },
- { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
- { "-mono", "monoMode", XrmoptionNoArg, "True" },
- { "-xmono", "monoMode", XrmoptionNoArg, "False" },
- { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
- { "-debug", "debugMode", XrmoptionNoArg, "True" },
- { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
- { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
- { "-clock", "clockMode", XrmoptionNoArg, "True" },
- { "-xclock", "clockMode", XrmoptionNoArg, "False" },
- { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
- { "-size", "boardSize", XrmoptionSepArg, NULL },
- { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
- { "-st", "searchTime", XrmoptionSepArg, NULL },
- { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
- { "-depth", "searchDepth", XrmoptionSepArg, NULL },
- { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
- { "-coords", "showCoords", XrmoptionNoArg, "True" },
- { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
-#if JAIL
- { "-showJail", "showJail", XrmoptionSepArg, NULL },
- { "-jail", "showJail", XrmoptionNoArg, "1" },
- { "-sidejail", "showJail", XrmoptionNoArg, "2" },
- { "-xjail", "showJail", XrmoptionNoArg, "0" },
-#endif
- { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
- { "-thinking", "showThinking", XrmoptionNoArg, "True" },
- { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
- { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
- { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
- { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
- { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
- { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
- { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
- { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
- { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
- { "-font", "font", XrmoptionSepArg, NULL },
- { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
- { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
- { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
- { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
- { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
- { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
- { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
- { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
- { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
- { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
- { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
- { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
- { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
- { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
- { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
- { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
- { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
- { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
- { "-moves", "getMoveList", XrmoptionNoArg, "True" },
- { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
-#if HIGHDRAG
- { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
- { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
- { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
-#endif
- { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
- { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
- { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
- { "-premove", "premove", XrmoptionSepArg, NULL },
- { "-pre", "premove", XrmoptionNoArg, "True" },
- { "-xpre", "premove", XrmoptionNoArg, "False" },
- { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
- { "-legal", "testLegality", XrmoptionNoArg, "True" },
- { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
- { "-flipView", "flipView", XrmoptionSepArg, NULL },
- { "-flip", "flipView", XrmoptionNoArg, "True" },
- { "-xflip", "flipView", XrmoptionNoArg, "False" },
- { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
- { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
- XrmoptionSepArg, NULL },
- { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
- { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
- { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
- { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
- { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
- { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
- { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
- { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
- { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
- { "-title", "titleInWindow", XrmoptionNoArg, "True" },
- { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
-#ifdef ZIPPY
- { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
- { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
- { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
- { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
- { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
- { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
- { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
- { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
- { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
- { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
- { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
- { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
- { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
- { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
- { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
- { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
- { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
- { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
- { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
- { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
- { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
- { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
- { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
- { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
- { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
- { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
- { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
- { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
- { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
- { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
-#endif
{ "-flashCount", "flashCount", XrmoptionSepArg, NULL },
{ "-flash", "flashCount", XrmoptionNoArg, "3" },
{ "-xflash", "flashCount", XrmoptionNoArg, "0" },
- { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
- { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
- { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
- { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
- { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
- { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
- { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
- { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
- { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
- { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
- { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
- { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
- { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
- { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
- { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
- { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
- { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
- { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
- { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
- { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
- { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
- { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
- { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
- { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
- { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
- { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
- { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
- { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
- { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
- { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
- { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
- { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
- { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
- { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
- { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
- { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
- { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
- { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
- { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
- { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
- { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
- { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
- { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
- { "-animate", "animateMoving", XrmoptionNoArg, "True" },
- { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
- { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
- { "-drag", "animateDragging", XrmoptionNoArg, "True" },
- { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
- { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
- { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
- { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
- { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
- { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
- { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
- { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
- { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
- { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
- { "-mode", "initialMode", XrmoptionSepArg, NULL },
- { "-variant", "variant", XrmoptionSepArg, NULL },
- { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
- { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
- { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
- { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
- { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
};
-
XtActionsRec boardActions[] = {
{ "DrawPosition", DrawPositionProc },
{ "HandleUserMove", HandleUserMove },
{ "AnimateUserMove", AnimateUserMove },
+ { "HandlePV", HandlePV },
+ { "SelectPV", SelectPV },
+ { "StopPV", StopPV },
{ "FileNameAction", FileNameAction },
{ "AskQuestionProc", AskQuestionProc },
{ "AskQuestionReplyAction", AskQuestionReplyAction },
{ "BlackClock", BlackClock },
{ "Iconify", Iconify },
{ "ResetProc", ResetProc },
+ { "NewVariantProc", NewVariantProc },
{ "LoadGameProc", LoadGameProc },
{ "LoadNextGameProc", LoadNextGameProc },
{ "LoadPrevGameProc", LoadPrevGameProc },
{ "LoadSelectedProc", LoadSelectedProc },
+ { "SetFilterProc", SetFilterProc },
{ "ReloadGameProc", ReloadGameProc },
{ "LoadPositionProc", LoadPositionProc },
{ "LoadNextPositionProc", LoadNextPositionProc },
{ "EditGameProc", EditGameProc },
{ "EditPositionProc", EditPositionProc },
{ "TrainingProc", EditPositionProc },
+ { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
+ { "EvalGraphProc", EvalGraphProc}, // [HGM] Winboard_x avaluation graph window
{ "ShowGameListProc", ShowGameListProc },
{ "ShowMoveListProc", HistoryShowProc},
{ "EditTagsProc", EditCommentProc },
{ "AdjournProc", AdjournProc },
{ "AbortProc", AbortProc },
{ "ResignProc", ResignProc },
+ { "AdjuWhiteProc", AdjuWhiteProc },
+ { "AdjuBlackProc", AdjuBlackProc },
+ { "AdjuDrawProc", AdjuDrawProc },
{ "EnterKeyProc", EnterKeyProc },
+ { "UpKeyProc", UpKeyProc },
+ { "DownKeyProc", DownKeyProc },
{ "StopObservingProc", StopObservingProc },
{ "StopExaminingProc", StopExaminingProc },
+ { "UploadProc", UploadProc },
{ "BackwardProc", BackwardProc },
{ "ForwardProc", ForwardProc },
{ "ToStartProc", ToStartProc },
{ "ToEndProc", ToEndProc },
{ "RevertProc", RevertProc },
+ { "AnnotateProc", AnnotateProc },
{ "TruncateGameProc", TruncateGameProc },
{ "MoveNowProc", MoveNowProc },
{ "RetractMoveProc", RetractMoveProc },
+ { "EngineMenuProc", (XtActionProc) EngineMenuProc },
+ { "UciMenuProc", (XtActionProc) UciMenuProc },
+ { "TimeControlProc", (XtActionProc) TimeControlProc },
{ "AlwaysQueenProc", AlwaysQueenProc },
{ "AnimateDraggingProc", AnimateDraggingProc },
{ "AnimateMovingProc", AnimateMovingProc },
{ "IcsAlarmProc", IcsAlarmProc },
{ "MoveSoundProc", MoveSoundProc },
{ "OldSaveStyleProc", OldSaveStyleProc },
- { "PeriodicUpdatesProc", PeriodicUpdatesProc },
+ { "PeriodicUpdatesProc", PeriodicUpdatesProc },
{ "PonderNextMoveProc", PonderNextMoveProc },
- { "PopupExitMessageProc", PopupExitMessageProc },
- { "PopupMoveErrorsProc", PopupMoveErrorsProc },
+ { "PopupExitMessageProc", PopupExitMessageProc },
+ { "PopupMoveErrorsProc", PopupMoveErrorsProc },
{ "PremoveProc", PremoveProc },
{ "QuietPlayProc", QuietPlayProc },
{ "ShowCoordsProc", ShowCoordsProc },
{ "ShowThinkingProc", ShowThinkingProc },
+ { "HideThinkingProc", HideThinkingProc },
{ "TestLegalityProc", TestLegalityProc },
+ { "SaveSettingsProc", SaveSettingsProc },
+ { "SaveOnExitProc", SaveOnExitProc },
{ "InfoProc", InfoProc },
{ "ManProc", ManProc },
{ "HintProc", HintProc },
{ "AboutProc", AboutProc },
{ "DebugProc", DebugProc },
{ "NothingProc", NothingProc },
+ { "CommentClick", (XtActionProc) CommentClick },
{ "CommentPopDown", (XtActionProc) CommentPopDown },
{ "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
{ "TagsPopDown", (XtActionProc) TagsPopDown },
{ "ErrorPopDown", (XtActionProc) ErrorPopDown },
{ "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
- { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
{ "FileNamePopDown", (XtActionProc) FileNamePopDown },
{ "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
{ "GameListPopDown", (XtActionProc) GameListPopDown },
+ { "GameListOptionsPopDown", (XtActionProc) GameListOptionsPopDown },
{ "PromotionPopDown", (XtActionProc) PromotionPopDown },
{ "HistoryPopDown", (XtActionProc) HistoryPopDown },
+ { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
+ { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
+ { "ShufflePopDown", (XtActionProc) ShufflePopDown },
+ { "EnginePopDown", (XtActionProc) EnginePopDown },
+ { "UciPopDown", (XtActionProc) UciPopDown },
+ { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
+ { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
+ { "SettingsPopDown", (XtActionProc) SettingsPopDown },
+ { "CopyMemoProc", (XtActionProc) CopyMemoProc },
};
-
+
char globalTranslations[] =
- ":<Key>R: ResignProc() \n \
- :<Key>r: ResetProc() \n \
- :<Key>g: LoadGameProc() \n \
- :<Key>N: LoadNextGameProc() \n \
- :<Key>P: LoadPrevGameProc() \n \
- :<Key>Q: QuitProc() \n \
- :<Key>F: ToEndProc() \n \
- :<Key>f: ForwardProc() \n \
- :<Key>B: ToStartProc() \n \
- :<Key>b: BackwardProc() \n \
- :<Key>p: PauseProc() \n \
- :<Key>d: DrawProc() \n \
- :<Key>t: CallFlagProc() \n \
- :<Key>i: Iconify() \n \
- :<Key>c: Iconify() \n \
- :<Key>v: FlipViewProc() \n \
- <KeyDown>Control_L: BackwardProc() \n \
- <KeyUp>Control_L: ForwardProc() \n \
- <KeyDown>Control_R: BackwardProc() \n \
- <KeyUp>Control_R: ForwardProc() \n \
+ ":<Key>F9: ResignProc() \n \
+ :Ctrl<Key>n: ResetProc() \n \
+ :Meta<Key>V: NewVariantProc() \n \
+ :Ctrl<Key>o: LoadGameProc() \n \
+ :Meta<Key>Next: LoadNextGameProc() \n \
+ :Meta<Key>Prior: LoadPrevGameProc() \n \
+ :Ctrl<Key>s: SaveGameProc() \n \
+ :Ctrl<Key>c: CopyGameProc() \n \
+ :Ctrl<Key>v: PasteGameProc() \n \
+ :Ctrl<Key>O: LoadPositionProc() \n \
+ :Shift Meta<Key>Next: LoadNextPositionProc() \n \
+ :Shift Meta<Key>Prior: LoadPrevPositionProc() \n \
+ :Ctrl<Key>S: SavePositionProc() \n \
+ :Ctrl<Key>C: CopyPositionProc() \n \
+ :Ctrl<Key>V: PastePositionProc() \n \
+ :Ctrl<Key>q: QuitProc() \n \
+ :Ctrl<Key>w: MachineWhiteProc() \n \
+ :Ctrl<Key>b: MachineBlackProc() \n \
+ :Ctrl<Key>t: TwoMachinesProc() \n \
+ :Ctrl<Key>a: AnalysisModeProc() \n \
+ :Ctrl<Key>f: AnalyzeFileProc() \n \
+ :Ctrl<Key>e: EditGameProc() \n \
+ :Ctrl<Key>E: EditPositionProc() \n \
+ :Meta<Key>O: EngineOutputProc() \n \
+ :Meta<Key>E: EvalGraphProc() \n \
+ :Meta<Key>G: ShowGameListProc() \n \
+ :Meta<Key>H: ShowMoveListProc() \n \
+ :<Key>Pause: PauseProc() \n \
+ :<Key>F3: AcceptProc() \n \
+ :<Key>F4: DeclineProc() \n \
+ :<Key>F12: RematchProc() \n \
+ :<Key>F5: CallFlagProc() \n \
+ :<Key>F6: DrawProc() \n \
+ :<Key>F7: AdjournProc() \n \
+ :<Key>F8: AbortProc() \n \
+ :<Key>F10: StopObservingProc() \n \
+ :<Key>F11: StopExaminingProc() \n \
+ :Meta Ctrl<Key>F12: DebugProc() \n \
+ :Meta<Key>End: ToEndProc() \n \
+ :Meta<Key>Right: ForwardProc() \n \
+ :Meta<Key>Home: ToStartProc() \n \
+ :Meta<Key>Left: BackwardProc() \n \
+ :Ctrl<Key>m: MoveNowProc() \n \
+ :Ctrl<Key>x: RetractMoveProc() \n \
+ :Meta<Key>J: EngineMenuProc() \n \
+ :Meta<Key>U: UciMenuProc() \n \
+ :Meta<Key>T: TimeControlProc() \n \
+ :Ctrl<Key>Q: AlwaysQueenProc() \n \
+ :Ctrl<Key>F: AutoflagProc() \n \
+ :Ctrl<Key>A: AnimateMovingProc() \n \
+ :Ctrl<Key>P: PonderNextMoveProc() \n \
+ :Ctrl<Key>L: TestLegalityProc() \n \
+ :Ctrl<Key>H: HideThinkingProc() \n \
+ :<Key>-: Iconify() \n \
+ :<Key>F1: ManProc() \n \
+ :<Key>F2: FlipViewProc() \n \
+ <KeyDown>.: BackwardProc() \n \
+ <KeyUp>.: 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 \
+ "<Btn1Down>: HandleUserMove(0) \n \
+ Shift<Btn1Up>: HandleUserMove(1) \n \
+ <Btn1Up>: HandleUserMove(0) \n \
<Btn1Motion>: AnimateUserMove() \n \
+ <Btn3Motion>: HandlePV() \n \
+ <Btn3Up>: PieceMenuPopup(menuB) \n \
Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
PieceMenuPopup(menuB) \n \
Any<Btn2Down>: 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>Up: UpKeyProc() \n "
+ "<Key>Down: DownKeyProc() \n "
"<Key>Return: EnterKeyProc() \n";
+// [HGM] vari: another hideous kludge: call extend-end first so we can be sure select-start works,
+// as the widget is destroyed before the up-click can call extend-end
+char commentTranslations[] = "<Btn3Down>: extend-end() select-start() CommentClick() \n";
+
String xboardResources[] = {
"*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
"*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
"*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
NULL
};
-
+
/* Max possible square size */
#define MAXSQSIZE 256
{
char *p, *d;
char buf[10];
-
+
if (len < 4)
return 0;
if ((p=strchr(name, '.')) == NULL ||
StrCaseCmp(p+1, ext) != 0)
return 0;
-
+
p = name + 3;
d = buf;
if (appData.debugMode)
fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
-
+
dir = opendir(dirname);
if (!dir)
{
- fprintf(stderr, "%s: Can't access XPM directory %s\n",
+ fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
programName, dirname);
exit(1);
}
-
+
while ((ent=readdir(dir)) != NULL) {
i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
if (i > 0 && i < MAXSQSIZE)
{
int i;
- fprintf(fp, "Available `%s' sizes:\n", ext);
+ fprintf(fp, _("Available `%s' sizes:\n"), ext);
for (i=1; i<MAXSQSIZE; ++i) {
if (xpm_avail[i])
printf("%d\n", 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;
}
if (!sm_index) {
- fprintf(stderr, "Error: No `%s' files!\n", ext);
+ fprintf(stderr, _("Error: No `%s' files!\n"), ext);
exit(1);
}
int size;
char *ext;
{
- fprintf(stderr, "Warning: No DIR structure found on this system --\n");
- fprintf(stderr, " Unable to autosize for XPM/XIM pieces.\n");
- fprintf(stderr, " Please report this error to frankm@hiwaay.net.\n");
- fprintf(stderr, " Include system type & operating system in message.\n");
+ 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 */
{
char *p, buf[100], *d;
int i;
-
+
if (strlen(str) > 99) /* watch bounds on buf */
return -1;
if (*p == ',') {
return -1; /* Use default for empty field */
}
-
+
if (which == 2 || isdigit(*p))
return atoi(p);
-
+
while (*p && isalpha(*p))
*(d++) = *(p++);
}
if (!StrCaseCmp(buf, "default")) return -1;
- fprintf(stderr, "%s: unrecognized color %s\n", programName, buf);
+ fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
return -2;
}
char *str;
{
if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
- fprintf(stderr, "%s: can't parse foreground color in `%s'\n",
+ fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
programName, str);
return -1;
}
{
char buf[MSG_SIZ];
XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
- sprintf(buf, "<Message>WM_PROTOCOLS: %s() \n", procname);
+ snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
XtAugmentTranslations(w, XtParseTranslationTable(buf));
}
XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
}
+//---------------------------------------------------------------------------------------------------------
+// some symbol definitions to provide the proper (= XBoard) context for the code in args.h
+#define XBOARD True
+#define JAWS_ARGS
+#define CW_USEDEFAULT (1<<31)
+#define ICS_TEXT_MENU_SIZE 90
+#define DEBUG_FILE "xboard.debug"
+#define SetCurrentDirectory chdir
+#define GetCurrentDirectory(SIZE, NAME) getcwd(NAME, SIZE)
+#define OPTCHAR "-"
+#define SEPCHAR " "
+
+// these two must some day move to frontend.h, when they are implemented
+Boolean GameListIsUp();
+
+// The option definition and parsing code common to XBoard and WinBoard is collected in this file
+#include "args.h"
+
+// front-end part of option handling
+
+// [HGM] This platform-dependent table provides the location for storing the color info
+extern char *crWhite, * crBlack;
+
+void *
+colorVariable[] = {
+ &appData.whitePieceColor,
+ &appData.blackPieceColor,
+ &appData.lightSquareColor,
+ &appData.darkSquareColor,
+ &appData.highlightSquareColor,
+ &appData.premoveHighlightColor,
+ &appData.lowTimeWarningColor,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &crWhite,
+ &crBlack,
+ NULL
+};
+
+// [HGM] font: keep a font for each square size, even non-stndard ones
+#define NUM_SIZES 18
+#define MAX_SIZE 130
+Boolean fontSet[NUM_FONTS], fontValid[NUM_FONTS][MAX_SIZE];
+char *fontTable[NUM_FONTS][MAX_SIZE];
+
+void
+ParseFont(char *name, int number)
+{ // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
+ int size;
+ if(sscanf(name, "size%d:", &size)) {
+ // [HGM] font: font is meant for specific boardSize (likely from settings file);
+ // defer processing it until we know if it matches our board size
+ if(size >= 0 && size<MAX_SIZE) { // for now, fixed limit
+ fontTable[number][size] = strdup(strchr(name, ':')+1);
+ fontValid[number][size] = True;
+ }
+ return;
+ }
+ switch(number) {
+ case 0: // CLOCK_FONT
+ appData.clockFont = strdup(name);
+ break;
+ case 1: // MESSAGE_FONT
+ appData.font = strdup(name);
+ break;
+ case 2: // COORD_FONT
+ appData.coordFont = strdup(name);
+ break;
+ default:
+ return;
+ }
+ fontSet[number] = True; // [HGM] font: indicate a font was specified (not from settings file)
+}
+
+void
+SetFontDefaults()
+{ // only 2 fonts currently
+ appData.clockFont = CLOCK_FONT_NAME;
+ appData.coordFont = COORD_FONT_NAME;
+ appData.font = DEFAULT_FONT_NAME;
+}
+
+void
+CreateFonts()
+{ // no-op, until we identify the code for this already in XBoard and move it here
+}
+
+void
+ParseColor(int n, char *name)
+{ // in XBoard, just copy the color-name string
+ if(colorVariable[n]) *(char**)colorVariable[n] = strdup(name);
+}
+
+void
+ParseTextAttribs(ColorClass cc, char *s)
+{
+ (&appData.colorShout)[cc] = strdup(s);
+}
+
+void
+ParseBoardSize(void *addr, char *name)
+{
+ appData.boardSize = strdup(name);
+}
+
+void
+LoadAllSounds()
+{ // In XBoard the sound-playing program takes care of obtaining the actual sound
+}
+
+void
+SetCommPortDefaults()
+{ // for now, this is a no-op, as the corresponding option does not exist in XBoard
+}
+
+// [HGM] args: these three cases taken out to stay in front-end
+void
+SaveFontArg(FILE *f, ArgDescriptor *ad)
+{
+ char *name;
+ int i, n = (int)ad->argLoc;
+ switch(n) {
+ case 0: // CLOCK_FONT
+ name = appData.clockFont;
+ break;
+ case 1: // MESSAGE_FONT
+ name = appData.font;
+ break;
+ case 2: // COORD_FONT
+ name = appData.coordFont;
+ break;
+ default:
+ return;
+ }
+ for(i=0; i<NUM_SIZES; i++) // [HGM] font: current font becomes standard for current size
+ if(sizeDefaults[i].squareSize == squareSize) { // only for standard sizes!
+ fontTable[n][squareSize] = strdup(name);
+ fontValid[n][squareSize] = True;
+ 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]);
+}
+
+void
+ExportSounds()
+{ // nothing to do, as the sounds are at all times represented by their text-string names already
+}
+
+void
+SaveAttribsArg(FILE *f, ArgDescriptor *ad)
+{ // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)ad->argLoc]);
+}
+
+void
+SaveColor(FILE *f, ArgDescriptor *ad)
+{ // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
+ if(colorVariable[(int)ad->argLoc])
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)ad->argLoc]);
+}
+
+void
+SaveBoardSize(FILE *f, char *name, void *addr)
+{ // wrapper to shield back-end from BoardSize & sizeInfo
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
+}
+
+void
+ParseCommPortSettings(char *s)
+{ // no such option in XBoard (yet)
+}
+
+extern Widget engineOutputShell;
+extern Widget tagsShell, editTagsShell;
+void
+GetActualPlacement(Widget wg, WindowPlacement *wp)
+{
+ Arg args[16];
+ Dimension w, h;
+ Position x, y;
+ int i;
+
+ if(!wg) return;
+
+ i = 0;
+ XtSetArg(args[i], XtNx, &x); i++;
+ XtSetArg(args[i], XtNy, &y); i++;
+ XtSetArg(args[i], XtNwidth, &w); i++;
+ XtSetArg(args[i], XtNheight, &h); i++;
+ XtGetValues(wg, args, i);
+ wp->x = x - 4;
+ wp->y = y - 23;
+ wp->height = h;
+ wp->width = w;
+}
+
+void
+GetWindowCoords()
+{ // wrapper to shield use of window handles from back-end (make addressible by number?)
+ // In XBoard this will have to wait until awareness of window parameters is implemented
+ GetActualPlacement(shellWidget, &wpMain);
+ if(EngineOutputIsUp()) GetActualPlacement(engineOutputShell, &wpEngineOutput); else
+ if(MoveHistoryIsUp()) GetActualPlacement(historyShell, &wpMoveHistory);
+ if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
+ if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
+ if(commentShell) GetActualPlacement(commentShell, &wpComment);
+ else GetActualPlacement(editShell, &wpComment);
+ if(tagsShell) GetActualPlacement(tagsShell, &wpTags);
+ else GetActualPlacement(editTagsShell, &wpTags);
+}
+
+void
+PrintCommPortSettings(FILE *f, char *name)
+{ // This option does not exist in XBoard
+}
+
+int
+MySearchPath(char *installDir, char *name, char *fullname)
+{ // just append installDir and name. Perhaps ExpandPath should be used here?
+ name = ExpandPathName(name);
+ if(name && name[0] == '/')
+ safeStrCpy(fullname, name, MSG_SIZ );
+ else {
+ sprintf(fullname, "%s%c%s", installDir, '/', name);
+ }
+ return 1;
+}
+
+int
+MyGetFullPathName(char *name, char *fullname)
+{ // should use ExpandPath?
+ name = ExpandPathName(name);
+ safeStrCpy(fullname, name, MSG_SIZ );
+ return 1;
+}
+
+void
+EnsureOnScreen(int *x, int *y, int minX, int minY)
+{
+ return;
+}
+
+int
+MainWindowUp()
+{ // [HGM] args: allows testing if main window is realized from back-end
+ return xBoardWindow != 0;
+}
+
+void
+PopUpStartupDialog()
+{ // start menu not implemented in XBoard
+}
+
+char *
+ConvertToLine(int argc, char **argv)
+{
+ static char line[128*1024], buf[1024];
+ int i;
+
+ line[0] = NULLCHAR;
+ for(i=1; i<argc; i++)
+ {
+ if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') )
+ && argv[i][0] != '{' )
+ 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;
+}
+
+//--------------------------------------------------------------------------------------------
+
+extern Boolean twoBoards, partnerUp;
+
+#ifdef IDSIZES
+ // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
+#else
+#define BoardSize int
+void InitDrawingSizes(BoardSize boardSize, int flags)
+{ // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
+ Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
+ Arg args[16];
+ XtGeometryResult gres;
+ int i;
+
+ if(!formWidget) return;
+
+ /*
+ * Enable shell resizing.
+ */
+ shellArgs[0].value = (XtArgVal) &w;
+ shellArgs[1].value = (XtArgVal) &h;
+ XtGetValues(shellWidget, shellArgs, 2);
+
+ shellArgs[4].value = 3*w; shellArgs[2].value = 10;
+ shellArgs[5].value = 2*h; shellArgs[3].value = 10;
+ XtSetValues(shellWidget, &shellArgs[2], 4);
+
+ XtSetArg(args[0], XtNdefaultDistance, &sep);
+ XtGetValues(formWidget, args, 1);
+
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ CreateGrid();
+ hOffset = boardWidth + 10;
+ for(i=0; i<BOARD_WIDTH+BOARD_HEIGHT+2; i++) { // [HGM] dual: grid for second board
+ secondSegments[i] = gridSegments[i];
+ secondSegments[i].x1 += hOffset;
+ secondSegments[i].x2 += hOffset;
+ }
+
+ XtSetArg(args[0], XtNwidth, boardWidth);
+ XtSetArg(args[1], XtNheight, boardHeight);
+ XtSetValues(boardWidget, args, 2);
+
+ timerWidth = (boardWidth - sep) / 2;
+ XtSetArg(args[0], XtNwidth, timerWidth);
+ XtSetValues(whiteTimerWidget, args, 1);
+ XtSetValues(blackTimerWidget, args, 1);
+
+ XawFormDoLayout(formWidget, False);
+
+ if (appData.titleInWindow) {
+ i = 0;
+ XtSetArg(args[i], XtNborderWidth, &bor); i++;
+ XtSetArg(args[i], XtNheight, &h); i++;
+ XtGetValues(titleWidget, args, i);
+ if (smallLayout) {
+ w = boardWidth - 2*bor;
+ } else {
+ XtSetArg(args[0], XtNwidth, &w);
+ XtGetValues(menuBarWidget, args, 1);
+ w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
+ }
+
+ gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
+ if (gres != XtGeometryYes && appData.debugMode) {
+ fprintf(stderr,
+ _("%s: titleWidget geometry error %d %d %d %d %d\n"),
+ programName, gres, w, h, wr, hr);
+ }
+ }
+
+ XawFormDoLayout(formWidget, True);
+
+ /*
+ * Inhibit shell resizing.
+ */
+ shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + twoBoards*hOffset; // [HGM] dual
+ shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
+ shellArgs[4].value = shellArgs[2].value = w;
+ shellArgs[5].value = shellArgs[3].value = h;
+ XtSetValues(shellWidget, &shellArgs[0], 6);
+
+ // [HGM] pieces: tailor piece bitmaps to needs of specific variant
+ // (only for xpm)
+ if(useImages) {
+ for(i=0; i<4; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
+ xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
+ xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
+ xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
+ xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
+ }
+#endif
+#if !HAVE_LIBXPM
+ // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
+ for(p=0; p<=(int)WhiteKing; p++)
+ ximMaskPm[p] = ximMaskPm2[p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
+ ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
+ ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
+ ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
+ ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
+ }
+#endif
+#endif
+ }
+ } else {
+ for(i=0; i<2; i++) {
+ int p;
+ for(p=0; p<=(int)WhiteKing; p++)
+ pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
+ if(gameInfo.variant == VariantShogi) {
+ pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
+ pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
+ pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
+ pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
+ pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
+ }
+#ifdef GOTHIC
+ if(gameInfo.variant == VariantGothic) {
+ pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
+ }
+#endif
+ }
+ }
+#if HAVE_LIBXPM
+ CreateAnimVars();
+#endif
+}
+#endif
+
int
main(argc, argv)
int argc;
int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
XSetWindowAttributes window_attributes;
Arg args[16];
- Dimension timerWidth, boardWidth, w, h, sep, bor, wr, hr;
+ Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
XrmValue vFrom, vTo;
XtGeometryResult gres;
char *p;
XrmDatabase xdb;
int forceMono = False;
+ srandom(time(0)); // [HGM] book: make random truly random
+
setbuf(stdout, NULL);
setbuf(stderr, NULL);
debugFP = stderr;
+# if HAVE_LIBREADLINE
+ /* install gnu-readline handler */
+ rl_callback_handler_install("> ", ReadlineCompleteHandler);
+ rl_readline_name="XBoard";
+# endif
+
+ if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
+ printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+ exit(0);
+ }
+
programName = strrchr(argv[0], '/');
if (programName == NULL)
programName = argv[0];
else
programName++;
+#ifdef ENABLE_NLS
+ XtSetLanguageProc(NULL, NULL, NULL);
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
+#endif
+
shellWidget =
XtAppInitialize(&appContext, "XBoard", shellOptions,
XtNumber(shellOptions),
&argc, argv, xboardResources, NULL, 0);
- if (argc > 1) {
- fprintf(stderr, "%s: unrecognized argument %s\n",
- programName, argv[1]);
- exit(2);
+ appData.boardSize = "";
+ InitAppData(ConvertToLine(argc, argv));
+ p = getenv("HOME");
+ if (p == NULL) p = "/tmp";
+ i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
+ gameCopyFilename = (char*) malloc(i);
+ gamePasteFilename = (char*) malloc(i);
+ snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
+ snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
+
+ XtGetApplicationResources(shellWidget, (XtPointer) &appData,
+ clientResources, XtNumber(clientResources),
+ NULL, 0);
+
+ { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
+ static char buf[MSG_SIZ];
+ EscapeExpand(buf, appData.initString);
+ appData.initString = strdup(buf);
+ EscapeExpand(buf, appData.secondInitString);
+ appData.secondInitString = strdup(buf);
+ EscapeExpand(buf, appData.firstComputerString);
+ appData.firstComputerString = strdup(buf);
+ EscapeExpand(buf, appData.secondComputerString);
+ appData.secondComputerString = strdup(buf);
}
-
+
if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
chessDir = ".";
} else {
if (chdir(chessDir) != 0) {
- fprintf(stderr, "%s: can't cd to CHESSDIR: ", programName);
+ fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
perror(chessDir);
exit(1);
}
}
-
- p = getenv("HOME");
- if (p == NULL) p = "/tmp";
- i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
- gameCopyFilename = (char*) malloc(i);
- gamePasteFilename = (char*) malloc(i);
- sprintf(gameCopyFilename, "%s/.xboard%05uc.pgn", p, getpid());
- sprintf(gamePasteFilename, "%s/.xboard%05up.pgn", p, getpid());
- XtGetApplicationResources(shellWidget, (XtPointer) &appData,
- clientResources, XtNumber(clientResources),
- NULL, 0);
+ if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
+ /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
+ if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL) {
+ printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
+ exit(errno);
+ }
+ setbuf(debugFP, NULL);
+ }
+
+ /* [HGM,HR] make sure board size is acceptable */
+ if(appData.NrFiles > BOARD_FILES ||
+ appData.NrRanks > BOARD_RANKS )
+ DisplayFatalError(_("Recompile with larger BOARD_RANKS or BOARD_FILES 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);
- /*
- * Determine boardSize
- */
+ 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,
&lineGap, &clockFontPxlSize, &coordFontPxlSize,
&fontPxlSize, &smallLayout, &tinyLayout);
if (i == 0) {
- fprintf(stderr, "%s: bad boardSize syntax %s\n",
+ fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
programName, appData.boardSize);
exit(2);
}
szd++;
}
if (szd->name == NULL) szd--;
+ appData.boardSize = strdup(szd->name); // [HGM] settings: remember name for saving settings
} else {
while (szd->name != NULL &&
StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
if (szd->name == NULL) {
- fprintf(stderr, "%s: unrecognized boardSize name %s\n",
+ fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
programName, appData.boardSize);
exit(2);
}
fontPxlSize = szd->fontPxlSize;
smallLayout = szd->smallLayout;
tinyLayout = szd->tinyLayout;
+ // [HGM] font: use defaults from settings file if available and not overruled
}
+ if(!fontSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
+ appData.clockFont = fontTable[CLOCK_FONT][squareSize];
+ if(!fontSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
+ appData.font = fontTable[MESSAGE_FONT][squareSize];
+ if(!fontSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
+ appData.coordFont = fontTable[COORD_FONT][squareSize];
/* 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",
+ fprintf(stderr, _("Error expanding path name \"%s\"\n"),
appData.pixmapDirectory);
exit(1);
}
if (appData.debugMode) {
- fprintf(stderr, "XBoard square size (hint): %d\n", squareSize);
- fprintf(stderr, "%s fulldir:%s:\n", IMAGE_EXT, p);
+ 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);
+ fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
}
}
-
- boardWidth = lineGap + BOARD_SIZE * (squareSize + lineGap);
+
+ /* [HR] height treated separately (hacked) */
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
if (appData.showJail == 1) {
/* Jail on top and bottom */
XtSetArg(boardArgs[1], XtNwidth, boardWidth);
XtSetArg(boardArgs[2], XtNheight,
- boardWidth + 2*(lineGap + squareSize));
+ boardHeight + 2*(lineGap + squareSize));
} else if (appData.showJail == 2) {
/* Jail on sides */
XtSetArg(boardArgs[1], XtNwidth,
boardWidth + 2*(lineGap + squareSize));
- XtSetArg(boardArgs[2], XtNheight, boardWidth);
+ XtSetArg(boardArgs[2], XtNheight, boardHeight);
} else {
/* No jail */
XtSetArg(boardArgs[1], XtNwidth, boardWidth);
- XtSetArg(boardArgs[2], XtNheight, boardWidth);
+ XtSetArg(boardArgs[2], XtNheight, boardHeight);
}
/*
coordFontID = XLoadFont(xDisplay, appData.coordFont);
coordFontStruct = XQueryFont(xDisplay, coordFontID);
appData.font = FindFont(appData.font, fontPxlSize);
+ countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
+ countFontStruct = XQueryFont(xDisplay, countFontID);
+// appData.font = FindFont(appData.font, fontPxlSize);
xdb = XtDatabase(xDisplay);
XrmPutStringResource(&xdb, "*font", appData.font);
}
if (forceMono) {
- fprintf(stderr, "%s: too few colors available; trying monochrome mode\n",
+ fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
programName);
+
+ if (appData.bitmapDirectory == NULL ||
+ appData.bitmapDirectory[0] == NULLCHAR)
+ appData.bitmapDirectory = DEF_BITMAP_DIR;
+ }
+
+ if (appData.lowTimeWarning && !appData.monoMode) {
+ vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
+ vFrom.size = strlen(appData.lowTimeWarningColor);
+ XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ if (vTo.addr == NULL)
+ appData.monoMode = True;
+ else
+ lowTimeWarningColor = *(Pixel *) vTo.addr;
}
if (appData.monoMode && appData.debugMode) {
- fprintf(stderr, "white pixel = 0x%lx, black pixel = 0x%lx\n",
+ fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
(unsigned long) XWhitePixel(xDisplay, xScreen),
(unsigned long) XBlackPixel(xDisplay, xScreen));
}
-
+
if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
{
if (appData.colorize) {
fprintf(stderr,
- "%s: can't parse color names; disabling colorization\n",
+ _("%s: can't parse color names; disabling colorization\n"),
programName);
}
appData.colorize = FALSE;
}
textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
textColors[ColorNone].attr = 0;
-
+
XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
-
+
/*
* widget hierarchy
*/
formArgs, XtNumber(formArgs));
XtSetArg(args[0], XtNdefaultDistance, &sep);
XtGetValues(formWidget, args, 1);
-
+
j = 0;
widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetArg(args[2], XtNright, XtChainLeft);
+ XtSetValues(menuBarWidget, args, 3);
widgetList[j++] = whiteTimerWidget =
XtCreateWidget("whiteTime", labelWidgetClass,
formWidget, timerArgs, XtNumber(timerArgs));
XtSetArg(args[0], XtNfont, clockFontStruct);
- XtSetValues(whiteTimerWidget, args, 1);
-
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainTop);
+ XtSetValues(whiteTimerWidget, args, 3);
+
widgetList[j++] = blackTimerWidget =
XtCreateWidget("blackTime", labelWidgetClass,
formWidget, timerArgs, XtNumber(timerArgs));
XtSetArg(args[0], XtNfont, clockFontStruct);
- XtSetValues(blackTimerWidget, args, 1);
-
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainTop);
+ XtSetValues(blackTimerWidget, args, 3);
+
if (appData.titleInWindow) {
- widgetList[j++] = titleWidget =
+ widgetList[j++] = titleWidget =
XtCreateWidget("title", labelWidgetClass, formWidget,
titleArgs, XtNumber(titleArgs));
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetValues(titleWidget, args, 2);
}
if (appData.showButtonBar) {
widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
+ XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
+ XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
+ XtSetArg(args[2], XtNtop, XtChainTop);
+ XtSetArg(args[3], XtNbottom, XtChainTop);
+ XtSetValues(buttonBarWidget, args, 4);
}
widgetList[j++] = messageWidget =
XtCreateWidget("message", labelWidgetClass, formWidget,
messageArgs, XtNumber(messageArgs));
-
+ XtSetArg(args[0], XtNtop, XtChainTop);
+ XtSetArg(args[1], XtNbottom, XtChainTop);
+ XtSetValues(messageWidget, args, 2);
+
widgetList[j++] = boardWidget =
XtCreateWidget("board", widgetClass, formWidget, boardArgs,
XtNumber(boardArgs));
XtManageChildren(widgetList, j);
-
+
timerWidth = (boardWidth - sep) / 2;
XtSetArg(args[0], XtNwidth, timerWidth);
XtSetValues(whiteTimerWidget, args, 1);
XtSetValues(blackTimerWidget, args, 1);
-
+
XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
XtGetValues(whiteTimerWidget, args, 2);
-
+
if (appData.showButtonBar) {
XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
}
i = 0;
XtSetArg(args[0], XtNfromVert, messageWidget);
- XtSetValues(boardWidget, args, 1);
+ XtSetArg(args[1], XtNtop, XtChainTop);
+ XtSetArg(args[2], XtNbottom, XtChainBottom);
+ XtSetArg(args[3], XtNleft, XtChainLeft);
+ XtSetArg(args[4], XtNright, XtChainRight);
+ XtSetValues(boardWidget, args, 5);
XtRealizeWidget(shellWidget);
+ if(wpMain.x > 0) {
+ XtSetArg(args[0], XtNx, wpMain.x);
+ XtSetArg(args[1], XtNy, wpMain.y);
+ XtSetValues(shellWidget, args, 2);
+ }
+
/*
* 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);
+
#define WIDTH_FUDGE 2
i = 0;
XtSetArg(args[i], XtNborderWidth, &bor); i++;
gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
if (gres != XtGeometryYes && appData.debugMode) {
- fprintf(stderr, "%s: messageWidget geometry error %d %d %d %d %d\n",
+ fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
programName, gres, w, h, wr, hr);
}
-
+
/* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
/* The size used for the child widget in layout lags one resize behind
its true size, so we resize a second time, 1 pixel smaller. Yeech! */
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",
+ 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.titleInWindow) {
i = 0;
gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
if (gres != XtGeometryYes && appData.debugMode) {
fprintf(stderr,
- "%s: titleWidget geometry error %d %d %d %d %d\n",
+ _("%s: titleWidget geometry error %d %d %d %d %d\n"),
programName, gres, w, h, wr, hr);
}
}
XawFormDoLayout(formWidget, True);
xBoardWindow = XtWindow(boardWidget);
-
- /*
+
+ // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
+ // not need to go into InitDrawingSizes().
+#endif
+
+ /*
* Create X checkmark bitmap and initialize option menu checks.
*/
ReadBitmap(&xMarkPixmap, "checkmark.bm",
if (appData.periodicUpdates) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Periodic Updates"), args, 1);
- }
+ }
if (appData.ponderNextMove) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Ponder Next Move"), args, 1);
- }
+ }
if (appData.popupExitMessage) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Popup Exit Message"), args, 1);
- }
+ }
if (appData.popupMoveErrors) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Popup Move Errors"), args, 1);
- }
+ }
if (appData.premove) {
XtSetValues(XtNameToWidget(menuBarWidget,
"menuOptions.Premove"), args, 1);
XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
args, 1);
}
- if (appData.showThinking) {
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
+ if (appData.hideThinkingFromHuman) {
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
args, 1);
}
if (appData.testLegality) {
XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
args, 1);
}
+ if (saveSettingsOnExit) {
+ XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Save Settings on Exit"),
+ args, 1);
+ }
/*
* Create an icon.
i = 0;
XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
XtSetValues(shellWidget, args, i);
-
+
/*
* Create a cursor for the board widget.
*/
window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
XChangeWindowAttributes(xDisplay, xBoardWindow,
CWCursor, &window_attributes);
-
+
/*
* Inhibit shell resizing.
*/
shellArgs[4].value = shellArgs[2].value = w;
shellArgs[5].value = shellArgs[3].value = h;
XtSetValues(shellWidget, &shellArgs[2], 4);
-
+ marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
+ marginH = h - boardHeight;
+
CatchDeleteWindow(shellWidget, "QuitProc");
CreateGCs();
CreateXIMPieces();
/* Create regular pieces */
if (!useImages) CreatePieces();
-#endif
+#endif
CreatePieceMenus();
if (appData.animate || appData.animateDragging)
CreateAnimVars();
-
+
XtAugmentTranslations(formWidget,
XtParseTranslationTable(globalTranslations));
XtAugmentTranslations(boardWidget,
/* Why is the following needed on some versions of X instead
* of a translation? */
- XtAddEventHandler(boardWidget, ExposureMask, False,
+ XtAddEventHandler(boardWidget, ExposureMask|PointerMotionMask, False,
(XtEventHandler) EventProc, NULL);
/* end why */
+ /* [AS] Restore layout */
+ if( wpMoveHistory.visible ) {
+ HistoryPopUp();
+ }
+
+ if( wpEvalGraph.visible )
+ {
+ EvalGraphPopUp();
+ };
+
+ if( wpEngineOutput.visible ) {
+ EngineOutputPopUp();
+ }
+
InitBackEnd2();
-
+
if (errorExitStatus == -1) {
if (appData.icsActive) {
/* We now wait until we see "login:" from the ICS before
if (appData.icsInputBox) ICSInputBoxPopUp();
}
+ #ifdef SIGWINCH
+ signal(SIGWINCH, TermSizeSigHandler);
+ #endif
signal(SIGINT, IntSigHandler);
signal(SIGTERM, IntSigHandler);
if (*appData.cmailGameName != NULLCHAR) {
signal(SIGUSR1, CmailSigHandler);
}
}
+ gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
+ InitPosition(TRUE);
+ XtSetKeyboardFocus(shellWidget, formWidget);
XtAppMainLoop(appContext);
+ if (appData.debugMode) fclose(debugFP); // [DM] debug
return 0;
}
if (appData.icsActive && oldICSInteractionTitle != NULL) {
DisplayIcsInteractionTitle(oldICSInteractionTitle);
}
+ if (saveSettingsOnExit) SaveSettings(settingsFileName);
unlink(gameCopyFilename);
unlink(gamePasteFilename);
+
+# if HAVE_LIBREADLINE
+ /* remove gnu-readline handler. */
+ rl_callback_handler_remove();
+#endif
+
+ return;
+}
+
+RETSIGTYPE TermSizeSigHandler(int sig)
+{
+ update_ics_width();
}
RETSIGTYPE
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
} Enables;
void
+GreyRevert(grey)
+ Boolean grey;
+{
+ Widget w;
+ if (!menuBarWidget) return;
+ w = XtNameToWidget(menuBarWidget, "menuStep.Revert");
+ if (w == NULL) {
+ DisplayError("menuStep.Revert", 0);
+ } else {
+ XtSetSensitive(w, !grey);
+ }
+ w = XtNameToWidget(menuBarWidget, "menuStep.Annotate");
+ if (w == NULL) {
+ DisplayError("menuStep.Annotate", 0);
+ } else {
+ XtSetSensitive(w, !grey);
+ }
+}
+
+void
SetMenuEnables(enab)
Enables *enab;
{
{ "menuHelp.Hint", False },
{ "menuHelp.Book", False },
{ "menuStep.Move Now", False },
- { "menuOptions.Periodic Updates", False },
- { "menuOptions.Show Thinking", False },
+ { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
{ "menuOptions.Ponder Next Move", False },
#endif
+ { "menuStep.Annotate", False },
{ NULL, False }
};
-Enables ncpEnables[] = {
+Enables ncpEnables[] = {
{ "menuFile.Mail Move", False },
{ "menuFile.Reload CMail Message", False },
{ "menuMode.Machine White", False },
{ "menuMode.ICS Input Box", False },
{ "Action", False },
{ "menuStep.Revert", False },
+ { "menuStep.Annotate", False },
{ "menuStep.Move Now", False },
{ "menuStep.Retract Move", False },
{ "menuOptions.Auto Comment", False },
{ "menuOptions.ICS Alarm", False },
{ "menuOptions.Move Sound", False },
{ "menuOptions.Quiet Play", False },
- { "menuOptions.Show Thinking", False },
- { "menuOptions.Periodic Updates", False },
+ { "menuOptions.Hide Thinking", False },
+ { "menuOptions.Periodic Updates", False },
{ "menuOptions.Ponder Next Move", False },
{ "menuHelp.Hint", False },
{ "menuHelp.Book", False },
{ NULL, False }
};
-Enables gnuEnables[] = {
+Enables gnuEnables[] = {
{ "menuMode.ICS Client", False },
{ "menuMode.ICS Input Box", False },
{ "menuAction.Accept", False },
{ "menuAction.Adjourn", False },
{ "menuAction.Stop Examining", False },
{ "menuAction.Stop Observing", False },
+ { "menuAction.Upload to Examine", False },
{ "menuStep.Revert", False },
+ { "menuStep.Annotate", False },
{ "menuOptions.Auto Comment", False },
{ "menuOptions.Auto Observe", False },
{ "menuOptions.Auto Raise Board", False },
{ NULL, False }
};
-Enables cmailEnables[] = {
+Enables cmailEnables[] = {
{ "Action", True },
{ "menuAction.Call Flag", False },
{ "menuAction.Draw", True },
{ NULL, False }
};
-Enables trainingOnEnables[] = {
+Enables trainingOnEnables[] = {
{ "menuMode.Edit Comment", False },
{ "menuMode.Pause", False },
{ "menuStep.Forward", False },
{ NULL, False }
};
-Enables trainingOffEnables[] = {
+Enables trainingOffEnables[] = {
{ "menuMode.Edit Comment", True },
{ "menuMode.Pause", True },
{ "menuStep.Forward", True },
void SetICSMode()
{
SetMenuEnables(icsEnables);
+
+#if ZIPPY
+ if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
+ XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
+#endif
}
void
}
}
+// [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 Abs(n) ((n)<0 ? -(n) : (n))
/*
* Find a font that matches "pattern" that is as close as
* possible to the targetPxlSize. Prefer fonts that are k
* pixels smaller to fonts that are k pixels larger. The
- * pattern must be in the X Consortium standard format,
+ * pattern must be in the X Consortium standard format,
* e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
* The return value should be freed with XtFree when no
* longer needed.
*/
-char *FindFont(pattern, targetPxlSize)
+char *
+FindFont(pattern, targetPxlSize)
char *pattern;
int targetPxlSize;
{
char **fonts, *p, *best, *scalable, *scalableTail;
int i, j, nfonts, minerr, err, pxlSize;
+#ifdef ENABLE_NLS
+ char **missing_list;
+ int missing_count;
+ char *def_string, *base_fnt_lst, strInt[3];
+ XFontSet fntSet;
+ XFontStruct **fnt_list;
+
+ base_fnt_lst = calloc(1, strlen(pattern) + 3);
+ 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);
+ strcat(base_fnt_lst, strchr(p + 2, '-'));
+
+ if ((fntSet = XCreateFontSet(xDisplay,
+ base_fnt_lst,
+ &missing_list,
+ &missing_count,
+ &def_string)) == NULL) {
+
+ fprintf(stderr, _("Unable to create font set.\n"));
+ exit (2);
+ }
+
+ nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
+#else
fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
if (nfonts < 1) {
- fprintf(stderr, "%s: no fonts match pattern %s\n",
+ fprintf(stderr, _("%s: no fonts match pattern %s\n"),
programName, pattern);
exit(2);
}
+#endif
+
best = fonts[0];
scalable = NULL;
minerr = 999999;
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",
+ fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
pattern, targetPxlSize, p);
}
- XFreeFontNames(fonts);
+#ifdef ENABLE_NLS
+ if (missing_count > 0)
+ XFreeStringList(missing_list);
+ XFreeFontSet(xDisplay, fntSet);
+#else
+ XFreeFontNames(fonts);
+#endif
return p;
}
| GCBackground | GCFunction | GCPlaneMask;
XGCValues gc_values;
GC copyInvertedGC;
-
+
gc_values.plane_mask = AllPlanes;
gc_values.line_width = lineGap;
gc_values.line_style = LineSolid;
gc_values.function = GXcopy;
-
+
gc_values.foreground = XBlackPixel(xDisplay, xScreen);
gc_values.background = XBlackPixel(xDisplay, xScreen);
lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = XBlackPixel(xDisplay, xScreen);
gc_values.background = XWhitePixel(xDisplay, xScreen);
coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
XSetFont(xDisplay, coordGC, coordFontID);
-
+
+ // [HGM] make font for holdings counts (white on black0
+ gc_values.foreground = XWhitePixel(xDisplay, xScreen);
+ gc_values.background = XBlackPixel(xDisplay, xScreen);
+ countGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ XSetFont(xDisplay, countGC, countFontID);
+
if (appData.monoMode) {
gc_values.foreground = XWhitePixel(xDisplay, xScreen);
gc_values.background = XWhitePixel(xDisplay, xScreen);
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = XWhitePixel(xDisplay, xScreen);
gc_values.background = XBlackPixel(xDisplay, xScreen);
- lightSquareGC = wbPieceGC
+ lightSquareGC = wbPieceGC
= XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = XBlackPixel(xDisplay, xScreen);
} else {
gc_values.foreground = highlightSquareColor;
gc_values.background = highlightSquareColor;
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = premoveHighlightColor;
gc_values.background = premoveHighlightColor;
- prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
+ prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = lightSquareColor;
gc_values.background = darkSquareColor;
lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = darkSquareColor;
gc_values.background = lightSquareColor;
darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
gc_values.foreground = whitePieceColor;
gc_values.background = darkSquareColor;
wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = whitePieceColor;
gc_values.background = lightSquareColor;
wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = whitePieceColor;
gc_values.background = jailSquareColor;
wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = blackPieceColor;
gc_values.background = darkSquareColor;
bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
-
+
gc_values.foreground = blackPieceColor;
gc_values.background = lightSquareColor;
blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
fp = fopen(filename, "rb");
if (!fp) {
- fprintf(stderr, "%s: error loading XIM!\n", programName);
+ fprintf(stderr, _("%s: error loading XIM!\n"), programName);
exit(1);
}
-
+
w = fgetc(fp);
h = fgetc(fp);
-
+
for (y=0; y<h; ++y) {
for (x=0; x<h; ++x) {
p = fgetc(fp);
switch (p) {
- case 0:
- XPutPixel(xim, x, y, blackPieceColor);
+ case 0:
+ XPutPixel(xim, x, y, blackPieceColor);
if (xmask)
XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
break;
- case 1:
- XPutPixel(xim, x, y, darkSquareColor);
+ case 1:
+ XPutPixel(xim, x, y, darkSquareColor);
if (xmask)
XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
break;
- case 2:
- XPutPixel(xim, x, y, whitePieceColor);
+ case 2:
+ XPutPixel(xim, x, y, whitePieceColor);
if (xmask)
XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
break;
- case 3:
+ case 3:
XPutPixel(xim, x, y, lightSquareColor);
if (xmask)
XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
*dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
w, h, xim->depth);
XPutImage(xDisplay, *dest, lightSquareGC, xim,
- 0, 0, 0, 0, w, h);
+ 0, 0, 0, 0, w, h);
- /* create Pixmap of clipmask
+ /* create Pixmap of clipmask
Note: We assume the white/black pieces have the same
outline, so we make only 6 masks. This is okay
since the XPM clipmask routines do the same. */
temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
w, h, xim->depth);
XPutImage(xDisplay, temp, lightSquareGC, xmask,
- 0, 0, 0, 0, w, h);
+ 0, 0, 0, 0, w, h);
/* now create the 1-bit version */
*mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
values.background = 0;
/* Don't use XtGetGC, not read only */
- maskGC = XCreateGC(xDisplay, *mask,
+ maskGC = XCreateGC(xDisplay, *mask,
GCForeground | GCBackground, &values);
- XCopyPlane(xDisplay, temp, *mask, maskGC,
+ XCopyPlane(xDisplay, temp, *mask, maskGC,
0, 0, squareSize, squareSize, 0, 0, 1);
XFreePixmap(xDisplay, temp);
}
}
+
+char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
+
void CreateXIMPieces()
{
int piece, kind;
Not sure if needed, but can't hurt */
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
-
+
/* temp needed by loadXIM() */
ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
} else {
useImages = 1;
if (appData.monoMode) {
- DisplayFatalError("XIM pieces cannot be used in monochrome mode",
+ DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
0, 2);
ExitEvent(2);
}
- fprintf(stderr, "\nLoading XIMs...\n");
+ fprintf(stderr, _("\nLoading XIMs...\n"));
/* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
fprintf(stderr, "%d", piece+1);
for (kind=0; kind<4; kind++) {
fprintf(stderr, ".");
- sprintf(buf, "%s/%c%s%u.xim",
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
ExpandPathName(appData.pixmapDirectory),
- ToLower(PieceToChar((ChessSquare)piece)),
+ piece <= (int) WhiteKing ? "" : "w",
+ pieceBitmapNames[piece],
ximkind[kind], ss);
ximPieceBitmap[kind][piece] =
XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
if (appData.debugMode)
- fprintf(stderr, "(File:%s:) ", buf);
- loadXIM(ximPieceBitmap[kind][piece],
+ fprintf(stderr, _("(File:%s:) "), buf);
+ loadXIM(ximPieceBitmap[kind][piece],
ximtemp, buf,
- &(xpmPieceBitmap[kind][piece]),
- &(ximMaskPm[piece%6]));
+ &(xpmPieceBitmap2[kind][piece]),
+ &(ximMaskPm2[piece]));
+ if(piece <= (int)WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
}
fprintf(stderr," ");
}
/* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
+ /* If the LSQ and DSQ pieces don't exist, we will
draw them with solid squares. */
- sprintf(buf, "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
+ snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
if (access(buf, 0) != 0) {
useImageSqs = 0;
} else {
useImageSqs = 1;
- fprintf(stderr, "light square ");
- ximLightSquare=
+ fprintf(stderr, _("light square "));
+ ximLightSquare=
XGetImage(xDisplay, DefaultRootWindow(xDisplay),
0, 0, ss, ss, AllPlanes, XYPixmap);
if (appData.debugMode)
- fprintf(stderr, "(File:%s:) ", buf);
+ fprintf(stderr, _("(File:%s:) "), buf);
loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
- fprintf(stderr, "dark square ");
- sprintf(buf, "%s/dsq%u.xim",
+ 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=
+ 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");
+ fprintf(stderr, _("Done.\n"));
}
XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
}
static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
XpmColorSymbol symbols[4];
-#if 0
- /* Apparently some versions of Xpm don't define XpmFormat at all --tpm */
- if (appData.debugMode) {
- fprintf(stderr, "XPM Library Version: %d.%d%c\n",
- XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));
- }
-#endif
-
/* The XSynchronize calls were copied from CreatePieces.
Not sure if needed, but can't hurt */
XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
-
+
/* Setup translations so piece colors match square colors */
symbols[0].name = "light_piece";
symbols[0].value = appData.whitePieceColor;
attr.numsymbols = 4;
if (appData.monoMode) {
- DisplayFatalError("XPM pieces cannot be used in monochrome mode",
+ DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
0, 2);
ExitEvent(2);
}
/* Load pieces */
while (pieces->size != squareSize && pieces->size) pieces++;
if (!pieces->size) {
- fprintf(stderr, "No builtin XPM pieces of size %d\n", squareSize);
+ fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
exit(1);
}
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
for (kind=0; kind<4; kind++) {
if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
pieces->xpm[piece][kind],
- &(xpmPieceBitmap[kind][piece]),
+ &(xpmPieceBitmap2[kind][piece]),
NULL, &attr)) != 0) {
- fprintf(stderr, "Error %d loading XPM image \"%s\"\n",
+ fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
r, buf);
- exit(1);
- }
- }
+ exit(1);
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
}
useImageSqs = 0;
xpmJailSquare = xpmLightSquare;
} else {
useImages = 1;
-
- fprintf(stderr, "\nLoading XPMs...\n");
+
+ fprintf(stderr, _("\nLoading XPMs...\n"));
/* Load pieces */
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
fprintf(stderr, "%d ", piece+1);
for (kind=0; kind<4; kind++) {
- sprintf(buf, "%s/%c%s%u.xpm",
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
ExpandPathName(appData.pixmapDirectory),
- ToLower(PieceToChar((ChessSquare)piece)),
+ piece > (int) WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
xpmkind[kind], ss);
if (appData.debugMode) {
- fprintf(stderr, "(File:%s:) ", buf);
+ fprintf(stderr, _("(File:%s:) "), buf);
}
if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
- &(xpmPieceBitmap[kind][piece]),
+ &(xpmPieceBitmap2[kind][piece]),
NULL, &attr)) != 0) {
- fprintf(stderr, "Error %d loading XPM file \"%s\"\n",
- r, buf);
- exit(1);
- }
- }
+ if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
+ // [HGM] missing: read of unorthodox piece failed; substitute King.
+ snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
+ ExpandPathName(appData.pixmapDirectory),
+ xpmkind[kind], ss);
+ if (appData.debugMode) {
+ fprintf(stderr, _("(Replace by File:%s:) "), buf);
+ }
+ r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &(xpmPieceBitmap2[kind][piece]),
+ NULL, &attr);
+ }
+ if (r != 0) {
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
+ r, buf);
+ exit(1);
+ }
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
}
/* Load light and dark squares */
- /* If the LSQ and DSQ pieces don't exist, we will
+ /* If the LSQ and DSQ pieces don't exist, we will
draw them with solid squares. */
- fprintf(stderr, "light square ");
- sprintf(buf, "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
+ 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);
+ 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);
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
exit(1);
}
- fprintf(stderr, "dark square ");
- sprintf(buf, "%s/dsq%u.xpm",
+ fprintf(stderr, _("dark square "));
+ snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
ExpandPathName(appData.pixmapDirectory), ss);
if (appData.debugMode) {
- fprintf(stderr, "(File:%s:) ", buf);
+ 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);
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
exit(1);
}
}
xpmJailSquare = xpmLightSquare;
- fprintf(stderr, "Done.\n");
+ fprintf(stderr, _("Done.\n"));
}
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
- buffering bug */
+ buffering bug */
}
#endif /* HAVE_LIBXPM */
int piece, kind;
char buf[MSG_SIZ];
u_int ss = squareSize;
-
+
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; 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];
}
}
-
+
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
buffering bug */
}
int piece, kind;
char buf[MSG_SIZ];
u_int ss = squareSize;
-
+
XSynchronize(xDisplay, True); /* Work-around for xlib/xt
buffering bug */
while (bib->squareSize != ss && bib->squareSize != 0) bib++;
for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
- ss, kind == SOLID ? 's' : 'o');
- ReadBitmap(&pieceBitmap[kind][piece], buf,
- bib->bits[kind][piece], ss, ss);
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; 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];
}
}
-
+
XSynchronize(xDisplay, False); /* Work-around for xlib/xt
buffering bug */
}
u_int w, h;
int errcode;
char msg[MSG_SIZ], fullname[MSG_SIZ];
-
+
if (*appData.bitmapDirectory != NULLCHAR) {
- strcpy(fullname, appData.bitmapDirectory);
- strcat(fullname, "/");
- strcat(fullname, name);
- errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
- &w, &h, pm, &x_hot, &y_hot);
+ 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:
- sprintf(msg, "Can't open bitmap file %s", fullname);
+ snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
break;
case BitmapFileInvalid:
- sprintf(msg, "Invalid bitmap in file %s", fullname);
+ snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
break;
case BitmapNoMemory:
- sprintf(msg, "Ran out of memory reading bitmap file %s",
+ snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
fullname);
break;
default:
- sprintf(msg, "Unknown XReadBitmapFile error %d on file %s",
+ snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
errcode, fullname);
break;
}
- fprintf(stderr, "%s: %s...using built-in\n",
+ 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",
+ _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
programName, fullname, w, h, wreq, hreq);
} else {
return;
}
}
- if (bits == NULL) {
- fprintf(stderr, "%s: No built-in bitmap for %s; giving up\n",
- programName, name);
- exit(1);
- } else {
+ if (bits != NULL) {
*pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
wreq, hreq);
}
void CreateGrid()
{
- int i;
-
+ int i, j;
+
if (lineGap == 0) return;
- for (i = 0; i < BOARD_SIZE + 1; i++) {
- gridSegments[i].x1 = 0;
- gridSegments[i].x2 =
- lineGap + BOARD_SIZE * (squareSize + lineGap);
- gridSegments[i].y1 = gridSegments[i].y2
- = lineGap / 2 + (i * (squareSize + lineGap));
- gridSegments[i + BOARD_SIZE + 1].y1 = 0;
- gridSegments[i + BOARD_SIZE + 1].y2 =
- BOARD_SIZE * (squareSize + lineGap);
- gridSegments[i + BOARD_SIZE + 1].x1 =
- gridSegments[i + BOARD_SIZE + 1].x2
- = lineGap / 2 + (i * (squareSize + lineGap));
+ /* [HR] Split this into 2 loops for non-square boards. */
+
+ for (i = 0; i < BOARD_HEIGHT + 1; i++) {
+ gridSegments[i].x1 = 0;
+ gridSegments[i].x2 =
+ lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ gridSegments[i].y1 = gridSegments[i].y2
+ = lineGap / 2 + (i * (squareSize + lineGap));
+ }
+
+ for (j = 0; j < BOARD_WIDTH + 1; j++) {
+ gridSegments[j + i].y1 = 0;
+ gridSegments[j + i].y2 =
+ lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ gridSegments[j + i].x1 = gridSegments[j + i].x2
+ = lineGap / 2 + (j * (squareSize + lineGap));
}
}
entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
menu, args, j);
} else {
+ XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
- menu, args, j);
+ menu, args, j+1);
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) MenuBarSelect,
(caddr_t) mi->proc);
}
mi++;
}
-}
+}
Widget CreateMenuBar(mb)
Menu *mb;
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->name, 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], XtNborderWidth, 0); j++;
anchor = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,
menuBar, args, j);
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,
mi++;
}
return buttonBar;
-}
+}
Widget
CreatePieceMenu(name, color)
menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
boardWidget, args, 0);
-
+
for (i = 0; i < PIECE_MENU_SIZE; i++) {
String item = pieceMenuStrings[color][i];
-
+
if (strcmp(item, "----") == 0) {
entry = XtCreateManagedWidget(item, smeLineObjectClass,
menu, NULL, 0);
} else {
+ XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
entry = XtCreateManagedWidget(item, smeBSBObjectClass,
- menu, NULL, 0);
+ menu, args, 1);
selection = pieceMenuTranslation[color][i];
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) PieceMenuSelect,
whitePieceMenu = CreatePieceMenu("menuW", 0);
blackPieceMenu = CreatePieceMenu("menuB", 1);
-
+
XtRegisterGrabAction(PieceMenuPopup, True,
(unsigned)(ButtonPressMask|ButtonReleaseMask),
GrabModeAsync, GrabModeAsync);
- XtSetArg(args[0], XtNlabel, "Drop");
+ 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, NULL, 0);
+ dropMenu, args, 1);
selection = dropMenuTranslation[i];
XtAddCallback(entry, XtNcallback,
(XtCallbackProc) DropMenuSelect,
(caddr_t) selection);
}
}
-}
+}
void SetupDropMenu()
{
&& !appData.icsActive));
count = 0;
while (p && *p++ == dmEnables[i].piece) count++;
- sprintf(label, "%s %d", dmEnables[i].widget, count);
+ snprintf(label, sizeof(label), "%s %d", dmEnables[i].widget, count);
j = 0;
XtSetArg(args[j], XtNlabel, label); j++;
XtSetValues(entry, args, j);
String *params;
Cardinal *num_params;
{
- String whichMenu;
- if (event->type != ButtonPress) return;
- if (errorUp) ErrorPopDown();
- switch (gameMode) {
- case EditPosition:
- case IcsExamining:
- whichMenu = params[0];
- break;
- case IcsPlayingWhite:
- case IcsPlayingBlack:
- case EditGame:
- case MachinePlaysWhite:
- case MachinePlaysBlack:
- if (appData.testLegality &&
- gameInfo.variant != VariantBughouse &&
- gameInfo.variant != VariantCrazyhouse) return;
- SetupDropMenu();
- whichMenu = "menuD";
- break;
- default:
- return;
+ String whichMenu; int menuNr;
+ if (event->type == ButtonRelease)
+ 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) {
+ case 0: whichMenu = params[0]; break;
+ case 1: SetupDropMenu(); whichMenu = "menuD"; break;
+ case 2:
+ case -1: if (errorUp) ErrorPopDown();
+ default: return;
}
-
- if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_SIZE)) < 0) ||
- ((pmFromY = EventToSquare(event->xbutton.y, BOARD_SIZE)) < 0)) {
- pmFromX = pmFromY = -1;
- return;
- }
- if (flipView)
- pmFromX = BOARD_SIZE - 1 - pmFromX;
- else
- pmFromY = BOARD_SIZE - 1 - pmFromY;
-
XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
}
int EventToSquare(x, limit)
int x;
{
- if (x <= 0)
+ if (x <= 0)
return -2;
if (x < lineGap)
return -1;
int x, y;
if (lineGap == 0 || appData.blindfold) return;
-
+
if (flipView) {
- x = lineGap/2 + ((BOARD_SIZE-1)-file) *
+ x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
(squareSize + lineGap);
y = lineGap/2 + rank * (squareSize + lineGap);
} else {
x = lineGap/2 + file * (squareSize + lineGap);
- y = lineGap/2 + ((BOARD_SIZE-1)-rank) *
+ y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
(squareSize + lineGap);
}
-
+
XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
squareSize+lineGap, squareSize+lineGap);
}
if (hi1X >= 0 && hi1Y >= 0) {
drawHighlight(hi1X, hi1Y, lineGC);
}
+ } // [HGM] first erase both, then draw new!
+ if (hi2X != toX || hi2Y != toY) {
+ if (hi2X >= 0 && hi2Y >= 0) {
+ drawHighlight(hi2X, hi2Y, lineGC);
+ }
+ }
+ if (hi1X != fromX || hi1Y != fromY) {
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);
}
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),
}
break;
}
+ if(appData.upsideDown && flipView) kind ^= 2; // swap white and black pieces
XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, wlPieceGC, 0, 0,
- squareSize, squareSize, x, y);
+ squareSize, squareSize, x, y);
}
typedef void (*DrawFunc)();
}
}
+/* [HR] determine square color depending on chess variant. */
+static int SquareColor(row, column)
+ int row, column;
+{
+ int square_color;
+
+ if (gameInfo.variant == VariantXiangqi) {
+ if (column >= 3 && column <= 5 && row >= 0 && row <= 2) {
+ square_color = 1;
+ } else if (column >= 3 && column <= 5 && row >= 7 && row <= 9) {
+ square_color = 0;
+ } else if (row <= 4) {
+ square_color = 0;
+ } else {
+ square_color = 1;
+ }
+ } else {
+ square_color = ((column + row) % 2) == 1;
+ }
+
+ /* [hgm] holdings: next line makes all holdings squares light */
+ if(column < BOARD_LEFT || column >= BOARD_RGHT) square_color = 1;
+
+ return square_color;
+}
+
void DrawSquare(row, column, piece, do_flash)
int row, column, do_flash;
ChessSquare piece;
/* Calculate delay in milliseconds (2-delays per complete flash) */
flash_delay = 500 / appData.flashRate;
-
+
if (flipView) {
- x = lineGap + ((BOARD_SIZE-1)-column) *
+ x = lineGap + ((BOARD_WIDTH-1)-column) *
(squareSize + lineGap);
y = lineGap + row * (squareSize + lineGap);
} else {
x = lineGap + column * (squareSize + lineGap);
- y = lineGap + ((BOARD_SIZE-1)-row) *
+ y = lineGap + ((BOARD_HEIGHT-1)-row) *
(squareSize + lineGap);
}
-
- square_color = ((column + row) % 2) == 1;
-
- if (piece == EmptySquare || appData.blindfold) {
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- } else {
- drawfunc = ChooseDrawFunc();
- if (do_flash && appData.flashCount > 0) {
- for (i=0; i<appData.flashCount; ++i) {
-
- drawfunc(piece, square_color, x, y, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
- BlankSquare(x, y, square_color, piece, xBoardWindow);
- XSync(xDisplay, False);
- do_flash_delay(flash_delay);
- }
+ if(twoBoards && partnerUp) x += hOffset; // [HGM] dual: draw second board
+
+ square_color = SquareColor(row, column);
+
+ if ( // [HGM] holdings: blank out area between board and holdings
+ column == BOARD_LEFT-1 || column == BOARD_RGHT
+ || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
+ || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
+ BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
+
+ // [HGM] print piece counts next to holdings
+ string[1] = NULLCHAR;
+ if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
+ string[0] = '0' + piece;
+ XTextExtents(countFontStruct, string, 1, &direction,
+ &font_ascent, &font_descent, &overall);
+ if (appData.monoMode) {
+ XDrawImageString(xDisplay, xBoardWindow, countGC,
+ x + squareSize - overall.width - 2,
+ y + font_ascent + 1, string, 1);
+ } else {
+ XDrawString(xDisplay, xBoardWindow, countGC,
+ x + squareSize - overall.width - 2,
+ y + font_ascent + 1, string, 1);
+ }
+ }
+ if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
+ string[0] = '0' + piece;
+ XTextExtents(countFontStruct, string, 1, &direction,
+ &font_ascent, &font_descent, &overall);
+ if (appData.monoMode) {
+ XDrawImageString(xDisplay, xBoardWindow, countGC,
+ x + 2, y + font_ascent + 1, string, 1);
+ } else {
+ XDrawString(xDisplay, xBoardWindow, countGC,
+ x + 2, y + font_ascent + 1, string, 1);
+ }
+ }
+ } else {
+ if (piece == EmptySquare || appData.blindfold) {
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ } else {
+ drawfunc = ChooseDrawFunc();
+ if (do_flash && appData.flashCount > 0) {
+ for (i=0; i<appData.flashCount; ++i) {
+
+ drawfunc(piece, square_color, x, y, xBoardWindow);
+ XSync(xDisplay, False);
+ do_flash_delay(flash_delay);
+
+ BlankSquare(x, y, square_color, piece, xBoardWindow);
+ XSync(xDisplay, False);
+ do_flash_delay(flash_delay);
+ }
+ }
+ drawfunc(piece, square_color, x, y, xBoardWindow);
+ }
}
- drawfunc(piece, square_color, x, y, xBoardWindow);
- }
-
+
string[1] = NULLCHAR;
- if (appData.showCoords && row == (flipView ? 7 : 0)) {
- string[0] = 'a' + column;
- XTextExtents(coordFontStruct, string, 1, &direction,
+ if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
+ && column >= BOARD_LEFT && column < BOARD_RGHT) {
+ string[0] = 'a' + column - BOARD_LEFT;
+ XTextExtents(coordFontStruct, string, 1, &direction,
&font_ascent, &font_descent, &overall);
if (appData.monoMode) {
XDrawImageString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
+ x + squareSize - overall.width - 2,
y + squareSize - font_descent - 1, string, 1);
} else {
XDrawString(xDisplay, xBoardWindow, coordGC,
- x + squareSize - overall.width - 2,
+ x + squareSize - overall.width - 2,
y + squareSize - font_descent - 1, string, 1);
}
}
- if (appData.showCoords && column == (flipView ? 7 : 0)) {
- string[0] = '1' + row;
- XTextExtents(coordFontStruct, string, 1, &direction,
+ if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
+ string[0] = ONE + row;
+ XTextExtents(coordFontStruct, string, 1, &direction,
&font_ascent, &font_descent, &overall);
if (appData.monoMode) {
XDrawImageString(xDisplay, xBoardWindow, coordGC,
} else {
XDrawString(xDisplay, xBoardWindow, coordGC,
x + 2, y + font_ascent + 1, string, 1);
- }
- }
+ }
+ }
+ if(!partnerUp && marker[row][column]) {
+ XFillArc(xDisplay, xBoardWindow, marker[row][column] == 2 ? prelineGC : highlineGC,
+ x + squareSize/4, y+squareSize/4, squareSize/2, squareSize/2, 0, 64*360);
+ }
}
case Expose:
if (event->xexpose.count > 0) return; /* no clipping is done */
XDrawPosition(widget, True, NULL);
+ if(twoBoards) { // [HGM] dual: draw other board in other orientation
+ flipView = !flipView; partnerUp = !partnerUp;
+ XDrawPosition(widget, True, NULL);
+ flipView = !flipView; partnerUp = !partnerUp;
+ }
break;
+ case MotionNotify:
+ if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;\r
default:
return;
}
{
int i, j;
int c = 0;
-
- for (i=0; i<BOARD_SIZE; ++i) {
- for (j=0; j<BOARD_SIZE; ++j) {
+
+ for (i=0; i<BOARD_HEIGHT; ++i) {
+ for (j=0; j<BOARD_WIDTH; ++j) {
if (b1[i][j] != b2[i][j]) {
if (++c > 4) /* Castling causes 4 diffs */
return 1;
/* Checks whether castling occurred. If it did, *rrow and *rcol
are set to the destination (row,col) of the rook that moved.
-
+
Returns 1 if castling occurred, 0 if not.
-
+
Note: Only handles a max of 1 castling move, so be sure
to call too_many_diffs() first.
*/
return 0;
}
-static int damage[BOARD_SIZE][BOARD_SIZE];
+// [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);
+}
+
+void DrawSeekBackground( int left, int top, int right, int bottom )
+{
+ XFillRectangle(xDisplay, xBoardWindow, lightSquareGC, left, top, right-left, bottom-top);
+}
+
+void DrawSeekText(char *buf, int x, int y)
+{
+ XDrawString(xDisplay, xBoardWindow, coordGC, x, y+4, buf, strlen(buf));
+}
+
+void DrawSeekDot(int x, int y, int colorNr)
+{
+ int square = colorNr & 0x80;
+ GC color;
+ colorNr &= 0x7F;
+ color = colorNr == 0 ? prelineGC : colorNr == 1 ? darkSquareGC : highlineGC;
+ if(square)
+ XFillRectangle(xDisplay, xBoardWindow, color,
+ x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
+ else
+ XFillArc(xDisplay, xBoardWindow, color,
+ x-squareSize/8, y-squareSize/8, squareSize/4, squareSize/4, 0, 64*360);
+}
+
+static int damage[2][BOARD_RANKS][BOARD_FILES];
/*
* event handler for redrawing the board
{
int i, j, do_flash;
static int lastFlipView = 0;
- static int lastBoardValid = 0;
- static Board lastBoard;
+ static int lastBoardValid[2] = {0, 0};
+ static Board lastBoard[2];
Arg args[16];
int rrow, rcol;
-
+ int nr = twoBoards*partnerUp;
+
+ if(DrawSeekGraph()) return; // [HGM] seekgraph: suppress any drawing if seek graph up
+
if (board == NULL) {
- if (!lastBoardValid) return;
- board = lastBoard;
+ if (!lastBoardValid[nr]) return;
+ board = lastBoard[nr];
}
- if (!lastBoardValid || lastFlipView != flipView) {
+ if (!lastBoardValid[nr] || (nr == 0 && 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 (!repaint && lastBoardValid && lastFlipView == flipView) {
+
+ if (!repaint && lastBoardValid[nr] && (nr == 1 || lastFlipView == flipView)) {
/* If too much changes (begin observing new game, etc.), don't
do flashing */
- do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
+ do_flash = too_many_diffs(board, lastBoard[nr]) ? 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)) {
+ if (check_castle_draw(board, lastBoard[nr], &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];
+ lastBoard[nr][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
+ /* First pass -- Draw (newly) empty squares and repair damage.
+ This prevents you from having a piece show up twice while it
is flashing on its new square */
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++)
- if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
- || damage[i][j]) {
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ if ((board[i][j] != lastBoard[nr][i][j] && board[i][j] == EmptySquare)
+ || damage[nr][i][j]) {
DrawSquare(i, j, board[i][j], 0);
- damage[i][j] = False;
+ damage[nr][i][j] = False;
}
/* Second pass -- Draw piece(s) in new position and flash them */
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++)
- if (board[i][j] != lastBoard[i][j]) {
- DrawSquare(i, j, board[i][j], do_flash);
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++)
+ if (board[i][j] != lastBoard[nr][i][j]) {
+ DrawSquare(i, j, board[i][j], do_flash);
}
} else {
if (lineGap > 0)
XDrawSegments(xDisplay, xBoardWindow, lineGC,
- gridSegments, (BOARD_SIZE + 1) * 2);
-
- for (i = 0; i < BOARD_SIZE; i++)
- for (j = 0; j < BOARD_SIZE; j++) {
+ twoBoards & partnerUp ? secondSegments : // [HGM] dual
+ gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
+
+ for (i = 0; i < BOARD_HEIGHT; i++)
+ for (j = 0; j < BOARD_WIDTH; j++) {
DrawSquare(i, j, board[i][j], 0);
- damage[i][j] = False;
+ damage[nr][i][j] = False;
}
}
- CopyBoard(lastBoard, board);
- lastBoardValid = 1;
+ CopyBoard(lastBoard[nr], board);
+ lastBoardValid[nr] = 1;
+ if(nr == 0) { // [HGM] dual: no highlights on second board yet
lastFlipView = flipView;
/* Draw highlights */
if (hi2X >= 0 && hi2Y >= 0) {
drawHighlight(hi2X, hi2Y, highlineGC);
}
-
+ }
/* If piece being dragged around board, must redraw that too */
DrawDragPiece();
/*
* event handler for parsing user moves
*/
+// [HGM] This routine will need quite some reworking. Although the backend still supports the old
+// way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform
+// it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it
+// should be made to use the new way, of calling UserMoveTest early to determine the legality of the
+// move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),
+// and at the end FinishMove() to perform the move after optional promotion popups.
+// For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.
void HandleUserMove(w, event, prms, nprms)
Widget w;
XEvent *event;
String *prms;
Cardinal *nprms;
{
- int x, y;
- Boolean saveAnimate;
- static int second = 0;
-
if (w != boardWidget || errorExitStatus != -1) return;
-
- if (event->type == ButtonPress) ErrorPopDown();
+ if(nprms) shiftKey = !strcmp(prms[0], "1");
if (promotionUp) {
if (event->type == ButtonPress) {
return;
}
}
-
- x = EventToSquare(event->xbutton.x, BOARD_SIZE);
- y = EventToSquare(event->xbutton.y, BOARD_SIZE);
- if (!flipView && y >= 0) {
- y = BOARD_SIZE - 1 - y;
- }
- if (flipView && x >= 0) {
- x = BOARD_SIZE - 1 - x;
- }
-
- if (fromX == -1) {
- if (event->type == ButtonPress) {
- /* First square */
- if (OKToStartUserMove(x, y)) {
- fromX = x;
- fromY = y;
- second = 0;
- DragPieceBegin(event->xbutton.x, event->xbutton.y);
- if (appData.highlightDragging) {
- SetHighlights(x, y, -1, -1);
- }
- }
- }
- return;
- }
-
- /* fromX != -1 */
- if (event->type == ButtonPress && gameMode != EditPosition &&
- x >= 0 && y >= 0) {
- ChessSquare fromP;
- ChessSquare toP;
- /* Check if clicking again on the same color piece */
- fromP = boards[currentMove][fromY][fromX];
- toP = boards[currentMove][y][x];
- if ((WhitePawn <= fromP && fromP <= WhiteKing &&
- WhitePawn <= toP && toP <= WhiteKing) ||
- (BlackPawn <= fromP && fromP <= BlackKing &&
- BlackPawn <= toP && toP <= BlackKing)) {
- /* Clicked again on same color piece -- changed his mind */
- second = (x == fromX && y == fromY);
- if (appData.highlightDragging) {
- SetHighlights(x, y, -1, -1);
- } else {
- ClearHighlights();
- }
- if (OKToStartUserMove(x, y)) {
- fromX = x;
- fromY = y;
- DragPieceBegin(event->xbutton.x, event->xbutton.y);
- }
- return;
- }
- }
- if (event->type == ButtonRelease && x == fromX && y == fromY) {
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- if (appData.animateDragging) {
- /* Undo animation damage if any */
- DrawPosition(FALSE, NULL);
- }
- if (second) {
- /* Second up/down in same square; just abort move */
- second = 0;
- fromX = fromY = -1;
- ClearHighlights();
- gotPremove = 0;
- ClearPremoveHighlights();
- } else {
- /* First upclick in same square; start click-click mode */
- SetHighlights(x, y, -1, -1);
- }
- return;
- }
-
- /* Completed move */
- toX = x;
- toY = y;
- saveAnimate = appData.animate;
- if (event->type == ButtonPress) {
- /* Finish clickclick move */
- if (appData.animate || appData.highlightLastMove) {
- SetHighlights(fromX, fromY, toX, toY);
- } else {
- ClearHighlights();
- }
- } else {
- /* Finish drag move */
- if (appData.highlightLastMove) {
- SetHighlights(fromX, fromY, toX, toY);
- } else {
- ClearHighlights();
- }
- DragPieceEnd(event->xbutton.x, event->xbutton.y);
- /* Don't animate move and drag both */
- appData.animate = FALSE;
- }
- if (IsPromotion(fromX, fromY, toX, toY)) {
- if (appData.alwaysPromoteToQueen) {
- UserMoveEvent(fromX, fromY, toX, toY, 'q');
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
- fromX = fromY = -1;
- } else {
- SetHighlights(fromX, fromY, toX, toY);
- PromotionPopUp();
- }
- } else {
- UserMoveEvent(fromX, fromY, toX, toY, NULLCHAR);
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
- fromX = fromY = -1;
- }
- appData.animate = saveAnimate;
- if (appData.animate || appData.animateDragging) {
- /* Undo animation damage if needed */
- DrawPosition(FALSE, NULL);
- }
+ // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
+ if(event->type == ButtonPress) LeftClick(Press, event->xbutton.x, event->xbutton.y);
+ if(event->type == ButtonRelease) LeftClick(Release, event->xbutton.x, event->xbutton.y);
}
void AnimateUserMove (Widget w, XEvent * event,
DragPieceMove(event->xmotion.x, event->xmotion.y);
}
+void HandlePV (Widget w, XEvent * event,
+ String * params, Cardinal * nParams)
+{ // [HGM] pv: walk PV
+ MovePV(event->xmotion.x, event->xmotion.y, lineGap + BOARD_HEIGHT * (squareSize + lineGap));
+}
+
Widget CommentCreate(name, text, mutable, callback, lines)
char *name, *text;
int /*Boolean*/ mutable;
XtSetArg(args[j], XtNright, XtChainRight); j++;
XtSetArg(args[j], XtNresizable, True); j++;
XtSetArg(args[j], XtNwidth, bw_width); j++; /*force wider than buttons*/
-#if 0
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded); j++;
-#else
/* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;
-#endif
XtSetArg(args[j], XtNautoFill, True); j++;
XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
edit =
XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);
+ XtOverrideTranslations(edit, XtParseTranslationTable(commentTranslations));
if (mutable) {
j = 0;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainLeft); j++;
b_ok =
- XtCreateManagedWidget("ok", commandWidgetClass, form, args, j);
+ XtCreateManagedWidget(_("ok"), commandWidgetClass, form, args, j);
XtAddCallback(b_ok, XtNcallback, callback, (XtPointer) 0);
j = 0;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainLeft); j++;
b_cancel =
- XtCreateManagedWidget("cancel", commandWidgetClass, form, args, j);
+ XtCreateManagedWidget(_("cancel"), commandWidgetClass, form, args, j);
XtAddCallback(b_cancel, XtNcallback, callback, (XtPointer) 0);
j = 0;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainLeft); j++;
b_clear =
- XtCreateManagedWidget("clear", commandWidgetClass, form, args, j);
+ XtCreateManagedWidget(_("clear"), commandWidgetClass, form, args, j);
XtAddCallback(b_clear, XtNcallback, callback, (XtPointer) 0);
} else {
j = 0;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainLeft); j++;
b_close =
- XtCreateManagedWidget("close", commandWidgetClass, form, args, j);
+ XtCreateManagedWidget(_("close"), commandWidgetClass, form, args, j);
XtAddCallback(b_close, XtNcallback, callback, (XtPointer) 0);
j = 0;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainLeft); j++;
b_edit =
- XtCreateManagedWidget("edit", commandWidgetClass, form, args, j);
+ XtCreateManagedWidget(_("edit"), commandWidgetClass, form, args, j);
XtAddCallback(b_edit, XtNcallback, callback, (XtPointer) 0);
}
#endif /*!NOTDEF*/
if (commentY < 0) commentY = 0; /*avoid positioning top offscreen*/
}
+
+ if(wpComment.width > 0) {
+ commentX = wpComment.x;
+ commentY = wpComment.y;
+ commentW = wpComment.width;
+ commentH = wpComment.height;
+ }
+
j = 0;
XtSetArg(args[j], XtNheight, commentH); j++;
XtSetArg(args[j], XtNwidth, commentW); j++;
XtSetArg(args[j], XtNleft, XtChainLeft); j++;
XtSetArg(args[j], XtNright, XtChainRight); j++;
XtSetArg(args[j], XtNresizable, True); j++;
-#if 0
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded); j++;
-#else
/* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;
-#endif
XtSetArg(args[j], XtNautoFill, True); j++;
XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
edit =
static int savedIndex; /* gross that this is global */
+void CommentClick (Widget w, XEvent * event, String * params, Cardinal * nParams)
+{
+ String val;
+ XawTextPosition index, dummy;
+ Arg arg;
+
+ XawTextGetSelectionPos(w, &index, &dummy);
+ XtSetArg(arg, XtNstring, &val);
+ XtGetValues(w, &arg, 1);
+ ReplaceComment(savedIndex, val);
+ if(savedIndex != currentMove) ToNrEvent(savedIndex);
+ LoadVariation( index, val ); // [HGM] also does the actual moving to it, now
+}
+
void EditCommentPopUp(index, title, text)
int index;
char *title, *text;
if (editShell == NULL) {
editShell =
- CommentCreate(title, text, True, EditCommentCallback, 4);
+ CommentCreate(title, text, True, EditCommentCallback, 4);
XtRealizeWidget(editShell);
CatchDeleteWindow(editShell, "EditCommentPopDown");
} else {
XtSetArg(args[j], XtNlabel, &name); j++;
XtGetValues(w, args, j);
- if (strcmp(name, "ok") == 0) {
+ if (strcmp(name, _("ok")) == 0) {
edit = XtNameToWidget(editShell, "*form.text");
j = 0;
XtSetArg(args[j], XtNstring, &val); j++;
XtGetValues(edit, args, j);
ReplaceComment(savedIndex, val);
EditCommentPopDown();
- } else if (strcmp(name, "cancel") == 0) {
+ } else if (strcmp(name, _("cancel")) == 0) {
EditCommentPopDown();
- } else if (strcmp(name, "clear") == 0) {
+ } else if (strcmp(name, _("clear")) == 0) {
edit = XtNameToWidget(editShell, "*form.text");
XtCallActionProc(edit, "select-all", NULL, NULL, 0);
XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
Widget edit;
Arg args[16];
int j;
- char *title = "ICS Input";
+ char *title = _("ICS Input");
XtTranslations tr;
-
+
if (ICSInputShell == NULL) {
ICSInputShell = MiscCreate(title, "", True, NULL, 1);
tr = XtParseTranslationTable(ICSInputTranslations);
XtOverrideTranslations(edit, tr);
XtRealizeWidget(ICSInputShell);
CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
-
+
} else {
edit = XtNameToWidget(ICSInputShell, "*form.text");
j = 0;
int j;
Arg args[16];
String val;
-
+
edit = XtNameToWidget(ICSInputShell, "*form.text");
j = 0;
XtSetArg(args[j], XtNstring, &val); j++;
XtGetValues(edit, args, j);
+ SaveInHistory(val);
SendMultiLineToICS(val);
XtCallActionProc(edit, "select-all", NULL, NULL, 0);
XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
int j;
Widget edit;
+ savedIndex = currentMove; // [HGM] vari
if (commentShell == NULL) {
commentShell =
CommentCreate(title, text, False, CommentCallback, 4);
commentUp = True;
}
-void AnalysisPopUp(title, text)
- char *title, *text;
-{
- Arg args[16];
- int j;
- Widget edit;
-
- if (analysisShell == NULL) {
- analysisShell = MiscCreate(title, text, False, NULL, 4);
- XtRealizeWidget(analysisShell);
- CatchDeleteWindow(analysisShell, "AnalysisPopDown");
-
- } else {
- edit = XtNameToWidget(analysisShell, "*form.text");
- j = 0;
- XtSetArg(args[j], XtNstring, text); j++;
- XtSetValues(edit, args, j);
- j = 0;
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;
- XtSetValues(analysisShell, args, j);
- }
-
- if (!analysisUp) {
- XtPopup(analysisShell, XtGrabNone);
- }
- XSync(xDisplay, False);
-
- analysisUp = True;
-}
-
void CommentCallback(w, client_data, call_data)
Widget w;
XtPointer client_data, call_data;
XtSetArg(args[j], XtNlabel, &name); j++;
XtGetValues(w, args, j);
- if (strcmp(name, "close") == 0) {
+ if (strcmp(name, _("close")) == 0) {
CommentPopDown();
- } else if (strcmp(name, "edit") == 0) {
+ } else if (strcmp(name, _("edit")) == 0) {
CommentPopDown();
EditCommentEvent();
}
commentUp = False;
}
-void AnalysisPopDown()
-{
- if (!analysisUp) return;
- XtPopdown(analysisShell);
- XSync(xDisplay, False);
- analysisUp = False;
-}
-
-
void FileNamePopUp(label, def, proc, openMode)
char *label;
char *def;
FileProc proc;
char *openMode;
{
- Arg args[16];
- Widget popup, layout, dialog, edit;
- Window root, child;
- int x, y, i;
- int win_x, win_y;
- unsigned int mask;
-
fileProc = proc; /* I can't see a way not */
fileOpenMode = openMode; /* to use globals here */
-
- i = 0;
- XtSetArg(args[i], XtNresizable, True); i++;
- XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
- fileNameShell = popup =
- XtCreatePopupShell("File name prompt", transientShellWidgetClass,
- shellWidget, args, i);
-
- layout =
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,
- layoutArgs, XtNumber(layoutArgs));
-
- i = 0;
- XtSetArg(args[i], XtNlabel, label); i++;
- XtSetArg(args[i], XtNvalue, def); i++;
- XtSetArg(args[i], XtNborderWidth, 0); i++;
- dialog = XtCreateManagedWidget("fileName", dialogWidgetClass,
- layout, args, i);
-
- XawDialogAddButton(dialog, "ok", FileNameCallback, (XtPointer) dialog);
- XawDialogAddButton(dialog, "cancel", FileNameCallback,
- (XtPointer) dialog);
-
- XtRealizeWidget(popup);
- CatchDeleteWindow(popup, "FileNamePopDown");
-
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,
- &x, &y, &win_x, &win_y, &mask);
-
- XtSetArg(args[0], XtNx, x - 10);
- XtSetArg(args[1], XtNy, y - 30);
- XtSetValues(popup, args, 2);
-
- XtPopup(popup, XtGrabExclusive);
- filenameUp = True;
-
- edit = XtNameToWidget(dialog, "*value");
- XtSetKeyboardFocus(popup, edit);
+ { // [HGM] use file-selector dialog stolen from Ghostview
+ char *name;
+ int index; // this is not supported yet
+ FILE *f;
+ if(f = XsraSelFile(shellWidget, label, NULL, NULL, "could not open: ",
+ def, openMode, NULL, &name))
+ (void) (*fileProc)(f, index=0, name);
+ }
}
void FileNamePopDown()
{
String name;
Arg args[16];
-
+
XtSetArg(args[0], XtNlabel, &name);
XtGetValues(w, args, 1);
-
- if (strcmp(name, "cancel") == 0) {
+
+ if (strcmp(name, _("cancel")) == 0) {
FileNamePopDown();
return;
}
-
+
FileNameAction(w, NULL, NULL, NULL);
}
int index;
name = XawDialogGetValueString(w = XtParent(w));
-
+
if ((name != NULL) && (*name != NULLCHAR)) {
- strcpy(buf, name);
+ safeStrCpy(buf, name, sizeof(buf)/sizeof(buf[0]) );
XtPopdown(w = XtParent(XtParent(w)));
XtDestroyWidget(w);
filenameUp = False;
}
fullname = ExpandPathName(buf);
if (!fullname) {
- ErrorPopUp("Error", "Can't open file", FALSE);
+ ErrorPopUp(_("Error"), _("Can't open file"), FALSE);
}
else {
f = fopen(fullname, fileOpenMode);
if (f == NULL) {
- DisplayError("Failed to open file", errno);
+ DisplayError(_("Failed to open file"), errno);
} else {
(void) (*fileProc)(f, index, buf);
}
ModeHighlight();
return;
}
-
+
XtPopdown(w = XtParent(XtParent(w)));
XtDestroyWidget(w);
filenameUp = False;
j = 0;
XtSetArg(args[j], XtNwidth, &bw_width); j++;
XtGetValues(boardWidget, args, j);
-
+
j = 0;
XtSetArg(args[j], XtNresizable, True); j++;
+ XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
promotionShell =
XtCreatePopupShell("Promotion", transientShellWidgetClass,
shellWidget, args, j);
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
layoutArgs, XtNumber(layoutArgs));
-
+
j = 0;
- XtSetArg(args[j], XtNlabel, "Promote pawn to what?"); j++;
+ XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
XtSetArg(args[j], XtNborderWidth, 0); j++;
dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
layout, args, j);
-
- XawDialogAddButton(dialog, "Queen", PromotionCallback,
+
+ if(gameInfo.variant != VariantShogi) {
+ XawDialogAddButton(dialog, _("Queen"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, "Rook", PromotionCallback,
+ XawDialogAddButton(dialog, _("Rook"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, "Bishop", PromotionCallback,
+ XawDialogAddButton(dialog, _("Bishop"), PromotionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, "Knight", PromotionCallback,
+ XawDialogAddButton(dialog, _("Knight"), PromotionCallback,
(XtPointer) dialog);
if (!appData.testLegality || gameInfo.variant == VariantSuicide ||
gameInfo.variant == VariantGiveaway) {
- XawDialogAddButton(dialog, "King", PromotionCallback,
+ XawDialogAddButton(dialog, _("King"), PromotionCallback,
+ (XtPointer) dialog);
+ }
+ if(gameInfo.variant == VariantCapablanca ||
+ gameInfo.variant == VariantGothic ||
+ gameInfo.variant == VariantCapaRandom) {
+ XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
+ (XtPointer) dialog);
+ XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback,
(XtPointer) dialog);
}
- XawDialogAddButton(dialog, "cancel", PromotionCallback,
+ } else // [HGM] shogi
+ {
+ XawDialogAddButton(dialog, _("Promote"), PromotionCallback,
+ (XtPointer) dialog);
+ XawDialogAddButton(dialog, _("Defer"), PromotionCallback,
+ (XtPointer) dialog);
+ }
+ XawDialogAddButton(dialog, _("cancel"), PromotionCallback,
(XtPointer) dialog);
-
+
XtRealizeWidget(promotionShell);
CatchDeleteWindow(promotionShell, "PromotionPopDown");
-
+
j = 0;
XtSetArg(args[j], XtNwidth, &pw_width); j++;
XtGetValues(promotionShell, args, j);
-
+
XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
lineGap + squareSize/3 +
- ((toY == 7) ^ (flipView) ?
+ ((toY == BOARD_HEIGHT-1) ^ (flipView) ?
0 : 6*(squareSize + lineGap)), &x, &y);
-
+
j = 0;
XtSetArg(args[j], XtNx, x); j++;
XtSetArg(args[j], XtNy, y); j++;
XtSetValues(promotionShell, args, j);
-
+
XtPopup(promotionShell, XtGrabNone);
-
+
promotionUp = True;
}
String name;
Arg args[16];
int promoChar;
-
+
XtSetArg(args[0], XtNlabel, &name);
XtGetValues(w, args, 1);
-
+
PromotionPopDown();
-
+
if (fromX == -1) return;
-
- if (strcmp(name, "cancel") == 0) {
+
+ if (strcmp(name, _("cancel")) == 0) {
fromX = fromY = -1;
ClearHighlights();
return;
- } else if (strcmp(name, "Knight") == 0) {
+ } else if (strcmp(name, _("Knight")) == 0) {
promoChar = 'n';
+ } else if (strcmp(name, _("Promote")) == 0) {
+ promoChar = '+';
+ } else if (strcmp(name, _("Defer")) == 0) {
+ promoChar = '=';
} else {
promoChar = ToLower(name[0]);
}
Dimension bw_width, pw_width;
Dimension pw_height;
int i;
-
+
i = 0;
XtSetArg(args[i], XtNresizable, True); i++;
XtSetArg(args[i], XtNtitle, title); i++;
- errorShell =
+ errorShell =
XtCreatePopupShell("errorpopup", transientShellWidgetClass,
shellWidget, args, i);
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
layoutArgs, XtNumber(layoutArgs));
-
+
i = 0;
XtSetArg(args[i], XtNlabel, label); i++;
XtSetArg(args[i], XtNborderWidth, 0); i++;
dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
layout, args, i);
-
- XawDialogAddButton(dialog, "ok", ErrorCallback, (XtPointer) dialog);
-
+
+ XawDialogAddButton(dialog, _("ok"), ErrorCallback, (XtPointer) dialog);
+
XtRealizeWidget(errorShell);
CatchDeleteWindow(errorShell, "ErrorPopDown");
-
+
i = 0;
XtSetArg(args[i], XtNwidth, &bw_width); i++;
XtGetValues(boardWidget, args, i);
case EndOfGame:
return NULL;
}
-}
+}
void ModeHighlight()
{
static int oldPausing = FALSE;
static GameMode oldmode = (GameMode) -1;
char *wname;
-
+
if (!boardWidget || !XtIsRealized(boardWidget)) return;
if (pausing != oldPausing) {
args, 1);
if (appData.showButtonBar) {
-#if 0
- if (pausing) {
- XtSetArg(args[0], XtNbackground, buttonForegroundPixel);
- XtSetArg(args[1], XtNforeground, buttonBackgroundPixel);
- } else {
- XtSetArg(args[0], XtNbackground, buttonBackgroundPixel);
- XtSetArg(args[1], XtNforeground, buttonForegroundPixel);
- }
-#else
/* Always toggle, don't set. Previous code messes up when
invoked while the button is pressed, as releasing it
toggles the state again. */
XtSetArg(args[0], XtNbackground, oldfg);
XtSetArg(args[1], XtNforeground, oldbg);
}
-#endif
XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
}
}
Cardinal *nprms;
{
ResetGameEvent();
- AnalysisPopDown();
}
int LoadGamePopUp(f, gameNumber, title)
if (gameNumber == 0) {
int error = GameListBuild(f);
if (error) {
- DisplayError("Cannot build game list", error);
+ DisplayError(_("Cannot build game list"), error);
} else if (!ListEmpty(&gameList) &&
((ListGame *) gameList.tailPred)->number > 1) {
GameListPopUp(f, title);
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
Reset(FALSE, TRUE);
}
- FileNamePopUp("Load game file name?", "", LoadGamePopUp, "rb");
+ FileNamePopUp(_("Load game file name?"), "", LoadGamePopUp, "rb");
}
void LoadNextGameProc(w, event, prms, nprms)
if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
Reset(FALSE, TRUE);
}
- FileNamePopUp("Load position file name?", "", LoadPosition, "rb");
+ FileNamePopUp(_("Load position file name?"), "", LoadPosition, "rb");
}
void SaveGameProc(w, event, prms, nprms)
String *prms;
Cardinal *nprms;
{
- FileNamePopUp("Save game file name?",
+ FileNamePopUp(_("Save game file name?"),
DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),
SaveGame, "a");
}
String *prms;
Cardinal *nprms;
{
- FileNamePopUp("Save position file name?",
+ FileNamePopUp(_("Save position file name?"),
DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),
SavePosition, "a");
}
}
/* this variable is shared between CopyPositionProc and SendPositionSelection */
-static char *selected_fen_position=NULL;
+char *selected_fen_position=NULL;
-static Boolean
+Boolean
SendPositionSelection(Widget w, Atom *selection, Atom *target,
Atom *type_return, XtPointer *value_return,
unsigned long *length_return, int *format_return)
char *selection_tmp;
if (!selected_fen_position) return False; /* should never happen */
- if (*target == XA_STRING){
+ if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
/* note: since no XtSelectionDoneProc was registered, Xt will
* automatically call XtFree on the value returned. So have to
* make a copy of it allocated with XtMalloc */
selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
- strcpy(selection_tmp, selected_fen_position);
+ safeStrCpy(selection_tmp, selected_fen_position, sizeof(selection_tmp)/sizeof(selection_tmp[0]) );
*value_return=selection_tmp;
*length_return=strlen(selection_tmp);
- *type_return=XA_STRING;
+ *type_return=*target;
*format_return = 8; /* bits per byte */
return True;
+ } else if (*target == XA_TARGETS(xDisplay)) {
+ Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+ targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+ targets_tmp[1] = XA_STRING;
+ *value_return = targets_tmp;
+ *type_return = XA_ATOM;
+ *length_return = 2;
+ *format_return = 8 * sizeof(Atom);
+ if (*format_return > 32) {
+ *length_return *= *format_return / 32;
+ *format_return = 32;
+ }
+ return True;
} else {
return False;
- }
+ }
}
/* note: when called from menu all parameters are NULL, so no clue what the
String *prms;
Cardinal *nprms;
{
- int ret;
-
+ /*
+ * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+ * have a notion of a position that is selected but not copied.
+ * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+ */
+ if(gameMode == EditPosition) EditPositionDone(TRUE);
if (selected_fen_position) free(selected_fen_position);
- selected_fen_position = (char *)PositionToFEN(currentMove);
+ selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
if (!selected_fen_position) return;
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
- CurrentTime,
- SendPositionSelection,
- NULL/* lose_ownership_proc */ ,
- NULL/* transfer_done_proc */);
- if (!ret) {
- free(selected_fen_position);
- selected_fen_position=NULL;
- }
+ XtOwnSelection(menuBarWidget, XA_PRIMARY,
+ CurrentTime,
+ SendPositionSelection,
+ NULL/* lose_ownership_proc */ ,
+ NULL/* transfer_done_proc */);
+ XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+ CurrentTime,
+ SendPositionSelection,
+ NULL/* lose_ownership_proc */ ,
+ NULL/* transfer_done_proc */);
}
/* function called when the data to Paste is ready */
String *prms;
Cardinal *nprms;
{
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
+ XtGetSelectionValue(menuBarWidget,
+ appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
/* (XtSelectionCallbackProc) */ PastePositionCB,
NULL, /* client_data passed to PastePositionCB */
{
char *selection_tmp;
- if (*target == XA_STRING){
+ if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
FILE* f = fopen(gameCopyFilename, "r");
long len;
size_t count;
selection_tmp[len] = NULLCHAR;
*value_return = selection_tmp;
*length_return = len;
- *type_return = XA_STRING;
+ *type_return = *target;
*format_return = 8; /* bits per byte */
return True;
+ } else if (*target == XA_TARGETS(xDisplay)) {
+ Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+ targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+ targets_tmp[1] = XA_STRING;
+ *value_return = targets_tmp;
+ *type_return = XA_ATOM;
+ *length_return = 2;
+ *format_return = 8 * sizeof(Atom);
+ if (*format_return > 32) {
+ *length_return *= *format_return / 32;
+ *format_return = 32;
+ }
+ return True;
} else {
return False;
- }
+ }
}
/* note: when called from menu all parameters are NULL, so no clue what the
ret = SaveGameToFile(gameCopyFilename, FALSE);
if (!ret) return;
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,
- CurrentTime,
- SendGameSelection,
- NULL/* lose_ownership_proc */ ,
- NULL/* transfer_done_proc */);
+ /*
+ * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
+ * have a notion of a game that is selected but not copied.
+ * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
+ */
+ XtOwnSelection(menuBarWidget, XA_PRIMARY,
+ CurrentTime,
+ SendGameSelection,
+ NULL/* lose_ownership_proc */ ,
+ NULL/* transfer_done_proc */);
+ XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
+ CurrentTime,
+ SendGameSelection,
+ NULL/* lose_ownership_proc */ ,
+ NULL/* transfer_done_proc */);
}
/* function called when the data to Paste is ready */
}
f = fopen(gamePasteFilename, "w");
if (f == NULL) {
- DisplayError("Can't open temp file", errno);
+ DisplayError(_("Can't open temp file"), errno);
return;
}
fwrite(value, 1, *len, f);
String *prms;
Cardinal *nprms;
{
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,
+ XtGetSelectionValue(menuBarWidget,
+ appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
/* (XtSelectionCallbackProc) */ PasteGameCB,
NULL, /* client_data passed to PasteGameCB */
String *prms;
Cardinal *nprms;
{
+ char buf[MSG_SIZ];
+
if (!first.analysisSupport) {
- char buf[MSG_SIZ];
- sprintf(buf, "%s does not support analysis", first.tidy);
+ snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
DisplayError(buf, 0);
return;
}
+ /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
+ if (appData.icsActive) {
+ if (gameMode != IcsObserving) {
+ snprintf(buf, MSG_SIZ, _("You are not observing a game"));
+ DisplayError(buf, 0);
+ /* secure check */
+ if (appData.icsEngineAnalyze) {
+ if (appData.debugMode)
+ fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
+ ExitAnalyzeMode();
+ ModeHighlight();
+ }
+ return;
+ }
+ /* if enable, use want disable icsEngineAnalyze */
+ if (appData.icsEngineAnalyze) {
+ ExitAnalyzeMode();
+ ModeHighlight();
+ return;
+ }
+ appData.icsEngineAnalyze = TRUE;
+ if (appData.debugMode)
+ fprintf(debugFP, _("ICS engine analyze starting... \n"));
+ }
if (!appData.showThinking)
ShowThinkingProc(w,event,prms,nprms);
{
if (!first.analysisSupport) {
char buf[MSG_SIZ];
- sprintf(buf, "%s does not support analysis", first.tidy);
+ snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
DisplayError(buf, 0);
return;
}
ShowThinkingProc(w,event,prms,nprms);
AnalyzeFileEvent();
- FileNamePopUp("File to analyze", "", LoadGamePopUp, "rb");
+ FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
AnalysisPeriodicEvent(1);
}
ResignEvent();
}
+void AdjuWhiteProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(+1);
+}
+
+void AdjuBlackProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(-1);
+}
+
+void AdjuDrawProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UserAdjudicationEvent(0);
+}
+
void EnterKeyProc(w, event, prms, nprms)
Widget w;
XEvent *event;
ICSInputSendText();
}
+void UpKeyProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{ // [HGM] input: let up-arrow recall previous line from history
+ Widget edit;
+ int j;
+ Arg args[16];
+ String val;
+ XawTextBlock t;
+
+ if (!ICSInputBoxUp) return;
+ edit = XtNameToWidget(ICSInputShell, "*form.text");
+ j = 0;
+ XtSetArg(args[j], XtNstring, &val); j++;
+ XtGetValues(edit, args, j);
+ val = PrevInHistory(val);
+ XtCallActionProc(edit, "select-all", NULL, NULL, 0);
+ XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
+ if(val) {
+ t.ptr = val; t.firstPos = 0; t.length = strlen(val); t.format = XawFmt8Bit;
+ XawTextReplace(edit, 0, 0, &t);
+ XawTextSetInsertionPoint(edit, 9999);
+ }
+}
+
+void DownKeyProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{ // [HGM] input: let down-arrow recall next line from history
+ Widget edit;
+ String val;
+ XawTextBlock t;
+
+ if (!ICSInputBoxUp) return;
+ edit = XtNameToWidget(ICSInputShell, "*form.text");
+ val = NextInHistory();
+ XtCallActionProc(edit, "select-all", NULL, NULL, 0);
+ XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
+ if(val) {
+ t.ptr = val; t.firstPos = 0; t.length = strlen(val); t.format = XawFmt8Bit;
+ XawTextReplace(edit, 0, 0, &t);
+ XawTextSetInsertionPoint(edit, 9999);
+ }
+}
+
void StopObservingProc(w, event, prms, nprms)
Widget w;
XEvent *event;
StopExaminingEvent();
}
+void UploadProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ UploadGameEvent();
+}
+
void ForwardProc(w, event, prms, nprms)
Widget w;
String *prms;
Cardinal *nprms;
{
- RevertEvent();
+ RevertEvent(False);
+}
+
+void AnnotateProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ RevertEvent(True);
}
void TruncateGameProc(w, event, prms, nprms)
Arg args[16];
PeriodicUpdatesEvent(!appData.periodicUpdates);
-
+
if (appData.periodicUpdates) {
XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
} else {
String *prms;
Cardinal *nprms;
{
+ 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];
- ShowThinkingEvent(!appData.showThinking);
+ appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
+ ShowThinkingEvent();
- if (appData.showThinking) {
+ if (appData.hideThinkingFromHuman) {
XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
} else {
XtSetArg(args[0], XtNleftBitmap, None);
}
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
args, 1);
}
+void SaveOnExitProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ Arg args[16];
+
+ saveSettingsOnExit = !saveSettingsOnExit;
+
+ if (saveSettingsOnExit) {
+ XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
+ } else {
+ XtSetArg(args[0], XtNleftBitmap, None);
+ }
+ XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Save Settings on Exit"),
+ args, 1);
+}
+
+void SaveSettingsProc(w, event, prms, nprms)
+ Widget w;
+ XEvent *event;
+ String *prms;
+ Cardinal *nprms;
+{
+ SaveSettings(settingsFileName);
+}
+
void InfoProc(w, event, prms, nprms)
Widget w;
XEvent *event;
Cardinal *nprms;
{
char buf[MSG_SIZ];
- sprintf(buf, "xterm -e info --directory %s --directory . -f %s &",
+ snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
INFODIR, INFOFILE);
system(buf);
}
name = prms[0];
else
name = "xboard";
- sprintf(buf, "xterm -e man %s &", name);
+ snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
system(buf);
}
#else
char *zippy = "";
#endif
- sprintf(buf, "%s%s\n\n%s\n%s\n\n%s%s\n%s",
+ snprintf(buf, sizeof(buf), "%s%s\n\n%s\n%s\n%s\n\n%s%s\n%s",
programVersion, zippy,
"Copyright 1991 Digital Equipment Corporation",
- "Enhancements Copyright 1992-2001 Free Software Foundation",
- PRODUCT, " is free software and carries NO WARRANTY;",
+ "Enhancements Copyright 1992-2009 Free Software Foundation",
+ "Enhancements Copyright 2005 Alessandro Scotti",
+ PACKAGE, " is free software and carries NO WARRANTY;",
"see the file COPYING for more information.");
- ErrorPopUp("About XBoard", buf, FALSE);
+ ErrorPopUp(_("About XBoard"), buf, FALSE);
}
void DebugProc(w, event, prms, nprms)
Cardinal *nprms;
{
Arg args[16];
-
+
fromX = fromY = -1;
XtSetArg(args[0], XtNiconic, True);
XtSetValues(shellWidget, args, 1);
void DisplayMessage(message, extMessage)
char *message, *extMessage;
{
- char buf[MSG_SIZ];
- Arg arg;
-
- if (extMessage) {
- if (*message) {
- sprintf(buf, "%s %s", message, extMessage);
- message = buf;
- } else {
- 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;
}
- }
- XtSetArg(arg, XtNlabel, message);
- XtSetValues(messageWidget, &arg, 1);
+ 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;
}
void DisplayTitle(text)
}
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) {
- sprintf(icon, "%s", appData.icsHost);
- sprintf(title, "%s: %s", programName, appData.icsHost);
+ snprintf(icon, sizeof(icon), "%s", appData.icsHost);
+ snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
} else if (appData.cmailGameName[0] != NULLCHAR) {
- sprintf(icon, "%s", "CMail");
- sprintf(title, "%s: %s", programName, "CMail");
+ snprintf(icon, sizeof(icon), "%s", "CMail");
+ snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
+#ifdef GOTHIC
+ // [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
+ } else if (gameInfo.variant == VariantGothic) {
+ safeStrCpy(icon, programName, sizeof(icon)/sizeof(icon[0]) );
+ safeStrCpy(title, GOTHIC, sizeof(title)/sizeof(title[0]) );
+#endif
+#ifdef FALCON
+ } else if (gameInfo.variant == VariantFalcon) {
+ 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);
- sprintf(title, "%s: %s", programName, first.tidy);
+ safeStrCpy(icon, first.tidy, sizeof(icon)/sizeof(icon[0]) );
+ snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
}
i = 0;
XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
}
-void DisplayError(message, error)
+void
+DisplayError(message, error)
String message;
int error;
{
fprintf(stderr, "%s: %s: %s\n",
programName, message, strerror(error));
}
- sprintf(buf, "%s: %s", message, strerror(error));
+ snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
message = buf;
- }
- ErrorPopUp("Error", message, FALSE);
+ }
+ ErrorPopUp(_("Error"), message, FALSE);
}
fprintf(stderr, "%s: %s\n", programName, message);
}
if (appData.popupMoveErrors) {
- ErrorPopUp("Error", message, FALSE);
+ ErrorPopUp(_("Error"), message, FALSE);
} else {
DisplayMessage(message, "");
}
} else {
fprintf(stderr, "%s: %s: %s\n",
programName, message, strerror(error));
- sprintf(buf, "%s: %s", message, strerror(error));
+ snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
message = buf;
}
if (appData.popupExitMessage && boardWidget && XtIsRealized(boardWidget)) {
- ErrorPopUp(status ? "Fatal Error" : "Exiting", message, TRUE);
+ ErrorPopUp(status ? _("Fatal Error") : _("Exiting"), message, TRUE);
} else {
ExitEvent(status);
}
String message;
{
ErrorPopDown();
- ErrorPopUp("Information", message, TRUE);
+ ErrorPopUp(_("Information"), message, TRUE);
+}
+
+void DisplayNote(message)
+ String message;
+{
+ ErrorPopDown();
+ ErrorPopUp(_("Note"), message, FALSE);
}
static int
XSetErrorHandler(oldHandler);
}
if (oldICSInteractionTitle == NULL) {
- oldICSInteractionTitle = "xterm";
+ oldICSInteractionTitle = "xterm";
}
- }
+ }
printf("\033]0;%s\007", message);
fflush(stdout);
}
Cardinal *nprms;
{
if (*nprms != 4) {
- fprintf(stderr, "AskQuestionProc needed 4 parameters, got %d\n",
+ fprintf(stderr, _("AskQuestionProc needed 4 parameters, got %d\n"),
*nprms);
return;
}
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();
- if (err) DisplayFatalError("Error writing to chess program", err, 0);
+ if (err) DisplayFatalError(_("Error writing to chess program"), err, 0);
}
void AskQuestionCallback(w, client_data, call_data)
XtSetArg(args[0], XtNlabel, &name);
XtGetValues(w, args, 1);
-
- if (strcmp(name, "cancel") == 0) {
+
+ if (strcmp(name, _("cancel")) == 0) {
AskQuestionPopDown();
} else {
AskQuestionReplyAction(w, NULL, NULL, NULL);
int x, y, i;
int win_x, win_y;
unsigned int mask;
-
- strcpy(pendingReplyPrefix, replyPrefix);
+
+ safeStrCpy(pendingReplyPrefix, replyPrefix, sizeof(pendingReplyPrefix)/sizeof(pendingReplyPrefix[0]) );
pendingReplyPR = pr;
-
+
i = 0;
XtSetArg(args[i], XtNresizable, True); i++;
XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
askQuestionShell = popup =
XtCreatePopupShell(title, transientShellWidgetClass,
shellWidget, args, i);
-
+
layout =
XtCreateManagedWidget(layoutName, formWidgetClass, popup,
layoutArgs, XtNumber(layoutArgs));
-
+
i = 0;
XtSetArg(args[i], XtNlabel, question); i++;
XtSetArg(args[i], XtNvalue, ""); i++;
XtSetArg(args[i], XtNborderWidth, 0); i++;
dialog = XtCreateManagedWidget("question", dialogWidgetClass,
layout, args, i);
-
- XawDialogAddButton(dialog, "enter", AskQuestionCallback,
+
+ XawDialogAddButton(dialog, _("enter"), AskQuestionCallback,
(XtPointer) dialog);
- XawDialogAddButton(dialog, "cancel", AskQuestionCallback,
+ XawDialogAddButton(dialog, _("cancel"), AskQuestionCallback,
(XtPointer) dialog);
XtRealizeWidget(popup);
CatchDeleteWindow(popup, "AskQuestionPopDown");
-
+
XQueryPointer(xDisplay, xBoardWindow, &root, &child,
&x, &y, &win_x, &win_y, &mask);
-
+
XtSetArg(args[0], XtNx, x - 10);
XtSetArg(args[1], XtNy, y - 30);
XtSetValues(popup, args, 2);
-
+
XtPopup(popup, XtGrabExclusive);
askQuestionUp = True;
-
+
edit = XtNameToWidget(dialog, "*value");
XtSetKeyboardFocus(popup, edit);
}
putc(BELLCHAR, stderr);
} else {
char buf[2048];
- sprintf(buf, "%s '%s' &", appData.soundProgram, name);
+ snprintf(buf, sizeof(buf), "%s '%s' &", appData.soundProgram, name);
system(buf);
}
}
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);
outCount = OutputToProcess(NoProc, buf, count, &error);
if (outCount < count) {
- DisplayFatalError("Error writing to display", error, 1);
+ DisplayFatalError(_("Error writing to display"), error, 1);
}
if (continuation) return;
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;
d = static_buf;
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]) );
+ *strchr(buf, '/') = 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;
-}
+}
char *HostName()
{
static char host_name[MSG_SIZ];
-
+
#if HAVE_GETHOSTNAME
gethostname(host_name, MSG_SIZ);
return host_name;
ScheduleDelayedEvent(cb, millisec)
DelayedEventCallback cb; long millisec;
{
+ if(delayedEventTimerXID && delayedEventCallback == cb)
+ // [HGM] alive: replace, rather than add or flush identical event
+ XtRemoveTimeOut(delayedEventTimerXID);
delayedEventCallback = cb;
delayedEventTimerXID =
XtAppAddTimeOut(appContext, millisec,
XtPointer arg;
XtIntervalId *id;
{
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
+ if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
+ || appData.icsEngineAnalyze) { // [DM]
AnalysisPeriodicEvent(0);
StartAnalysisClock();
}
{
char buf[MSG_SIZ];
Arg args[16];
-
+
+ /* check for low time warning */
+ Pixel foregroundOrWarningColor = timerForegroundPixel;
+
+ if (timer > 0 &&
+ appData.lowTimeWarning &&
+ (timer / 1000) < appData.icsAlarmTime)
+ foregroundOrWarningColor = lowTimeWarningColor;
+
if (appData.clockMode) {
- sprintf(buf, "%s: %s", color, TimeString(timer));
- XtSetArg(args[0], XtNlabel, buf);
+ 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) {
- XtSetArg(args[1], XtNbackground, timerForegroundPixel);
+
+ XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
} else {
XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
- XtSetArg(args[2], XtNforeground, timerForegroundPixel);
+ XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
}
-
+
XtSetValues(w, args, 3);
}
int highlight;
{
Arg args[16];
- DisplayTimerLabel(whiteTimerWidget, "White", timeRemaining, highlight);
+
+ if(appData.noGUI) return;
+ DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
if (highlight && iconPixmap == bIconPixmap) {
iconPixmap = wIconPixmap;
XtSetArg(args[0], XtNiconPixmap, iconPixmap);
int highlight;
{
Arg args[16];
- DisplayTimerLabel(blackTimerWidget, "Black", timeRemaining, highlight);
+
+ if(appData.noGUI) return;
+ DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
if (highlight && iconPixmap == wIconPixmap) {
iconPixmap = bIconPixmap;
XtSetArg(args[0], XtNiconPixmap, iconPixmap);
typedef struct {
CPKind kind;
int pid;
- int fdTo, fdFrom;
+ int fdTo, fdFrom;
} ChildProc;
int StartChildProcess(cmdLine, dir, pr)
- char *cmdLine;
+ char *cmdLine;
char *dir;
ProcRef *pr;
{
int to_prog[2], from_prog[2];
ChildProc *cp;
char buf[MSG_SIZ];
-
+
if (appData.debugMode) {
fprintf(stderr, "StartChildProcess (dir=\"%s\") %s\n",dir, cmdLine);
}
most simple-minded way possible.
*/
i = 0;
- strcpy(buf, cmdLine);
+ safeStrCpy(buf, cmdLine, sizeof(buf)/sizeof(buf[0]) );
p = buf;
for (;;) {
+ while(*p == ' ') p++;
argv[i++] = p;
- p = strchr(p, ' ');
+ if(*p == '"' || *p == '\'')
+ p = strchr(++argv[i-1], *p);
+ else p = strchr(p, ' ');
if (p == NULL) break;
*p++ = NULLCHAR;
}
if ((pid = fork()) == 0) {
/* Child process */
- dup2(to_prog[0], 0);
- dup2(from_prog[1], 1);
- close(to_prog[0]);
- close(to_prog[1]);
+ // [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
+ close(to_prog[1]); // first close the unused pipe ends
close(from_prog[0]);
- close(from_prog[1]);
- dup2(1, fileno(stderr)); /* force stderr to the pipe */
+ dup2(to_prog[0], 0); // to_prog was created first, nd is the only one to use 0 or 1
+ dup2(from_prog[1], 1);
+ if(to_prog[0] >= 2) close(to_prog[0]); // if 0 or 1, the dup2 already cosed the original
+ close(from_prog[1]); // and closing again loses one of the pipes!
+ if(fileno(stderr) >= 2) // better safe than sorry...
+ dup2(1, fileno(stderr)); /* force stderr to the pipe */
if (dir[0] != NULLCHAR && chdir(dir) != 0) {
perror(dir);
exit(1);
}
+ nice(appData.niceEngines); // [HGM] nice: adjust priority of engine proc
+
execvp(argv[0], argv);
-
+
/* If we get here, exec failed */
perror(argv[0]);
exit(1);
}
-
+
/* Parent process */
close(to_prog[0]);
close(from_prog[1]);
-
+
cp = (ChildProc *) calloc(1, sizeof(ChildProc));
cp->kind = CPReal;
cp->pid = pid;
return 0;
}
+// [HGM] kill: implement the 'hard killing' of AS's Winboard_x
+static RETSIGTYPE AlarmCallBack(int n)
+{
+ return;
+}
+
void
-DestroyChildProcess(pr, signal)
+DestroyChildProcess(pr, signalType)
ProcRef pr;
- int signal;
+ int signalType;
{
ChildProc *cp = (ChildProc *) pr;
if (cp->kind != CPReal) return;
cp->kind = CPNone;
- if (signal) {
- kill(cp->pid, SIGTERM);
+ if (signalType == 10) { // [HGM] kill: if it does not terminate in 3 sec, kill
+ signal(SIGALRM, AlarmCallBack);
+ alarm(3);
+ if(wait((int *) 0) == -1) { // process does not terminate on its own accord
+ kill(cp->pid, SIGKILL); // kill it forcefully
+ wait((int *) 0); // and wait again
+ }
+ } else {
+ if (signalType) {
+ kill(cp->pid, signalType == 9 ? SIGKILL : SIGTERM); // [HGM] kill: use hard kill if so requested
+ }
+ /* Process is exiting either because of the kill or because of
+ a quit command sent by the backend; either way, wait for it to die.
+ */
+ wait((int *) 0);
}
- /* Process is exiting either because of the kill or because of
- a quit command sent by the backend; either way, wait for it to die.
- */
- wait((int *) 0);
close(cp->fdFrom);
close(cp->fdTo);
}
char cmdLine[MSG_SIZ];
if (port[0] == NULLCHAR) {
- sprintf(cmdLine, "%s %s", appData.telnetProgram, host);
+ snprintf(cmdLine, sizeof(cmdLine), "%s %s", appData.telnetProgram, host);
} else {
- sprintf(cmdLine, "%s %s %s", appData.telnetProgram, host, port);
+ snprintf(cmdLine, sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
}
return StartChildProcess(cmdLine, "", pr);
}
ProcRef *pr;
{
#if OMIT_SOCKETS
- DisplayFatalError("Socket support is not configured in", 0, 2);
+ DisplayFatalError(_("Socket support is not configured in"), 0, 2);
#else /* !OMIT_SOCKETS */
int s;
struct sockaddr_in sa;
sa.sin_port = htons(uport);
memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
- if (connect(s, (struct sockaddr *) &sa,
+ if (connect(s, (struct sockaddr *) &sa,
sizeof(struct sockaddr_in)) < 0) {
return errno;
}
char *host, *user, *cmd;
ProcRef *pr;
{
- DisplayFatalError("internal rcmd not implemented for Unix", 0, 1);
+ DisplayFatalError(_("internal rcmd not implemented for Unix"), 0, 1);
return -1;
-}
+}
#define INPUT_SOURCE_BUF_SIZE 8192
} InputSource;
void
-DoInputCallback(closure, source, xid)
+DoInputCallback(closure, source, xid)
caddr_t closure;
int *source;
XtInputId *xid;
}
q = is->buf;
while (p < is->unused) {
- *q++ = *p++;
+ *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);
- }
+# if HAVE_LIBREADLINE
+ /* check if input is from stdin, if yes, use gnu-readline */
+ if( is->fd==fileno(stdin) )
+ {
+ /* to clear the line */
+ printf("\r \r");
+
+ /* read from stdin */
+ rl_callback_read_char();
+
+ /* redisplay the current line, check special case for login and password */
+ if(sending_ICS_password)
+ {
+ int i; char buf[MSG_SIZ];
+
+ bzero(buf,MSG_SIZ);
+
+ /* blank the password */
+ count = strlen(rl_line_buffer);
+ if(count>MSG_SIZ-1)
+ {
+ printf("PROBLEM with readline\n");
+ count=MSG_SIZ;
+ }
+ for(i=0;i<count;i++)
+ buf[i]='*';
+ i++;
+ buf[i]='\0';
+ printf("\rpassword: %s",buf);
+ }
+ else if (sending_ICS_login)
+ {
+ /* show login prompt */
+ count = strlen(rl_line_buffer);
+ printf("\rlogin: %s",rl_line_buffer);
+ }
+ else
+ rl_reset_line_state();
+
+ if(readline_complete)
+ {
+ /* copy into XBoards buffer */
+ count = strlen(readline_buffer);
+ if (count>INPUT_SOURCE_BUF_SIZE-1)
+ {
+ printf("PROBLEM with readline\n");
+ count = INPUT_SOURCE_BUF_SIZE;
+ };
+ strncpy(is->buf,readline_buffer,count);
+ is->buf[count]='\n';count++;
+
+ /* reset gnu-readline state */
+ free(readline_buffer);
+ readline_buffer=NULL;
+ readline_complete=0;
+
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+
+ /* are we done with the password? */
+ if(sending_ICS_password)
+ sending_ICS_password=0;
+ if(sending_ICS_login)
+ sending_ICS_login=0;
+ }
+ }
+ else
+ {
+ /* input not from stdin, use default method */
+ 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);
+ };
+#else /* no readline support */
+ 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);
+#endif
+
+ }
}
InputSourceRef AddInputSource(pr, lineByLine, func, closure)
if (lineByLine) {
is->unused = is->buf;
}
-
+
is->xid = XtAppAddInput(appContext, is->fd,
(XtPointer) (XtInputReadMask),
(XtInputCallbackProc) DoInputCallback,
int count;
int *outError;
{
+ static int line = 0;
ChildProc *cp = (ChildProc *) pr;
int outCount;
+
if (pr == NoProc)
- outCount = fwrite(message, 1, count, stdout);
+ {
+ if (appData.noJoin || !appData.useInternalWrap)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ int width = get_term_width();
+ int len = wrap(NULL, message, count, width, &line);
+ char *msg = malloc(len);
+ int dbgchk;
+
+ if (!msg)
+ outCount = fwrite(message, 1, count, stdout);
+ else
+ {
+ dbgchk = wrap(msg, message, count, width, &line);
+ if (dbgchk != len && appData.debugMode)
+ fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
+ outCount = fwrite(msg, 1, dbgchk, stdout);
+ free(msg);
+ }
+ }
+
+# if HAVE_LIBREADLINE
+ /* readline support */
+ if(strlen(rl_line_buffer))
+ printf("\n> %s",rl_line_buffer);
+#endif
+
+ }
else
outCount = write(cp->fdTo, message, count);
ChildProc *cp = (ChildProc *) pr;
int outCount = 0;
int r;
-
+
while (count--) {
r = write(cp->fdTo, message++, 1);
if (r == -1) {
and dark squares, and all pieces must use the same
background square colors/images. */
+static int xpmDone = 0;
+
static void
CreateAnimMasks (pieceDepth)
int pieceDepth;
XFreePixmap(xDisplay, buf);
buf = XCreatePixmap(xDisplay, xBoardWindow,
- squareSize, squareSize, pieceDepth);
+ squareSize, squareSize, pieceDepth);
values.foreground = XBlackPixel(xDisplay, xScreen);
values.background = XWhitePixel(xDisplay, xScreen);
bufGC = XCreateGC(xDisplay, buf,
for (piece = WhitePawn; piece <= BlackKing; piece++) {
/* Begin with empty mask */
+ if(!xpmDone) // [HGM] pieces: keep using existing
xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
squareSize, squareSize, 1);
XSetFunction(xDisplay, maskGC, GXclear);
XFillRectangle(xDisplay, xpmMask[piece], maskGC,
0, 0, squareSize, squareSize);
-
+
/* Take a copy of the piece */
if (White(piece))
kind = 0;
else
kind = 2;
XSetFunction(xDisplay, bufGC, GXcopy);
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % 6],
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
buf, bufGC,
0, 0, squareSize, squareSize, 0, 0);
-
+
/* XOR the background (light) over the piece */
XSetFunction(xDisplay, bufGC, GXxor);
if (useImageSqs)
XSetForeground(xDisplay, bufGC, lightSquareColor);
XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
}
-
+
/* We now have an inverted piece image with the background
erased. Construct mask by just selecting all the non-zero
pixels - no need to reconstruct the original image. */
{
XtGCMask mask;
XGCValues values;
-
+
/* Each buffer is square size, same depth as window */
anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
squareSize, squareSize, info->depth);
static void
CreateAnimVars ()
{
- static int done = 0;
+ static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
XWindowAttributes info;
- if (done) return;
- done = 1;
+ if (xpmDone && gameInfo.variant == old) return;
+ if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
XGetWindowAttributes(xDisplay, xBoardWindow, &info);
-
+
InitAnimState(&game, &info);
InitAnimState(&player, &info);
-
+
/* For XPM pieces, we need bitmaps to use as masks. */
if (useImages)
CreateAnimMasks(info.depth);
+ xpmDone = 1;
}
#ifndef HAVE_USLEEP
int time;
{
struct itimerval delay;
-
+
XSync(xDisplay, False);
if (time > 0) {
frameWaiting = True;
signal(SIGALRM, FrameAlarm);
- delay.it_interval.tv_sec =
+ delay.it_interval.tv_sec =
delay.it_value.tv_sec = time / 1000;
- delay.it_interval.tv_usec =
+ delay.it_interval.tv_usec =
delay.it_value.tv_usec = (time % 1000) * 1000;
setitimer(ITIMER_REAL, &delay, NULL);
-#if 0
- /* Ugh -- busy-wait! --tpm */
- while (frameWaiting);
-#else
while (frameWaiting) pause();
-#endif
delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;
delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &delay, NULL);
int column; int row; XPoint * pt; int * color;
{
if (flipView) {
- pt->x = lineGap + ((BOARD_SIZE-1)-column) * (squareSize + lineGap);
+ pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
pt->y = lineGap + row * (squareSize + lineGap);
} else {
pt->x = lineGap + column * (squareSize + lineGap);
- pt->y = lineGap + ((BOARD_SIZE-1)-row) * (squareSize + lineGap);
+ pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
}
- *color = ((column + row) % 2) == 1;
+ *color = SquareColor(row, column);
}
/* Convert window coords to square */
BoardSquare(x, y, column, row)
int x; int y; int * column; int * row;
{
- *column = EventToSquare(x, BOARD_SIZE);
+ *column = EventToSquare(x, BOARD_WIDTH);
if (flipView && *column >= 0)
- *column = BOARD_SIZE - 1 - *column;
- *row = EventToSquare(y, BOARD_SIZE);
+ *column = BOARD_WIDTH - 1 - *column;
+ *row = EventToSquare(y, BOARD_HEIGHT);
if (!flipView && *row >= 0)
- *row = BOARD_SIZE - 1 - *row;
+ *row = BOARD_HEIGHT - 1 - *row;
}
/* Utilities */
/* Test if two frames overlap. If they do, return
intersection rect within old and location of
that rect within new. */
-
+
static Boolean
Intersect(old, new, size, area, pt)
XPoint * old; XPoint * new;
/* For two overlapping frames, return the rect(s)
in the old that do not intersect with the new. */
-
+
static void
CalcUpdateRects(old, new, size, update, nUpdates)
XPoint * old; XPoint * new; int size;
count ++;
fraction = fraction / 2;
}
-
+
/* Midpoint */
frames[count] = *mid;
count ++;
-
+
/* Slow out, stepping 1/2, then 1/4, ... */
fraction = 2;
for (n = 0; n < factor; n++) {
#if HAVE_LIBXPM
*mask = xpmMask[piece];
#else
- *mask = ximMaskPm[piece%6];
+ *mask = ximMaskPm[piece];
#endif
} else {
*mask = *pieceToSolid(piece);
source = blPieceGC;
}
XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
-
+
/* Outline only used in mono mode and is not modified */
if (White(piece))
*outline = bwPieceGC;
ChessSquare piece; GC clip; GC outline; Drawable dest;
{
int kind;
-
+
if (!useImages) {
/* Draw solid rectangle which will be clipped to shape of piece */
XFillRectangle(xDisplay, dest, clip,
kind = 0;
else
kind = 2;
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % 6],
+ if(appData.upsideDown && flipView) kind ^= 2;
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
dest, clip,
0, 0, squareSize, squareSize,
- 0, 0);
+ 0, 0);
}
}
/* Animate the movement of a single piece */
-static void
+static void
BeginAnimation(anim, piece, startColor, start)
AnimState *anim;
ChessSquare piece;
XPoint * start;
{
Pixmap mask;
-
+
/* The old buffer is initialised with the start square (empty) */
BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
anim->prevFrame = *start;
-
+
/* The piece will be drawn using its own bitmap as a matte */
SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
XSetClipMask(xDisplay, anim->pieceGC, mask);
XRectangle overlap;
XPoint pt;
int count, i;
-
+
/* Save what we are about to draw into the new buffer */
XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
frame->x, frame->y, squareSize, squareSize,
0, 0);
-
+
/* Erase bits of the previous frame */
if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
/* Where the new frame overlapped the previous,
0, 0, squareSize, squareSize,
0, 0);
anim->prevFrame = *frame;
-
+
/* Draw piece over original screen contents, not current,
and copy entire rect. Wipes out overlapping piece images. */
OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);
if (!appData.animate || appData.blindfold)
return;
+ if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
+ board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
+ return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
+
if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
piece = board[fromY][fromX];
if (piece >= EmptySquare) return;
#endif
if (appData.debugMode) {
- printf("AnimateMove: piece %d %s from %d,%d to %d,%d \n",
- piece, hop ? "hops" : "slides", fromX, fromY, toX, toY);
- }
+ fprintf(debugFP, hop ? _("AnimateMove: piece %d hops from %d,%d to %d,%d \n") :
+ _("AnimateMove: piece %d slides from %d,%d to %d,%d \n"),
+ piece, fromX, fromY, toX, toY); }
ScreenSquare(fromX, fromY, &start, &startColor);
ScreenSquare(toX, toY, &finish, &endColor);
mid.x = start.x + (finish.x - start.x) / 2;
mid.y = start.y + (finish.y - start.y) / 2;
}
-
+
/* Don't use as many frames for very short moves */
if (abs(toY - fromY) + abs(toX - fromX) <= 2)
Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
else
Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
-
+
/* Be sure end square is redrawn */
- damage[toY][toX] = True;
+ damage[0][toY][toX] = True;
}
-static void
+void
DragPieceBegin(x, y)
int x; int y;
{
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Figure out which square we start in and the
mouse position relative to top left corner. */
BoardSquare(x, y, &boardX, &boardY);
ScreenSquare(boardX, boardY, &corner, &color);
player.startSquare = corner;
player.startColor = color;
-#if 0
- /* Start from exactly where the piece is. This can be confusing
- if you start dragging far from the center of the square; most
- or all of the piece can be over a different square from the one
- the mouse pointer is in. */
- player.mouseDelta.x = x - corner.x;
- player.mouseDelta.y = y - corner.y;
-#else
/* As soon as we start dragging, the piece will jump slightly to
be centered over the mouse pointer. */
player.mouseDelta.x = squareSize/2;
player.mouseDelta.y = squareSize/2;
-#endif
/* Initialise animation */
player.dragPiece = PieceForSquare(boardX, boardY);
/* Sanity check */
/* Mark this square as needing to be redrawn. Note that
we don't remove the piece though, since logically (ie
as seen by opponent) the move hasn't been made yet. */
- damage[boardY][boardX] = True;
+ if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
+ boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
+ XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
+ corner.x, corner.y, squareSize, squareSize,
+ 0, 0); // [HGM] zh: unstack in stead of grab
+ damage[0][boardY][boardX] = True;
} else {
player.dragActive = False;
}
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Sanity check */
if (! player.dragActive)
return;
corner.x = x - player.mouseDelta.x;
corner.y = y - player.mouseDelta.y;
AnimationFrame(&player, &corner, player.dragPiece);
-#if HIGHDRAG
+#if HIGHDRAG*0
if (appData.highlightDragging) {
int boardX, boardY;
BoardSquare(x, y, &boardX, &boardY);
#endif
}
-static void
+void
DragPieceEnd(x, y)
int x; int y;
{
/* Are we animating? */
if (!appData.animateDragging || appData.blindfold)
return;
-
+
/* Sanity check */
if (! player.dragActive)
return;
EndAnimation(&player, &corner);
/* Be sure end square is redrawn */
- damage[boardY][boardX] = True;
+ damage[0][boardY][boardX] = True;
/* This prevents weird things happening with fast successive
clicks which on my Sun at least can cause motion events
BlankSquare(player.startSquare.x, player.startSquare.y,
player.startColor, EmptySquare, xBoardWindow);
AnimationFrame(&player, &player.prevFrame, player.dragPiece);
- damage[player.startBoardY][player.startBoardX] = TRUE;
+ damage[0][player.startBoardY][player.startBoardX] = TRUE;
+}
+
+#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();
+}
+
+# if HAVE_LIBREADLINE
+static void
+ReadlineCompleteHandler(char* ptr)
+{
+ /* make gnu-readline keep the history */
+ readline_buffer = ptr;
+ readline_complete = 1;
+
+ if (ptr && *ptr && !sending_ICS_password && !sending_ICS_login)
+ add_history(ptr);
+
+ return;
+}
+#endif