-/*\r
- * xboard.c -- X front end for XBoard\r
- * $Id: xboard.c,v 2.2 2003/11/06 07:22:14 mann Exp $\r
- *\r
- * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.\r
- * Enhancements Copyright 1992-2001 Free Software Foundation, Inc.\r
- *\r
- * The following terms apply to Digital Equipment Corporation's copyright\r
- * interest in XBoard:\r
- * ------------------------------------------------------------------------\r
- * All Rights Reserved\r
- *\r
- * Permission to use, copy, modify, and distribute this software and its\r
- * documentation for any purpose and without fee is hereby granted,\r
- * provided that the above copyright notice appear in all copies and that\r
- * both that copyright notice and this permission notice appear in\r
- * supporting documentation, and that the name of Digital not be\r
- * used in advertising or publicity pertaining to distribution of the\r
- * software without specific, written prior permission.\r
- *\r
- * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING\r
- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL\r
- * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR\r
- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\r
- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,\r
- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\r
- * SOFTWARE.\r
- * ------------------------------------------------------------------------\r
- *\r
- * The following terms apply to the enhanced version of XBoard distributed\r
- * by the Free Software Foundation:\r
- * ------------------------------------------------------------------------\r
- * This program is free software; you can redistribute it and/or modify\r
- * it under the terms of the GNU General Public License as published by\r
- * the Free Software Foundation; either version 2 of the License, or\r
- * (at your option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\r
- * ------------------------------------------------------------------------\r
- *\r
- * See the file ChangeLog for a revision history.\r
- */\r
-\r
-#include "config.h"\r
-\r
-#include <stdio.h>\r
-#include <ctype.h>\r
-#include <signal.h>\r
-#include <errno.h>\r
-#include <sys/types.h>\r
-#include <sys/stat.h>\r
-#include <pwd.h>\r
-\r
-#if !OMIT_SOCKETS\r
-# if HAVE_SYS_SOCKET_H\r
-# include <sys/socket.h>\r
-# include <netinet/in.h>\r
-# include <netdb.h>\r
-# else /* not HAVE_SYS_SOCKET_H */\r
-# if HAVE_LAN_SOCKET_H\r
-# include <lan/socket.h>\r
-# include <lan/in.h>\r
-# include <lan/netdb.h>\r
-# else /* not HAVE_LAN_SOCKET_H */\r
-# define OMIT_SOCKETS 1\r
-# endif /* not HAVE_LAN_SOCKET_H */\r
-# endif /* not HAVE_SYS_SOCKET_H */\r
-#endif /* !OMIT_SOCKETS */\r
-\r
-#if STDC_HEADERS\r
-# include <stdlib.h>\r
-# include <string.h>\r
-#else /* not STDC_HEADERS */\r
-extern char *getenv();\r
-# if HAVE_STRING_H\r
-# include <string.h>\r
-# else /* not HAVE_STRING_H */\r
-# include <strings.h>\r
-# endif /* not HAVE_STRING_H */\r
-#endif /* not STDC_HEADERS */\r
-\r
-#if HAVE_SYS_FCNTL_H\r
-# include <sys/fcntl.h>\r
-#else /* not HAVE_SYS_FCNTL_H */\r
-# if HAVE_FCNTL_H\r
-# include <fcntl.h>\r
-# endif /* HAVE_FCNTL_H */\r
-#endif /* not HAVE_SYS_FCNTL_H */\r
-\r
-#if HAVE_SYS_SYSTEMINFO_H\r
-# include <sys/systeminfo.h>\r
-#endif /* HAVE_SYS_SYSTEMINFO_H */\r
-\r
-#if TIME_WITH_SYS_TIME\r
-# include <sys/time.h>\r
-# include <time.h>\r
-#else\r
-# if HAVE_SYS_TIME_H\r
-# include <sys/time.h>\r
-# else\r
-# include <time.h>\r
-# endif\r
-#endif\r
-\r
-#if HAVE_UNISTD_H\r
-# include <unistd.h>\r
-#endif\r
-\r
-#if HAVE_SYS_WAIT_H\r
-# include <sys/wait.h>\r
-#endif\r
-\r
-#if HAVE_DIRENT_H\r
-# include <dirent.h>\r
-# define NAMLEN(dirent) strlen((dirent)->d_name)\r
-# define HAVE_DIR_STRUCT\r
-#else\r
-# define dirent direct\r
-# define NAMLEN(dirent) (dirent)->d_namlen\r
-# if HAVE_SYS_NDIR_H\r
-# include <sys/ndir.h>\r
-# define HAVE_DIR_STRUCT\r
-# endif\r
-# if HAVE_SYS_DIR_H\r
-# include <sys/dir.h>\r
-# define HAVE_DIR_STRUCT\r
-# endif\r
-# if HAVE_NDIR_H\r
-# include <ndir.h>\r
-# define HAVE_DIR_STRUCT\r
-# endif\r
-#endif\r
-\r
-#include <X11/Intrinsic.h>\r
-#include <X11/StringDefs.h>\r
-#include <X11/Shell.h>\r
-#include <X11/cursorfont.h>\r
-#include <X11/Xatom.h>\r
-#if USE_XAW3D\r
-#include <X11/Xaw3d/Dialog.h>\r
-#include <X11/Xaw3d/Form.h>\r
-#include <X11/Xaw3d/List.h>\r
-#include <X11/Xaw3d/Label.h>\r
-#include <X11/Xaw3d/SimpleMenu.h>\r
-#include <X11/Xaw3d/SmeBSB.h>\r
-#include <X11/Xaw3d/SmeLine.h>\r
-#include <X11/Xaw3d/Box.h>\r
-#include <X11/Xaw3d/MenuButton.h>\r
-#include <X11/Xaw3d/Text.h>\r
-#include <X11/Xaw3d/AsciiText.h>\r
-#else\r
-#include <X11/Xaw/Dialog.h>\r
-#include <X11/Xaw/Form.h>\r
-#include <X11/Xaw/List.h>\r
-#include <X11/Xaw/Label.h>\r
-#include <X11/Xaw/SimpleMenu.h>\r
-#include <X11/Xaw/SmeBSB.h>\r
-#include <X11/Xaw/SmeLine.h>\r
-#include <X11/Xaw/Box.h>\r
-#include <X11/Xaw/MenuButton.h>\r
-#include <X11/Xaw/Text.h>\r
-#include <X11/Xaw/AsciiText.h>\r
-#endif\r
-\r
-// [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.\r
-#include "common.h"\r
-\r
-#if HAVE_LIBXPM\r
-#include <X11/xpm.h>\r
-#include "pixmaps/pixmaps.h"\r
-#define IMAGE_EXT "xpm"\r
-#else\r
-#define IMAGE_EXT "xim"\r
-#include "bitmaps/bitmaps.h"\r
-#endif\r
-\r
-#include "bitmaps/icon_white.bm"\r
-#include "bitmaps/icon_black.bm"\r
-#include "bitmaps/checkmark.bm"\r
-\r
-#include "frontend.h"\r
-#include "backend.h"\r
-#include "moves.h"\r
-#include "xboard.h"\r
-#include "childio.h"\r
-#include "xgamelist.h"\r
-#include "xhistory.h"\r
-#include "xedittags.h"\r
-\r
-#ifdef __EMX__\r
-#ifndef HAVE_USLEEP\r
-#define HAVE_USLEEP\r
-#endif\r
-#define usleep(t) _sleep2(((t)+500)/1000)\r
-#endif\r
-\r
-typedef struct {\r
- String string;\r
- XtActionProc proc;\r
-} MenuItem;\r
-\r
-typedef struct {\r
- String name;\r
- MenuItem *mi;\r
-} Menu;\r
-\r
-int main P((int argc, char **argv));\r
-RETSIGTYPE CmailSigHandler P((int sig));\r
-RETSIGTYPE IntSigHandler P((int sig));\r
-void CreateGCs P((void));\r
-void CreateXIMPieces P((void));\r
-void CreateXPMPieces P((void));\r
-void CreatePieces P((void));\r
-void CreatePieceMenus P((void));\r
-Widget CreateMenuBar P((Menu *mb));\r
-Widget CreateButtonBar P ((MenuItem *mi));\r
-char *FindFont P((char *pattern, int targetPxlSize));\r
-void PieceMenuPopup P((Widget w, XEvent *event,\r
- String *params, Cardinal *num_params));\r
-static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));\r
-static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));\r
-void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],\r
- u_int wreq, u_int hreq));\r
-void CreateGrid P((void));\r
-int EventToSquare P((int x, int limit));\r
-void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));\r
-void EventProc P((Widget widget, caddr_t unused, XEvent *event));\r
-void HandleUserMove P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AnimateUserMove P((Widget w, XEvent * event,\r
- String * params, Cardinal * nParams));\r
-void WhiteClock P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void BlackClock P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void DrawPositionProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void XDrawPosition P((Widget w, /*Boolean*/int repaint, \r
- Board board));\r
-void CommentPopUp P((char *title, char *label));\r
-void CommentPopDown P((void));\r
-void CommentCallback P((Widget w, XtPointer client_data,\r
- XtPointer call_data));\r
-void ICSInputBoxPopUp P((void));\r
-void ICSInputBoxPopDown P((void));\r
-void FileNamePopUp P((char *label, char *def,\r
- FileProc proc, char *openMode));\r
-void FileNamePopDown P((void));\r
-void FileNameCallback P((Widget w, XtPointer client_data,\r
- XtPointer call_data));\r
-void FileNameAction P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AskQuestionReplyAction P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AskQuestionProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AskQuestionPopDown P((void));\r
-void PromotionPopUp P((void));\r
-void PromotionPopDown P((void));\r
-void PromotionCallback P((Widget w, XtPointer client_data,\r
- XtPointer call_data));\r
-void EditCommentPopDown P((void));\r
-void EditCommentCallback P((Widget w, XtPointer client_data,\r
- XtPointer call_data));\r
-void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));\r
-void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void LoadNextGameProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void ReloadGameProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void LoadPositionProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void ReloadPositionProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void CopyPositionProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PastePositionProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void SavePositionProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void MachineBlackProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void MachineWhiteProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AnalyzeModeProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AnalyzeFileProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void TwoMachinesProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void IcsClientProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void EditPositionProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void EditCommentProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void IcsInputBoxProc P((Widget w, XEvent *event,\r
- String *prms, Cardinal *nprms));\r
-void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void StopObservingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void StopExaminingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void TruncateGameProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void RetractMoveProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void AnimateMovingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void AutocommProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AutobsProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void FlashMovesProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void GetMoveListProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ShowCoordsProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void ShowThinkingProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void TestLegalityProc P((Widget w, XEvent *event, String *prms,\r
- Cardinal *nprms));\r
-void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));\r
-void DisplayMove P((int moveNumber));\r
-void DisplayTitle P((char *title));\r
-void ICSInitScript P((void));\r
-int LoadGamePopUp P((FILE *f, int gameNumber, char *title));\r
-void ErrorPopUp P((char *title, char *text, int modal));\r
-void ErrorPopDown P((void));\r
-static char *ExpandPathName P((char *path));\r
-static void CreateAnimVars P((void));\r
-static void DragPieceBegin P((int x, int y));\r
-static void DragPieceMove P((int x, int y));\r
-static void DragPieceEnd P((int x, int y));\r
-static void DrawDragPiece P((void));\r
-char *ModeToWidgetName P((GameMode mode));\r
-\r
-/*\r
-* XBoard depends on Xt R4 or higher\r
-*/\r
-int xtVersion = XtSpecificationRelease;\r
-\r
-int xScreen;\r
-Display *xDisplay;\r
-Window xBoardWindow;\r
-Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,\r
- jailSquareColor, highlightSquareColor, premoveHighlightColor;\r
-GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,\r
- bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,\r
- wjPieceGC, bjPieceGC, prelineGC;\r
-Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;\r
-Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget, \r
- whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16], \r
- commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,\r
- menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,\r
- ICSInputShell, fileNameShell, askQuestionShell;\r
-XSegment gridSegments[(BOARD_SIZE + 1) * 2];\r
-XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];\r
-Font clockFontID, coordFontID;\r
-XFontStruct *clockFontStruct, *coordFontStruct;\r
-XtAppContext appContext;\r
-char *layoutName;\r
-char *oldICSInteractionTitle;\r
-\r
-FileProc fileProc;\r
-char *fileOpenMode;\r
-\r
-Position commentX = -1, commentY = -1;\r
-Dimension commentW, commentH;\r
-\r
-int squareSize, smallLayout = 0, tinyLayout = 0,\r
- fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,\r
- ICSInputBoxUp = False, askQuestionUp = False,\r
- filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,\r
- editUp = False, errorUp = False, errorExitStatus = -1, lineGap;\r
-Pixel timerForegroundPixel, timerBackgroundPixel;\r
-Pixel buttonForegroundPixel, buttonBackgroundPixel;\r
-char *chessDir, *programName, *programVersion,\r
- *gameCopyFilename, *gamePasteFilename;\r
-\r
-#define SOLID 0\r
-#define OUTLINE 1\r
-Pixmap pieceBitmap[2][(int)BlackPawn];\r
-Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD */\r
-Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;\r
-int useImages, useImageSqs;\r
-XImage *ximPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD */\r
-Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */\r
-XImage *ximLightSquare, *ximDarkSquare;\r
-XImage *xim_Cross;\r
-\r
-#define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % (int)BlackPawn]\r
-#define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % (int)BlackPawn]\r
-\r
-#define White(piece) ((int)(piece) < (int)BlackPawn)\r
-\r
-/* Variables for doing smooth animation. This whole thing\r
- would be much easier if the board was double-buffered,\r
- but that would require a fairly major rewrite. */\r
-\r
-typedef struct {\r
- Pixmap saveBuf;\r
- Pixmap newBuf;\r
- GC blitGC, pieceGC, outlineGC;\r
- XPoint startSquare, prevFrame, mouseDelta;\r
- int startColor;\r
- int dragPiece;\r
- Boolean dragActive;\r
- int startBoardX, startBoardY;\r
- } AnimState;\r
-\r
-/* There can be two pieces being animated at once: a player\r
- can begin dragging a piece before the remote opponent has moved. */\r
-\r
-static AnimState game, player;\r
-\r
-/* Bitmaps for use as masks when drawing XPM pieces.\r
- Need one for each black and white piece. */\r
-static Pixmap xpmMask[BlackKing + 1];\r
-\r
-/* This magic number is the number of intermediate frames used\r
- in each half of the animation. For short moves it's reduced\r
- by 1. The total number of frames will be factor * 2 + 1. */\r
-#define kFactor 4\r
-\r
-SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;\r
-\r
-MenuItem fileMenu[] = {\r
- {"Reset Game", ResetProc},\r
- {"----", NothingProc},\r
- {"Load Game", LoadGameProc},\r
- {"Load Next Game", LoadNextGameProc},\r
- {"Load Previous Game", LoadPrevGameProc},\r
- {"Reload Same Game", ReloadGameProc},\r
- {"Save Game", SaveGameProc},\r
- {"----", NothingProc},\r
- {"Copy Game", CopyGameProc},\r
- {"Paste Game", PasteGameProc},\r
- {"----", NothingProc},\r
- {"Load Position", LoadPositionProc},\r
- {"Load Next Position", LoadNextPositionProc},\r
- {"Load Previous Position", LoadPrevPositionProc},\r
- {"Reload Same Position", ReloadPositionProc},\r
- {"Save Position", SavePositionProc},\r
- {"----", NothingProc},\r
- {"Copy Position", CopyPositionProc},\r
- {"Paste Position", PastePositionProc},\r
- {"----", NothingProc},\r
- {"Mail Move", MailMoveProc},\r
- {"Reload CMail Message", ReloadCmailMsgProc},\r
- {"----", NothingProc},\r
- {"Exit", QuitProc},\r
- {NULL, NULL}\r
-};\r
-\r
-MenuItem modeMenu[] = {\r
- {"Machine White", MachineWhiteProc},\r
- {"Machine Black", MachineBlackProc},\r
- {"Two Machines", TwoMachinesProc},\r
- {"Analysis Mode", AnalyzeModeProc},\r
- {"Analyze File", AnalyzeFileProc },\r
- {"ICS Client", IcsClientProc},\r
- {"Edit Game", EditGameProc},\r
- {"Edit Position", EditPositionProc},\r
- {"Training", TrainingProc},\r
- {"----", NothingProc},\r
- {"Show Game List", ShowGameListProc},\r
- {"Show Move List", HistoryShowProc},\r
- {"Edit Tags", EditTagsProc},\r
- {"Edit Comment", EditCommentProc},\r
- {"ICS Input Box", IcsInputBoxProc},\r
- {"Pause", PauseProc},\r
- {NULL, NULL}\r
-};\r
-\r
-MenuItem actionMenu[] = {\r
- {"Accept", AcceptProc},\r
- {"Decline", DeclineProc},\r
- {"Rematch", RematchProc},\r
- {"----", NothingProc}, \r
- {"Call Flag", CallFlagProc},\r
- {"Draw", DrawProc},\r
- {"Adjourn", AdjournProc},\r
- {"Abort", AbortProc},\r
- {"Resign", ResignProc},\r
- {"----", NothingProc}, \r
- {"Stop Observing", StopObservingProc},\r
- {"Stop Examining", StopExaminingProc},\r
- {NULL, NULL}\r
-};\r
-\r
-MenuItem stepMenu[] = {\r
- {"Backward", BackwardProc},\r
- {"Forward", ForwardProc},\r
- {"Back to Start", ToStartProc},\r
- {"Forward to End", ToEndProc},\r
- {"Revert", RevertProc},\r
- {"Truncate Game", TruncateGameProc},\r
- {"----", NothingProc}, \r
- {"Move Now", MoveNowProc},\r
- {"Retract Move", RetractMoveProc},\r
- {NULL, NULL}\r
-}; \r
-\r
-MenuItem optionsMenu[] = {\r
- {"Always Queen", AlwaysQueenProc},\r
- {"Animate Dragging", AnimateDraggingProc},\r
- {"Animate Moving", AnimateMovingProc},\r
- {"Auto Comment", AutocommProc},\r
- {"Auto Flag", AutoflagProc},\r
- {"Auto Flip View", AutoflipProc},\r
- {"Auto Observe", AutobsProc},\r
- {"Auto Raise Board", AutoraiseProc},\r
- {"Auto Save", AutosaveProc},\r
- {"Blindfold", BlindfoldProc},\r
- {"Flash Moves", FlashMovesProc},\r
- {"Flip View", FlipViewProc},\r
- {"Get Move List", GetMoveListProc},\r
-#if HIGHDRAG\r
- {"Highlight Dragging", HighlightDraggingProc},\r
-#endif\r
- {"Highlight Last Move", HighlightLastMoveProc},\r
- {"Move Sound", MoveSoundProc},\r
- {"ICS Alarm", IcsAlarmProc},\r
- {"Old Save Style", OldSaveStyleProc},\r
- {"Periodic Updates", PeriodicUpdatesProc}, \r
- {"Ponder Next Move", PonderNextMoveProc},\r
- {"Popup Exit Message", PopupExitMessageProc}, \r
- {"Popup Move Errors", PopupMoveErrorsProc}, \r
- {"Premove", PremoveProc},\r
- {"Quiet Play", QuietPlayProc},\r
- {"Show Coords", ShowCoordsProc},\r
- {"Show Thinking", ShowThinkingProc},\r
- {"Test Legality", TestLegalityProc},\r
- {NULL, NULL}\r
-};\r
-\r
-MenuItem helpMenu[] = {\r
- {"Info XBoard", InfoProc},\r
- {"Man XBoard", ManProc},\r
- {"----", NothingProc},\r
- {"Hint", HintProc},\r
- {"Book", BookProc},\r
- {"----", NothingProc},\r
- {"About XBoard", AboutProc},\r
- {NULL, NULL}\r
-};\r
-\r
-Menu menuBar[] = {\r
- {"File", fileMenu},\r
- {"Mode", modeMenu},\r
- {"Action", actionMenu},\r
- {"Step", stepMenu},\r
- {"Options", optionsMenu},\r
- {"Help", helpMenu},\r
- {NULL, NULL}\r
-};\r
-\r
-#define PAUSE_BUTTON "P"\r
-MenuItem buttonBar[] = {\r
- {"<<", ToStartProc},\r
- {"<", BackwardProc},\r
- {PAUSE_BUTTON, PauseProc},\r
- {">", ForwardProc},\r
- {">>", ToEndProc},\r
- {NULL, NULL}\r
-};\r
-\r
-#define PIECE_MENU_SIZE 11\r
-String pieceMenuStrings[2][PIECE_MENU_SIZE] = {\r
- { "White", "----", "Pawn", "Knight", "Bishop", "Rook", "Queen", "King",\r
- "----", "Empty square", "Clear board" },\r
- { "Black", "----", "Pawn", "Knight", "Bishop", "Rook", "Queen", "King",\r
- "----", "Empty square", "Clear board" },\r
- };\r
-/* must be in same order as PieceMenuStrings! */\r
-ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {\r
- { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,\r
- WhiteRook, WhiteQueen, WhiteKing,\r
- (ChessSquare) 0, EmptySquare, ClearBoard },\r
- { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,\r
- BlackRook, BlackQueen, BlackKing,\r
- (ChessSquare) 0, EmptySquare, ClearBoard },\r
-};\r
-\r
-#define DROP_MENU_SIZE 6\r
-String dropMenuStrings[DROP_MENU_SIZE] = {\r
- "----", "Pawn", "Knight", "Bishop", "Rook", "Queen"\r
- };\r
-/* must be in same order as PieceMenuStrings! */\r
-ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {\r
- (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,\r
- WhiteRook, WhiteQueen\r
-};\r
-\r
-typedef struct {\r
- char piece;\r
- char* widget;\r
-} DropMenuEnables;\r
-\r
-DropMenuEnables dmEnables[] = {\r
- { 'P', "Pawn" },\r
- { 'N', "Knight" },\r
- { 'B', "Bishop" },\r
- { 'R', "Rook" },\r
- { 'Q', "Queen" }\r
-};\r
-\r
-Arg shellArgs[] = {\r
- { XtNwidth, 0 },\r
- { XtNheight, 0 },\r
- { XtNminWidth, 0 },\r
- { XtNminHeight, 0 },\r
- { XtNmaxWidth, 0 },\r
- { XtNmaxHeight, 0 }\r
-};\r
-\r
-Arg layoutArgs[] = {\r
- { XtNborderWidth, 0 },\r
- { XtNdefaultDistance, 0 },\r
-};\r
-\r
-Arg formArgs[] = {\r
- { XtNborderWidth, 0 },\r
- { XtNresizable, (XtArgVal) True },\r
-};\r
-\r
-Arg boardArgs[] = {\r
- { XtNborderWidth, 0 },\r
- { XtNwidth, 0 },\r
- { XtNheight, 0 }\r
-};\r
-\r
-Arg titleArgs[] = {\r
- { XtNjustify, (XtArgVal) XtJustifyRight },\r
- { XtNlabel, (XtArgVal) "..." },\r
- { XtNresizable, (XtArgVal) True },\r
- { XtNresize, (XtArgVal) False }\r
-};\r
-\r
-Arg messageArgs[] = {\r
- { XtNjustify, (XtArgVal) XtJustifyLeft },\r
- { XtNlabel, (XtArgVal) "..." },\r
- { XtNresizable, (XtArgVal) True },\r
- { XtNresize, (XtArgVal) False }\r
-};\r
-\r
-Arg timerArgs[] = {\r
- { XtNborderWidth, 0 },\r
- { XtNjustify, (XtArgVal) XtJustifyLeft }\r
-};\r
-\r
-XtResource clientResources[] = {\r
- { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, whitePieceColor), XtRString,\r
- WHITE_PIECE_COLOR },\r
- { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, blackPieceColor), XtRString,\r
- BLACK_PIECE_COLOR },\r
- { "lightSquareColor", "lightSquareColor", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, lightSquareColor),\r
- XtRString, LIGHT_SQUARE_COLOR }, \r
- { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, darkSquareColor), XtRString,\r
- DARK_SQUARE_COLOR },\r
- { "highlightSquareColor", "highlightSquareColor", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),\r
- XtRString, HIGHLIGHT_SQUARE_COLOR },\r
- { "premoveHighlightColor", "premoveHighlightColor", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),\r
- XtRString, PREMOVE_HIGHLIGHT_COLOR },\r
- { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, movesPerSession), XtRImmediate,\r
- (XtPointer) MOVES_PER_SESSION },\r
- { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, timeIncrement), XtRImmediate,\r
- (XtPointer) TIME_INCREMENT },\r
- { "initString", "initString", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },\r
- { "secondInitString", "secondInitString", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },\r
- { "firstComputerString", "firstComputerString", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,\r
- COMPUTER_STRING },\r
- { "secondComputerString", "secondComputerString", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,\r
- COMPUTER_STRING },\r
- { "firstChessProgram", "firstChessProgram", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, firstChessProgram),\r
- XtRString, FIRST_CHESS_PROGRAM },\r
- { "secondChessProgram", "secondChessProgram", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, secondChessProgram),\r
- XtRString, SECOND_CHESS_PROGRAM },\r
- { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),\r
- XtRImmediate, (XtPointer) False },\r
- { "noChessProgram", "noChessProgram", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),\r
- XtRImmediate, (XtPointer) False },\r
- { "firstHost", "firstHost", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },\r
- { "secondHost", "secondHost", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },\r
- { "firstDirectory", "firstDirectory", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, firstDirectory), XtRString, FIRST_DIRECTORY },\r
- { "secondDirectory", "secondDirectory", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, secondDirectory), XtRString, SECOND_DIRECTORY },\r
- { "bitmapDirectory", "bitmapDirectory", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),\r
- XtRString, "" },\r
- { "remoteShell", "remoteShell", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },\r
- { "remoteUser", "remoteUser", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, remoteUser), XtRString, "" },\r
- { "timeDelay", "timeDelay", XtRFloat, sizeof(float),\r
- XtOffset(AppDataPtr, timeDelay), XtRString,\r
- (XtPointer) TIME_DELAY_QUOTE },\r
- { "timeControl", "timeControl", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, timeControl), XtRString,\r
- (XtPointer) TIME_CONTROL },\r
- { "internetChessServerMode", "internetChessServerMode",\r
- XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, icsActive), XtRImmediate,\r
- (XtPointer) False },\r
- { "internetChessServerHost", "internetChessServerHost",\r
- XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, icsHost),\r
- XtRString, (XtPointer) ICS_HOST },\r
- { "internetChessServerPort", "internetChessServerPort",\r
- XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, icsPort), XtRString,\r
- (XtPointer) ICS_PORT },\r
- { "internetChessServerCommPort", "internetChessServerCommPort",\r
- XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, icsCommPort), XtRString,\r
- ICS_COMM_PORT },\r
- { "internetChessServerLogonScript", "internetChessServerLogonScript",\r
- XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, icsLogon), XtRString,\r
- ICS_LOGON },\r
- { "internetChessServerHelper", "internetChessServerHelper",\r
- XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, icsHelper), XtRString, "" },\r
- { "internetChessServerInputBox", "internetChessServerInputBox",\r
- XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, icsInputBox), XtRImmediate,\r
- (XtPointer) False },\r
- { "icsAlarm", "icsAlarm",\r
- XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, icsAlarm), XtRImmediate,\r
- (XtPointer) True },\r
- { "icsAlarmTime", "icsAlarmTime",\r
- XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,\r
- (XtPointer) 5000 },\r
- { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, useTelnet), XtRImmediate,\r
- (XtPointer) False },\r
- { "telnetProgram", "telnetProgram", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },\r
- { "gateway", "gateway", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, gateway), XtRString, "" },\r
- { "loadGameFile", "loadGameFile", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, loadGameFile), XtRString, "" },\r
- { "loadGameIndex", "loadGameIndex",\r
- XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,\r
- (XtPointer) 0 },\r
- { "saveGameFile", "saveGameFile", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, saveGameFile), XtRString, "" },\r
- { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),\r
- XtRImmediate, (XtPointer) True },\r
- { "autoSaveGames", "autoSaveGames", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),\r
- XtRImmediate, (XtPointer) False },\r
- { "blindfold", "blindfold", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, blindfold),\r
- XtRImmediate, (XtPointer) False },\r
- { "loadPositionFile", "loadPositionFile", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, loadPositionFile),\r
- XtRString, "" },\r
- { "loadPositionIndex", "loadPositionIndex",\r
- XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,\r
- (XtPointer) 1 },\r
- { "savePositionFile", "savePositionFile", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, savePositionFile),\r
- XtRString, "" },\r
- { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },\r
- { "matchGames", "matchGames", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, matchGames), XtRImmediate,\r
- (XtPointer) 0 },\r
- { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, monoMode), XtRImmediate,\r
- (XtPointer) False },\r
- { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, debugMode), XtRImmediate,\r
- (XtPointer) False },\r
- { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, clockMode), XtRImmediate,\r
- (XtPointer) True },\r
- { "boardSize", "boardSize", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, boardSize), XtRString, "" },\r
- { "searchTime", "searchTime", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, searchTime), XtRString,\r
- (XtPointer) "" },\r
- { "searchDepth", "searchDepth", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, searchDepth), XtRImmediate, \r
- (XtPointer) 0 },\r
- { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, showCoords), XtRImmediate,\r
- (XtPointer) False },\r
- { "showJail", "showJail", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, showJail), XtRImmediate,\r
- (XtPointer) 0 },\r
- { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, showThinking), XtRImmediate,\r
- (XtPointer) False },\r
- { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,\r
- (XtPointer) True },\r
- { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,\r
- (XtPointer) True },\r
- { "clockFont", "clockFont", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },\r
- { "coordFont", "coordFont", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },\r
- { "font", "font", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },\r
- { "ringBellAfterMoves", "ringBellAfterMoves",\r
- XtRBoolean, sizeof(Boolean),\r
- XtOffset(AppDataPtr, ringBellAfterMoves),\r
- XtRImmediate, (XtPointer) False },\r
- { "autoCallFlag", "autoCallFlag", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),\r
- XtRImmediate, (XtPointer) False },\r
- { "autoFlipView", "autoFlipView", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),\r
- XtRImmediate, (XtPointer) True },\r
- { "autoObserve", "autoObserve", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),\r
- XtRImmediate, (XtPointer) False },\r
- { "autoComment", "autoComment", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoComment),\r
- XtRImmediate, (XtPointer) False },\r
- { "getMoveList", "getMoveList", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),\r
- XtRImmediate, (XtPointer) True },\r
-#if HIGHDRAG\r
- { "highlightDragging", "highlightDragging", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),\r
- XtRImmediate, (XtPointer) False },\r
-#endif\r
- { "highlightLastMove", "highlightLastMove", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),\r
- XtRImmediate, (XtPointer) False },\r
- { "premove", "premove", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, premove),\r
- XtRImmediate, (XtPointer) True },\r
- { "testLegality", "testLegality", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, testLegality),\r
- XtRImmediate, (XtPointer) True },\r
- { "flipView", "flipView", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, flipView),\r
- XtRImmediate, (XtPointer) False },\r
- { "cmail", "cmailGameName", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, cmailGameName), XtRString, "" },\r
- { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),\r
- XtRImmediate, (XtPointer) False },\r
- { "oldSaveStyle", "oldSaveStyle", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),\r
- XtRImmediate, (XtPointer) False },\r
- { "quietPlay", "quietPlay", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),\r
- XtRImmediate, (XtPointer) False },\r
- { "titleInWindow", "titleInWindow", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),\r
- XtRImmediate, (XtPointer) False },\r
- { "localLineEditing", "localLineEditing", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),\r
- XtRImmediate, (XtPointer) True }, /* not implemented, must be True */\r
-#ifdef ZIPPY\r
- { "zippyTalk", "zippyTalk", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),\r
- XtRImmediate, (XtPointer) ZIPPY_TALK },\r
- { "zippyPlay", "zippyPlay", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),\r
- XtRImmediate, (XtPointer) ZIPPY_PLAY },\r
- { "zippyLines", "zippyLines", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },\r
- { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },\r
- { "zippyPassword", "zippyPassword", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },\r
- { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },\r
- { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyWrongPassword), XtRString,\r
- ZIPPY_WRONG_PASSWORD },\r
- { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },\r
- { "zippyUseI", "zippyUseI", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),\r
- XtRImmediate, (XtPointer) ZIPPY_USE_I },\r
- { "zippyBughouse", "zippyBughouse", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, zippyBughouse),\r
- XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },\r
- { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),\r
- XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },\r
- { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },\r
- { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },\r
- { "zippyAdjourn", "zippyAdjourn", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),\r
- XtRImmediate, (XtPointer) ZIPPY_ADJOURN },\r
- { "zippyAbort", "zippyAbort", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),\r
- XtRImmediate, (XtPointer) ZIPPY_ABORT },\r
- { "zippyVariants", "zippyVariants", XtRString, sizeof(String),\r
- XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },\r
- { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,\r
- (XtPointer) ZIPPY_MAX_GAMES },\r
- { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,\r
- (XtPointer) ZIPPY_REPLAY_TIMEOUT },\r
-#endif\r
- { "flashCount", "flashCount", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, flashCount), XtRImmediate,\r
- (XtPointer) FLASH_COUNT },\r
- { "flashRate", "flashRate", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, flashRate), XtRImmediate,\r
- (XtPointer) FLASH_RATE },\r
- { "pixmapDirectory", "pixmapDirectory", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),\r
- XtRString, "" },\r
- { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),\r
- XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,\r
- (XtPointer) MS_LOGIN_DELAY },\r
- { "colorizeMessages", "colorizeMessages", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, colorize),\r
- XtRImmediate, (XtPointer) False }, \r
- { "colorShout", "colorShout", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorShout),\r
- XtRString, COLOR_SHOUT },\r
- { "colorSShout", "colorSShout", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorSShout),\r
- XtRString, COLOR_SSHOUT },\r
- { "colorChannel1", "colorChannel1", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorChannel1),\r
- XtRString, COLOR_CHANNEL1 },\r
- { "colorChannel", "colorChannel", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorChannel),\r
- XtRString, COLOR_CHANNEL },\r
- { "colorKibitz", "colorKibitz", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorKibitz),\r
- XtRString, COLOR_KIBITZ },\r
- { "colorTell", "colorTell", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorTell),\r
- XtRString, COLOR_TELL },\r
- { "colorChallenge", "colorChallenge", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorChallenge),\r
- XtRString, COLOR_CHALLENGE },\r
- { "colorRequest", "colorRequest", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorRequest),\r
- XtRString, COLOR_REQUEST },\r
- { "colorSeek", "colorSeek", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorSeek),\r
- XtRString, COLOR_SEEK },\r
- { "colorNormal", "colorNormal", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, colorNormal),\r
- XtRString, COLOR_NORMAL }, \r
- { "soundProgram", "soundProgram", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundProgram),\r
- XtRString, "play" },\r
- { "soundShout", "soundShout", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundShout),\r
- XtRString, "" },\r
- { "soundSShout", "soundSShout", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundSShout),\r
- XtRString, "" },\r
- { "soundChannel1", "soundChannel1", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundChannel1),\r
- XtRString, "" },\r
- { "soundChannel", "soundChannel", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundChannel),\r
- XtRString, "" },\r
- { "soundKibitz", "soundKibitz", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundKibitz),\r
- XtRString, "" },\r
- { "soundTell", "soundTell", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundTell),\r
- XtRString, "" },\r
- { "soundChallenge", "soundChallenge", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundChallenge),\r
- XtRString, "" },\r
- { "soundRequest", "soundRequest", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundRequest),\r
- XtRString, "" },\r
- { "soundSeek", "soundSeek", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundSeek),\r
- XtRString, "" },\r
- { "soundMove", "soundMove", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundMove),\r
- XtRString, "$" },\r
- { "soundIcsWin", "soundIcsWin", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundIcsWin),\r
- XtRString, "" },\r
- { "soundIcsLoss", "soundIcsLoss", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),\r
- XtRString, "" },\r
- { "soundIcsDraw", "soundIcsDraw", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),\r
- XtRString, "" },\r
- { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),\r
- XtRString, "" },\r
- { "soundIcsAlarm", "soundIcsAlarm", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),\r
- XtRString, "$" },\r
- { "reuseFirst", "reuseFirst", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),\r
- XtRImmediate, (XtPointer) True },\r
- { "reuseSecond", "reuseSecond", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),\r
- XtRImmediate, (XtPointer) True },\r
- { "animateDragging", "animateDragging", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),\r
- XtRImmediate, (XtPointer) True },\r
- { "animateMoving", "animateMoving", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, animate),\r
- XtRImmediate, (XtPointer) True },\r
- { "animateSpeed", "animateSpeed", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, animSpeed),\r
- XtRImmediate, (XtPointer)10 },\r
- { "popupExitMessage", "popupExitMessage", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),\r
- XtRImmediate, (XtPointer) True },\r
- { "popupMoveErrors", "popupMoveErrors", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),\r
- XtRImmediate, (XtPointer) False },\r
- { "fontSizeTolerance", "fontSizeTolerance", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),\r
- XtRImmediate, (XtPointer)4 },\r
- { "initialMode", "initialMode", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, initialMode),\r
- XtRImmediate, (XtPointer) "" },\r
- { "variant", "variant", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, variant),\r
- XtRImmediate, (XtPointer) "normal" },\r
- { "firstProtocolVersion", "firstProtocolVersion", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),\r
- XtRImmediate, (XtPointer)PROTOVER },\r
- { "secondProtocolVersion", "secondProtocolVersion", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),\r
- XtRImmediate, (XtPointer)PROTOVER },\r
- { "showButtonBar", "showButtonBar", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),\r
- XtRImmediate, (XtPointer) True },\r
- { "firstScoreAbs", "firstScoreAbs", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),\r
- XtRImmediate, (XtPointer) False },\r
- { "secondScoreAbs", "secondScoreAbs", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),\r
- XtRImmediate, (XtPointer) False },\r
- { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),\r
- XtRImmediate, (XtPointer) False },\r
- { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),\r
- XtRImmediate, (XtPointer) False },\r
- { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),\r
- XtRImmediate, (XtPointer) 0},\r
- { "pgnEventHeader", "pgnEventHeader", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),\r
- XtRImmediate, (XtPointer) "Computer Chess Game" }, \r
- { "defaultFrcPosition", "defaultFrcPosition", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),\r
- XtRImmediate, (XtPointer) -1 }, \r
-\r
- // [HGM] 4.3.xx options\r
- { "boardWidth", "boardWidth", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, NrFiles),\r
- XtRImmediate, (XtPointer) -1},\r
- { "boardHeight", "boardHeight", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, NrRanks),\r
- XtRImmediate, (XtPointer) -1},\r
- { "matchPause", "matchPause", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, matchPause),\r
- XtRImmediate, (XtPointer) 10000},\r
- { "holdingsSize", "holdingsSize", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, holdingsSize),\r
- XtRImmediate, (XtPointer) -1},\r
- { "flipBlack", "flipBlack", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),\r
- XtRImmediate, (XtPointer) False},\r
- { "allWhite", "allWhite", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, allWhite),\r
- XtRImmediate, (XtPointer) False},\r
- { "pieceToCharTable", "pieceToCharTable", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),\r
- XtRImmediate, (XtPointer) 0},\r
- { "alphaRank", "alphaRank", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),\r
- XtRImmediate, (XtPointer) False},\r
- { "testClaims", "testClaims", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, testClaims),\r
- XtRImmediate, (XtPointer) False},\r
- { "checkMates", "checkMates", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, checkMates),\r
- XtRImmediate, (XtPointer) False},\r
- { "materialDraws", "materialDraws", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),\r
- XtRImmediate, (XtPointer) False},\r
- { "trivialDraws", "trivialDraws", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),\r
- XtRImmediate, (XtPointer) False},\r
- { "ruleMoves", "ruleMoves", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, ruleMoves),\r
- XtRImmediate, (XtPointer) 51},\r
- { "repeatsToDraw", "repeatsToDraw", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, drawRepeats),\r
- XtRImmediate, (XtPointer) 6},\r
- { "engineDebugOutput", "engineDebugOutput", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, engineComments),\r
- XtRImmediate, (XtPointer) 1},\r
- { "userName", "userName", XtRString,\r
- sizeof(int), XtOffset(AppDataPtr, userName),\r
- XtRImmediate, (XtPointer) 0},\r
- { "autoKibitz", "autoKibitz", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),\r
- XtRImmediate, (XtPointer) False},\r
- { "firstTimeOdds", "firstTimeOdds", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),\r
- XtRImmediate, (XtPointer) 1},\r
- { "secondTimeOdds", "secondTimeOdds", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),\r
- XtRImmediate, (XtPointer) 1},\r
- { "timeOddsMode", "timeOddsMode", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, timeOddsMode),\r
- XtRImmediate, (XtPointer) 0},\r
- { "firstAccumulateTC", "firstAccumulateTC", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),\r
- XtRImmediate, (XtPointer) 1},\r
- { "secondAccumulateTC", "secondAccumulateTC", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),\r
- XtRImmediate, (XtPointer) 1},\r
- { "firstNPS", "firstNPS", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, firstNPS),\r
- XtRImmediate, (XtPointer) -1},\r
- { "secondNPS", "secondNPS", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, secondNPS),\r
- XtRImmediate, (XtPointer) -1},\r
- { "serverMoves", "serverMoves", XtRString,\r
- sizeof(String), XtOffset(AppDataPtr, serverMovesName),\r
- XtRImmediate, (XtPointer) 0},\r
- { "serverPause", "serverPause", XtRInt,\r
- sizeof(int), XtOffset(AppDataPtr, serverPause),\r
- XtRImmediate, (XtPointer) 0},\r
- { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,\r
- sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),\r
- XtRImmediate, (XtPointer) False},\r
-};\r
-\r
-XrmOptionDescRec shellOptions[] = {\r
- { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },\r
- { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },\r
- { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },\r
- { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },\r
- { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },\r
- { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},\r
- { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },\r
- { "-mps", "movesPerSession", XrmoptionSepArg, NULL },\r
- { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },\r
- { "-inc", "timeIncrement", XrmoptionSepArg, NULL },\r
- { "-initString", "initString", XrmoptionSepArg, NULL },\r
- { "-firstInitString", "initString", XrmoptionSepArg, NULL },\r
- { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },\r
- { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },\r
- { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },\r
- { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },\r
- { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },\r
- { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },\r
- { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },\r
- { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },\r
- { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },\r
- { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },\r
- { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },\r
- { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },\r
- { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },\r
- { "-firstHost", "firstHost", XrmoptionSepArg, NULL },\r
- { "-fh", "firstHost", XrmoptionSepArg, NULL },\r
- { "-secondHost", "secondHost", XrmoptionSepArg, NULL },\r
- { "-sh", "secondHost", XrmoptionSepArg, NULL },\r
- { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },\r
- { "-fd", "firstDirectory", XrmoptionSepArg, NULL },\r
- { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },\r
- { "-sd", "secondDirectory", XrmoptionSepArg, NULL },\r
- { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },\r
- { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },\r
- { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },\r
- { "-rsh", "remoteShell", XrmoptionSepArg, NULL },\r
- { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },\r
- { "-ruser", "remoteUser", XrmoptionSepArg, NULL },\r
- { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },\r
- { "-td", "timeDelay", XrmoptionSepArg, NULL },\r
- { "-timeControl", "timeControl", XrmoptionSepArg, NULL },\r
- { "-tc", "timeControl", XrmoptionSepArg, NULL },\r
- { "-internetChessServerMode", "internetChessServerMode",\r
- XrmoptionSepArg, NULL },\r
- { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },\r
- { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },\r
- { "-internetChessServerHost", "internetChessServerHost",\r
- XrmoptionSepArg, NULL },\r
- { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },\r
- { "-internetChessServerPort", "internetChessServerPort",\r
- XrmoptionSepArg, NULL },\r
- { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },\r
- { "-internetChessServerCommPort", "internetChessServerCommPort",\r
- XrmoptionSepArg, NULL },\r
- { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },\r
- { "-internetChessServerLogonScript", "internetChessServerLogonScript",\r
- XrmoptionSepArg, NULL },\r
- { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },\r
- { "-internetChessServerHelper", "internetChessServerHelper",\r
- XrmoptionSepArg, NULL },\r
- { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },\r
- { "-internetChessServerInputBox", "internetChessServerInputBox",\r
- XrmoptionSepArg, NULL },\r
- { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },\r
- { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },\r
- { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },\r
- { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },\r
- { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },\r
- { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },\r
- { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },\r
- { "-telnet", "useTelnet", XrmoptionNoArg, "True" },\r
- { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },\r
- { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },\r
- { "-gateway", "gateway", XrmoptionSepArg, NULL },\r
- { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },\r
- { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },\r
- { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },\r
- { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },\r
- { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },\r
- { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },\r
- { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },\r
- { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },\r
- { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },\r
- { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },\r
- { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },\r
- { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },\r
- { "-blindfold", "blindfold", XrmoptionSepArg, NULL },\r
- { "-blind", "blindfold", XrmoptionNoArg, "True" },\r
- { "-xblind", "blindfold", XrmoptionNoArg, "False" },\r
- { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },\r
- { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },\r
- { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },\r
- { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },\r
- { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },\r
- { "-spf", "savePositionFile", XrmoptionSepArg, NULL },\r
- { "-matchMode", "matchMode", XrmoptionSepArg, NULL },\r
- { "-mm", "matchMode", XrmoptionNoArg, "True" },\r
- { "-xmm", "matchMode", XrmoptionNoArg, "False" },\r
- { "-matchGames", "matchGames", XrmoptionSepArg, NULL },\r
- { "-mg", "matchGames", XrmoptionSepArg, NULL },\r
- { "-monoMode", "monoMode", XrmoptionSepArg, NULL },\r
- { "-mono", "monoMode", XrmoptionNoArg, "True" },\r
- { "-xmono", "monoMode", XrmoptionNoArg, "False" },\r
- { "-debugMode", "debugMode", XrmoptionSepArg, NULL },\r
- { "-debug", "debugMode", XrmoptionNoArg, "True" },\r
- { "-xdebug", "debugMode", XrmoptionNoArg, "False" },\r
- { "-clockMode", "clockMode", XrmoptionSepArg, NULL },\r
- { "-clock", "clockMode", XrmoptionNoArg, "True" },\r
- { "-xclock", "clockMode", XrmoptionNoArg, "False" },\r
- { "-boardSize", "boardSize", XrmoptionSepArg, NULL },\r
- { "-size", "boardSize", XrmoptionSepArg, NULL },\r
- { "-searchTime", "searchTime", XrmoptionSepArg, NULL },\r
- { "-st", "searchTime", XrmoptionSepArg, NULL },\r
- { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },\r
- { "-depth", "searchDepth", XrmoptionSepArg, NULL },\r
- { "-showCoords", "showCoords", XrmoptionSepArg, NULL },\r
- { "-coords", "showCoords", XrmoptionNoArg, "True" },\r
- { "-xcoords", "showCoords", XrmoptionNoArg, "False" },\r
-#if JAIL\r
- { "-showJail", "showJail", XrmoptionSepArg, NULL },\r
- { "-jail", "showJail", XrmoptionNoArg, "1" },\r
- { "-sidejail", "showJail", XrmoptionNoArg, "2" },\r
- { "-xjail", "showJail", XrmoptionNoArg, "0" },\r
-#endif\r
- { "-showThinking", "showThinking", XrmoptionSepArg, NULL },\r
- { "-thinking", "showThinking", XrmoptionNoArg, "True" },\r
- { "-xthinking", "showThinking", XrmoptionNoArg, "False" },\r
- { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },\r
- { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },\r
- { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },\r
- { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },\r
- { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },\r
- { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },\r
- { "-clockFont", "clockFont", XrmoptionSepArg, NULL },\r
- { "-coordFont", "coordFont", XrmoptionSepArg, NULL },\r
- { "-font", "font", XrmoptionSepArg, NULL },\r
- { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },\r
- { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },\r
- { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },\r
- { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },\r
- { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },\r
- { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },\r
- { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },\r
- { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },\r
- { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },\r
- { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },\r
- { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },\r
- { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },\r
- { "-autobs", "autoObserve", XrmoptionNoArg, "True" },\r
- { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },\r
- { "-autoComment", "autoComment", XrmoptionSepArg, NULL },\r
- { "-autocomm", "autoComment", XrmoptionNoArg, "True" },\r
- { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },\r
- { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },\r
- { "-moves", "getMoveList", XrmoptionNoArg, "True" },\r
- { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },\r
-#if HIGHDRAG\r
- { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },\r
- { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },\r
- { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },\r
-#endif\r
- { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },\r
- { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },\r
- { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },\r
- { "-premove", "premove", XrmoptionSepArg, NULL },\r
- { "-pre", "premove", XrmoptionNoArg, "True" },\r
- { "-xpre", "premove", XrmoptionNoArg, "False" },\r
- { "-testLegality", "testLegality", XrmoptionSepArg, NULL },\r
- { "-legal", "testLegality", XrmoptionNoArg, "True" },\r
- { "-xlegal", "testLegality", XrmoptionNoArg, "False" },\r
- { "-flipView", "flipView", XrmoptionSepArg, NULL },\r
- { "-flip", "flipView", XrmoptionNoArg, "True" },\r
- { "-xflip", "flipView", XrmoptionNoArg, "False" },\r
- { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },\r
- { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",\r
- XrmoptionSepArg, NULL },\r
- { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },\r
- { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },\r
- { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },\r
- { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },\r
- { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },\r
- { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },\r
- { "-quiet", "quietPlay", XrmoptionNoArg, "True" },\r
- { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },\r
- { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },\r
- { "-title", "titleInWindow", XrmoptionNoArg, "True" },\r
- { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },\r
-#ifdef ZIPPY\r
- { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },\r
- { "-zt", "zippyTalk", XrmoptionNoArg, "True" },\r
- { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },\r
- { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },\r
- { "-zp", "zippyPlay", XrmoptionNoArg, "True" },\r
- { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },\r
- { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },\r
- { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },\r
- { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },\r
- { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },\r
- { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },\r
- { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },\r
- { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },\r
- { "-zui", "zippyUseI", XrmoptionNoArg, "True" },\r
- { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },\r
- { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },\r
- { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },\r
- { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },\r
- { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },\r
- { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },\r
- { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },\r
- { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },\r
- { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },\r
- { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },\r
- { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },\r
- { "-zab", "zippyAbort", XrmoptionNoArg, "True" },\r
- { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },\r
- { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },\r
- { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },\r
- { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },\r
-#endif\r
- { "-flashCount", "flashCount", XrmoptionSepArg, NULL },\r
- { "-flash", "flashCount", XrmoptionNoArg, "3" },\r
- { "-xflash", "flashCount", XrmoptionNoArg, "0" },\r
- { "-flashRate", "flashRate", XrmoptionSepArg, NULL },\r
- { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },\r
- { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },\r
- { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },\r
- { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },\r
- { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },\r
- { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },\r
- { "-colorShout", "colorShout", XrmoptionSepArg, NULL },\r
- { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },\r
- { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/\r
- { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },\r
- { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },\r
- { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },\r
- { "-colorTell", "colorTell", XrmoptionSepArg, NULL },\r
- { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },\r
- { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },\r
- { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },\r
- { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },\r
- { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },\r
- { "-soundShout", "soundShout", XrmoptionSepArg, NULL },\r
- { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },\r
- { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/\r
- { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },\r
- { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },\r
- { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },\r
- { "-soundTell", "soundTell", XrmoptionSepArg, NULL },\r
- { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },\r
- { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },\r
- { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },\r
- { "-soundMove", "soundMove", XrmoptionSepArg, NULL },\r
- { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },\r
- { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },\r
- { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },\r
- { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },\r
- { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },\r
- { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },\r
- { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/\r
- { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },\r
- { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },\r
- { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },\r
- { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },\r
- { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },\r
- { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },\r
- { "-animate", "animateMoving", XrmoptionNoArg, "True" },\r
- { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },\r
- { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },\r
- { "-drag", "animateDragging", XrmoptionNoArg, "True" },\r
- { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },\r
- { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },\r
- { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },\r
- { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },\r
- { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },\r
- { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },\r
- { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },\r
- { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },\r
- { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },\r
- { "-initialMode", "initialMode", XrmoptionSepArg, NULL },\r
- { "-mode", "initialMode", XrmoptionSepArg, NULL },\r
- { "-variant", "variant", XrmoptionSepArg, NULL },\r
- { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },\r
- { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },\r
- { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },\r
- { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },\r
- { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },\r
- /* [AS,HR] New features */\r
- { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },\r
- { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },\r
- { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },\r
- { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },\r
- { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },\r
- { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },\r
- { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },\r
- // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c\r
-\r
- /* [HGM,HR] User-selectable board size */\r
- { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL }, \r
- { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL }, \r
- { "-matchPause", "matchPause", XrmoptionSepArg, NULL }, \r
-\r
- /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */\r
- { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work\r
- { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL }, // requires front-end changes to work\r
- { "-allWhite", "allWhite", XrmoptionSepArg, NULL }, // requires front-end changes to work\r
- { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL }, \r
- { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL }, \r
- { "-testClaims", "testClaims", XrmoptionSepArg, NULL }, \r
- { "-checkMates", "checkMates", XrmoptionSepArg, NULL }, \r
- { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL }, \r
- { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL }, \r
- { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL }, \r
- { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },\r
- { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL }, \r
- { "-userName", "userName", XrmoptionSepArg, NULL }, \r
- { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" }, \r
- { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL }, \r
- { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL }, \r
- { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL }, \r
- { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL }, \r
- { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL }, \r
- { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL }, \r
- { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL }, \r
- { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL }, \r
- { "-serverPause", "serverPause", XrmoptionSepArg, NULL }, \r
- { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL }, \r
-};\r
-\r
-\r
-XtActionsRec boardActions[] = {\r
- { "DrawPosition", DrawPositionProc },\r
- { "HandleUserMove", HandleUserMove },\r
- { "AnimateUserMove", AnimateUserMove },\r
- { "FileNameAction", FileNameAction },\r
- { "AskQuestionProc", AskQuestionProc },\r
- { "AskQuestionReplyAction", AskQuestionReplyAction },\r
- { "PieceMenuPopup", PieceMenuPopup },\r
- { "WhiteClock", WhiteClock },\r
- { "BlackClock", BlackClock },\r
- { "Iconify", Iconify },\r
- { "ResetProc", ResetProc },\r
- { "LoadGameProc", LoadGameProc },\r
- { "LoadNextGameProc", LoadNextGameProc },\r
- { "LoadPrevGameProc", LoadPrevGameProc },\r
- { "LoadSelectedProc", LoadSelectedProc },\r
- { "ReloadGameProc", ReloadGameProc },\r
- { "LoadPositionProc", LoadPositionProc },\r
- { "LoadNextPositionProc", LoadNextPositionProc },\r
- { "LoadPrevPositionProc", LoadPrevPositionProc },\r
- { "ReloadPositionProc", ReloadPositionProc },\r
- { "CopyPositionProc", CopyPositionProc },\r
- { "PastePositionProc", PastePositionProc },\r
- { "CopyGameProc", CopyGameProc },\r
- { "PasteGameProc", PasteGameProc },\r
- { "SaveGameProc", SaveGameProc },\r
- { "SavePositionProc", SavePositionProc },\r
- { "MailMoveProc", MailMoveProc },\r
- { "ReloadCmailMsgProc", ReloadCmailMsgProc },\r
- { "QuitProc", QuitProc },\r
- { "MachineWhiteProc", MachineWhiteProc },\r
- { "MachineBlackProc", MachineBlackProc },\r
- { "AnalysisModeProc", AnalyzeModeProc },\r
- { "AnalyzeFileProc", AnalyzeFileProc },\r
- { "TwoMachinesProc", TwoMachinesProc },\r
- { "IcsClientProc", IcsClientProc },\r
- { "EditGameProc", EditGameProc },\r
- { "EditPositionProc", EditPositionProc },\r
- { "TrainingProc", EditPositionProc },\r
- { "ShowGameListProc", ShowGameListProc },\r
- { "ShowMoveListProc", HistoryShowProc},\r
- { "EditTagsProc", EditCommentProc },\r
- { "EditCommentProc", EditCommentProc },\r
- { "IcsAlarmProc", IcsAlarmProc },\r
- { "IcsInputBoxProc", IcsInputBoxProc },\r
- { "PauseProc", PauseProc },\r
- { "AcceptProc", AcceptProc },\r
- { "DeclineProc", DeclineProc },\r
- { "RematchProc", RematchProc },\r
- { "CallFlagProc", CallFlagProc },\r
- { "DrawProc", DrawProc },\r
- { "AdjournProc", AdjournProc },\r
- { "AbortProc", AbortProc },\r
- { "ResignProc", ResignProc },\r
- { "EnterKeyProc", EnterKeyProc },\r
- { "StopObservingProc", StopObservingProc },\r
- { "StopExaminingProc", StopExaminingProc },\r
- { "BackwardProc", BackwardProc },\r
- { "ForwardProc", ForwardProc },\r
- { "ToStartProc", ToStartProc },\r
- { "ToEndProc", ToEndProc },\r
- { "RevertProc", RevertProc },\r
- { "TruncateGameProc", TruncateGameProc },\r
- { "MoveNowProc", MoveNowProc },\r
- { "RetractMoveProc", RetractMoveProc },\r
- { "AlwaysQueenProc", AlwaysQueenProc },\r
- { "AnimateDraggingProc", AnimateDraggingProc },\r
- { "AnimateMovingProc", AnimateMovingProc },\r
- { "AutoflagProc", AutoflagProc },\r
- { "AutoflipProc", AutoflipProc },\r
- { "AutobsProc", AutobsProc },\r
- { "AutoraiseProc", AutoraiseProc },\r
- { "AutosaveProc", AutosaveProc },\r
- { "BlindfoldProc", BlindfoldProc },\r
- { "FlashMovesProc", FlashMovesProc },\r
- { "FlipViewProc", FlipViewProc },\r
- { "GetMoveListProc", GetMoveListProc },\r
-#if HIGHDRAG\r
- { "HighlightDraggingProc", HighlightDraggingProc },\r
-#endif\r
- { "HighlightLastMoveProc", HighlightLastMoveProc },\r
- { "IcsAlarmProc", IcsAlarmProc },\r
- { "MoveSoundProc", MoveSoundProc },\r
- { "OldSaveStyleProc", OldSaveStyleProc },\r
- { "PeriodicUpdatesProc", PeriodicUpdatesProc }, \r
- { "PonderNextMoveProc", PonderNextMoveProc },\r
- { "PopupExitMessageProc", PopupExitMessageProc }, \r
- { "PopupMoveErrorsProc", PopupMoveErrorsProc }, \r
- { "PremoveProc", PremoveProc },\r
- { "QuietPlayProc", QuietPlayProc },\r
- { "ShowCoordsProc", ShowCoordsProc },\r
- { "ShowThinkingProc", ShowThinkingProc },\r
- { "TestLegalityProc", TestLegalityProc },\r
- { "InfoProc", InfoProc },\r
- { "ManProc", ManProc },\r
- { "HintProc", HintProc },\r
- { "BookProc", BookProc },\r
- { "AboutGameProc", AboutGameProc },\r
- { "AboutProc", AboutProc },\r
- { "DebugProc", DebugProc },\r
- { "NothingProc", NothingProc },\r
- { "CommentPopDown", (XtActionProc) CommentPopDown },\r
- { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },\r
- { "TagsPopDown", (XtActionProc) TagsPopDown },\r
- { "ErrorPopDown", (XtActionProc) ErrorPopDown },\r
- { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },\r
- { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },\r
- { "FileNamePopDown", (XtActionProc) FileNamePopDown },\r
- { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },\r
- { "GameListPopDown", (XtActionProc) GameListPopDown },\r
- { "PromotionPopDown", (XtActionProc) PromotionPopDown },\r
- { "HistoryPopDown", (XtActionProc) HistoryPopDown },\r
-};\r
- \r
-char globalTranslations[] =\r
- ":<Key>R: ResignProc() \n \\r
- :<Key>r: ResetProc() \n \\r
- :<Key>g: LoadGameProc() \n \\r
- :<Key>N: LoadNextGameProc() \n \\r
- :<Key>P: LoadPrevGameProc() \n \\r
- :<Key>Q: QuitProc() \n \\r
- :<Key>F: ToEndProc() \n \\r
- :<Key>f: ForwardProc() \n \\r
- :<Key>B: ToStartProc() \n \\r
- :<Key>b: BackwardProc() \n \\r
- :<Key>p: PauseProc() \n \\r
- :<Key>d: DrawProc() \n \\r
- :<Key>t: CallFlagProc() \n \\r
- :<Key>i: Iconify() \n \\r
- :<Key>c: Iconify() \n \\r
- :<Key>v: FlipViewProc() \n \\r
- <KeyDown>Control_L: BackwardProc() \n \\r
- <KeyUp>Control_L: ForwardProc() \n \\r
- <KeyDown>Control_R: BackwardProc() \n \\r
- <KeyUp>Control_R: ForwardProc() \n \\r
- Shift<Key>1: AskQuestionProc(\"Direct command\",\\r
- \"Send to chess program:\",,1) \n \\r
- Shift<Key>2: AskQuestionProc(\"Direct command\",\\r
- \"Send to second chess program:\",,2) \n";\r
-\r
-char boardTranslations[] =\r
- "<Btn1Down>: HandleUserMove() \n \\r
- <Btn1Up>: HandleUserMove() \n \\r
- <Btn1Motion>: AnimateUserMove() \n \\r
- Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\\r
- PieceMenuPopup(menuB) \n \\r
- Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \\r
- PieceMenuPopup(menuW) \n \\r
- Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\\r
- PieceMenuPopup(menuW) \n \\r
- Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \\r
- PieceMenuPopup(menuB) \n";\r
- \r
-char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";\r
-char blackTranslations[] = "<BtnDown>: BlackClock()\n";\r
- \r
-char ICSInputTranslations[] =\r
- "<Key>Return: EnterKeyProc() \n";\r
-\r
-String xboardResources[] = {\r
- "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",\r
- "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",\r
- "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",\r
- NULL\r
- };\r
- \r
-\r
-/* Max possible square size */\r
-#define MAXSQSIZE 256\r
-\r
-static int xpm_avail[MAXSQSIZE];\r
-\r
-#ifdef HAVE_DIR_STRUCT\r
-\r
-/* Extract piece size from filename */\r
-static int\r
-xpm_getsize(name, len, ext)\r
- char *name;\r
- int len;\r
- char *ext;\r
-{\r
- char *p, *d;\r
- char buf[10];\r
- \r
- if (len < 4)\r
- return 0;\r
-\r
- if ((p=strchr(name, '.')) == NULL ||\r
- StrCaseCmp(p+1, ext) != 0)\r
- return 0;\r
- \r
- p = name + 3;\r
- d = buf;\r
-\r
- while (*p && isdigit(*p))\r
- *(d++) = *(p++);\r
-\r
- *d = 0;\r
- return atoi(buf);\r
-}\r
-\r
-/* Setup xpm_avail */\r
-static int\r
-xpm_getavail(dirname, ext)\r
- char *dirname;\r
- char *ext;\r
-{\r
- DIR *dir;\r
- struct dirent *ent;\r
- int i;\r
-\r
- for (i=0; i<MAXSQSIZE; ++i)\r
- xpm_avail[i] = 0;\r
-\r
- if (appData.debugMode)\r
- fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);\r
- \r
- dir = opendir(dirname);\r
- if (!dir)\r
- {\r
- fprintf(stderr, "%s: Can't access XPM directory %s\n", \r
- programName, dirname);\r
- exit(1);\r
- }\r
- \r
- while ((ent=readdir(dir)) != NULL) {\r
- i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);\r
- if (i > 0 && i < MAXSQSIZE)\r
- xpm_avail[i] = 1;\r
- }\r
-\r
- closedir(dir);\r
-\r
- return 0;\r
-}\r
-\r
-void\r
-xpm_print_avail(fp, ext)\r
- FILE *fp;\r
- char *ext;\r
-{\r
- int i;\r
-\r
- fprintf(fp, "Available `%s' sizes:\n", ext);\r
- for (i=1; i<MAXSQSIZE; ++i) {\r
- if (xpm_avail[i])\r
- printf("%d\n", i);\r
- }\r
-}\r
-\r
-/* Return XPM piecesize closest to size */\r
-int\r
-xpm_closest_to(dirname, size, ext)\r
- char *dirname;\r
- int size;\r
- char *ext;\r
-{\r
- int i;\r
- int sm_diff = MAXSQSIZE;\r
- int sm_index = 0;\r
- int diff;\r
- \r
- xpm_getavail(dirname, ext);\r
-\r
- if (appData.debugMode)\r
- xpm_print_avail(stderr, ext);\r
- \r
- for (i=1; i<MAXSQSIZE; ++i) {\r
- if (xpm_avail[i]) {\r
- diff = size - i;\r
- diff = (diff<0) ? -diff : diff;\r
- if (diff < sm_diff) {\r
- sm_diff = diff;\r
- sm_index = i;\r
- }\r
- }\r
- }\r
-\r
- if (!sm_index) {\r
- fprintf(stderr, "Error: No `%s' files!\n", ext);\r
- exit(1);\r
- }\r
-\r
- return sm_index;\r
-}\r
-#else /* !HAVE_DIR_STRUCT */\r
-/* If we are on a system without a DIR struct, we can't\r
- read the directory, so we can't collect a list of\r
- filenames, etc., so we can't do any size-fitting. */\r
-int\r
-xpm_closest_to(dirname, size, ext)\r
- char *dirname;\r
- int size;\r
- char *ext;\r
-{\r
- fprintf(stderr, "Warning: No DIR structure found on this system --\n");\r
- fprintf(stderr, " Unable to autosize for XPM/XIM pieces.\n");\r
- fprintf(stderr, " Please report this error to frankm@hiwaay.net.\n");\r
- fprintf(stderr, " Include system type & operating system in message.\n");\r
- return size;\r
-}\r
-#endif /* HAVE_DIR_STRUCT */\r
-\r
-static char *cnames[9] = { "black", "red", "green", "yellow", "blue",\r
- "magenta", "cyan", "white" };\r
-typedef struct {\r
- int attr, bg, fg;\r
-} TextColors;\r
-TextColors textColors[(int)NColorClasses];\r
-\r
-/* String is: "fg, bg, attr". Which is 0, 1, 2 */\r
-static int\r
-parse_color(str, which)\r
- char *str;\r
- int which;\r
-{\r
- char *p, buf[100], *d;\r
- int i;\r
- \r
- if (strlen(str) > 99) /* watch bounds on buf */\r
- return -1;\r
-\r
- p = str;\r
- d = buf;\r
- for (i=0; i<which; ++i) {\r
- p = strchr(p, ',');\r
- if (!p)\r
- return -1;\r
- ++p;\r
- }\r
-\r
- /* Could be looking at something like:\r
- black, , 1\r
- .. in which case we want to stop on a comma also */\r
- while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))\r
- ++p;\r
-\r
- if (*p == ',') {\r
- return -1; /* Use default for empty field */\r
- }\r
- \r
- if (which == 2 || isdigit(*p))\r
- return atoi(p);\r
- \r
- while (*p && isalpha(*p))\r
- *(d++) = *(p++);\r
-\r
- *d = 0;\r
-\r
- for (i=0; i<8; ++i) {\r
- if (!StrCaseCmp(buf, cnames[i]))\r
- return which? (i+40) : (i+30);\r
- }\r
- if (!StrCaseCmp(buf, "default")) return -1;\r
-\r
- fprintf(stderr, "%s: unrecognized color %s\n", programName, buf);\r
- return -2;\r
-}\r
-\r
-static int\r
-parse_cpair(cc, str)\r
- ColorClass cc;\r
- char *str;\r
-{\r
- if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {\r
- fprintf(stderr, "%s: can't parse foreground color in `%s'\n",\r
- programName, str);\r
- return -1;\r
- }\r
-\r
- /* bg and attr are optional */\r
- textColors[(int)cc].bg = parse_color(str, 1);\r
- if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {\r
- textColors[(int)cc].attr = 0;\r
- }\r
- return 0;\r
-}\r
-\r
-\r
-/* Arrange to catch delete-window events */\r
-Atom wm_delete_window;\r
-void\r
-CatchDeleteWindow(Widget w, String procname)\r
-{\r
- char buf[MSG_SIZ];\r
- XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);\r
- sprintf(buf, "<Message>WM_PROTOCOLS: %s() \n", procname);\r
- XtAugmentTranslations(w, XtParseTranslationTable(buf));\r
-}\r
-\r
-void\r
-BoardToTop()\r
-{\r
- Arg args[16];\r
- XtSetArg(args[0], XtNiconic, False);\r
- XtSetValues(shellWidget, args, 1);\r
-\r
- XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */\r
-}\r
-\r
-#ifdef IDSIZES\r
- // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined\r
-#else\r
-void InitDrawingSizes(BoardSize boardSize, int flags)\r
-{ // [HGM] Dummy routine to be able to link with backend files from 4.3.xx, which call it\r
- ;\r
-}\r
-#endif\r
-\r
-int\r
-main(argc, argv)\r
- int argc;\r
- char **argv;\r
-{\r
- int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;\r
- XSetWindowAttributes window_attributes;\r
- Arg args[16];\r
- Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;\r
- XrmValue vFrom, vTo;\r
- XtGeometryResult gres;\r
- char *p;\r
- XrmDatabase xdb;\r
- int forceMono = False;\r
-\r
- setbuf(stdout, NULL);\r
- setbuf(stderr, NULL);\r
- debugFP = stderr;\r
- \r
- programName = strrchr(argv[0], '/');\r
- if (programName == NULL)\r
- programName = argv[0];\r
- else\r
- programName++;\r
-\r
- shellWidget =\r
- XtAppInitialize(&appContext, "XBoard", shellOptions,\r
- XtNumber(shellOptions),\r
- &argc, argv, xboardResources, NULL, 0);\r
- if (argc > 1) {\r
- fprintf(stderr, "%s: unrecognized argument %s\n",\r
- programName, argv[1]);\r
- exit(2);\r
- }\r
- \r
- if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {\r
- chessDir = ".";\r
- } else {\r
- if (chdir(chessDir) != 0) {\r
- fprintf(stderr, "%s: can't cd to CHESSDIR: ", programName);\r
- perror(chessDir);\r
- exit(1);\r
- }\r
- }\r
- \r
- p = getenv("HOME");\r
- if (p == NULL) p = "/tmp";\r
- i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;\r
- gameCopyFilename = (char*) malloc(i);\r
- gamePasteFilename = (char*) malloc(i);\r
- sprintf(gameCopyFilename, "%s/.xboard%05uc.pgn", p, getpid());\r
- sprintf(gamePasteFilename, "%s/.xboard%05up.pgn", p, getpid());\r
-\r
- XtGetApplicationResources(shellWidget, (XtPointer) &appData,\r
- clientResources, XtNumber(clientResources),\r
- NULL, 0);\r
-\r
- /* [HGM,HR] make sure board size is acceptable */\r
- if(appData.NrFiles > BOARD_SIZE ||\r
- appData.NrRanks > BOARD_SIZE )\r
- DisplayFatalError("Recompile with BOARD_SIZE > 12, to support this size", 0, 2);\r
-\r
- /* [HGM] The following line must be moved to the "New Shuffle Game" menu as soon as there is one! */\r
- if(appData.defaultFrcPosition != -1) shuffleOpenings = TRUE;\r
-\r
-#if !HIGHDRAG\r
- /* This feature does not work; animation needs a rewrite */\r
- appData.highlightDragging = FALSE;\r
-#endif\r
- InitBackEnd1();\r
-\r
- xDisplay = XtDisplay(shellWidget);\r
- xScreen = DefaultScreen(xDisplay);\r
- wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);\r
-\r
- gameInfo.variant = StringToVariant(appData.variant);\r
- InitPosition(FALSE);\r
-#if 0\r
- /*\r
- * Determine boardSize\r
- */\r
- gameInfo.boardWidth = gameInfo.boardHeight = 8; // [HGM] boardsize: make sure we start as 8x8\r
-\r
-//#ifndef IDSIZE\r
- // [HGM] as long as we have not created the possibility to change size while running, start with requested size\r
- gameInfo.boardWidth = appData.NrFiles > 0 ? appData.NrFiles : 8; \r
- gameInfo.boardHeight = appData.NrRanks > 0 ? appData.NrRanks : 8;\r
- gameInfo.holdingsWidth = appData.holdingsSize > 0 ? 2 : 0;\r
-#endif\r
-\r
-\r
-#ifdef IDSIZE\r
- InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine\r
-#else\r
- if (isdigit(appData.boardSize[0])) {\r
- i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,\r
- &lineGap, &clockFontPxlSize, &coordFontPxlSize,\r
- &fontPxlSize, &smallLayout, &tinyLayout);\r
- if (i == 0) {\r
- fprintf(stderr, "%s: bad boardSize syntax %s\n",\r
- programName, appData.boardSize);\r
- exit(2);\r
- }\r
- if (i < 7) {\r
- /* Find some defaults; use the nearest known size */\r
- SizeDefaults *szd, *nearest;\r
- int distance = 99999;\r
- nearest = szd = sizeDefaults;\r
- while (szd->name != NULL) {\r
- if (abs(szd->squareSize - squareSize) < distance) {\r
- nearest = szd;\r
- distance = abs(szd->squareSize - squareSize);\r
- if (distance == 0) break;\r
- }\r
- szd++;\r
- }\r
- if (i < 2) lineGap = nearest->lineGap;\r
- if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;\r
- if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;\r
- if (i < 5) fontPxlSize = nearest->fontPxlSize;\r
- if (i < 6) smallLayout = nearest->smallLayout;\r
- if (i < 7) tinyLayout = nearest->tinyLayout;\r
- }\r
- } else {\r
- SizeDefaults *szd = sizeDefaults;\r
- if (*appData.boardSize == NULLCHAR) {\r
- while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||\r
- DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {\r
- szd++;\r
- }\r
- if (szd->name == NULL) szd--;\r
- } else {\r
- while (szd->name != NULL &&\r
- StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;\r
- if (szd->name == NULL) {\r
- fprintf(stderr, "%s: unrecognized boardSize name %s\n",\r
- programName, appData.boardSize);\r
- exit(2);\r
- }\r
- }\r
- squareSize = szd->squareSize;\r
- lineGap = szd->lineGap;\r
- clockFontPxlSize = szd->clockFontPxlSize;\r
- coordFontPxlSize = szd->coordFontPxlSize;\r
- fontPxlSize = szd->fontPxlSize;\r
- smallLayout = szd->smallLayout;\r
- tinyLayout = szd->tinyLayout;\r
- }\r
-\r
- /* Now, using squareSize as a hint, find a good XPM/XIM set size */\r
- if (strlen(appData.pixmapDirectory) > 0) {\r
- p = ExpandPathName(appData.pixmapDirectory);\r
- if (!p) {\r
- fprintf(stderr, "Error expanding path name \"%s\"\n",\r
- appData.pixmapDirectory);\r
- exit(1);\r
- }\r
- if (appData.debugMode) {\r
- fprintf(stderr, "XBoard square size (hint): %d\n", squareSize);\r
- fprintf(stderr, "%s fulldir:%s:\n", IMAGE_EXT, p);\r
- }\r
- squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);\r
- if (appData.debugMode) {\r
- fprintf(stderr, "Closest %s size: %d\n", IMAGE_EXT, squareSize);\r
- }\r
- }\r
- \r
- /* [HR] height treated separately (hacked) */\r
- boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);\r
- boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);\r
- if (appData.showJail == 1) {\r
- /* Jail on top and bottom */\r
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);\r
- XtSetArg(boardArgs[2], XtNheight,\r
- boardHeight + 2*(lineGap + squareSize));\r
- } else if (appData.showJail == 2) {\r
- /* Jail on sides */\r
- XtSetArg(boardArgs[1], XtNwidth,\r
- boardWidth + 2*(lineGap + squareSize));\r
- XtSetArg(boardArgs[2], XtNheight, boardHeight);\r
- } else {\r
- /* No jail */\r
- XtSetArg(boardArgs[1], XtNwidth, boardWidth);\r
- XtSetArg(boardArgs[2], XtNheight, boardHeight);\r
- }\r
-\r
- /*\r
- * Determine what fonts to use.\r
- */\r
- appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);\r
- clockFontID = XLoadFont(xDisplay, appData.clockFont);\r
- clockFontStruct = XQueryFont(xDisplay, clockFontID);\r
- appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);\r
- coordFontID = XLoadFont(xDisplay, appData.coordFont);\r
- coordFontStruct = XQueryFont(xDisplay, coordFontID);\r
- appData.font = FindFont(appData.font, fontPxlSize);\r
-\r
- xdb = XtDatabase(xDisplay);\r
- XrmPutStringResource(&xdb, "*font", appData.font);\r
-\r
- /*\r
- * Detect if there are not enough colors available and adapt.\r
- */\r
- if (DefaultDepth(xDisplay, xScreen) <= 2) {\r
- appData.monoMode = True;\r
- }\r
-\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.lightSquareColor;\r
- vFrom.size = strlen(appData.lightSquareColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- lightSquareColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.darkSquareColor;\r
- vFrom.size = strlen(appData.darkSquareColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- darkSquareColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.whitePieceColor;\r
- vFrom.size = strlen(appData.whitePieceColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- whitePieceColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.blackPieceColor;\r
- vFrom.size = strlen(appData.blackPieceColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- blackPieceColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
-\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.highlightSquareColor;\r
- vFrom.size = strlen(appData.highlightSquareColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- highlightSquareColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
-\r
- if (!appData.monoMode) {\r
- vFrom.addr = (caddr_t) appData.premoveHighlightColor;\r
- vFrom.size = strlen(appData.premoveHighlightColor);\r
- XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);\r
- if (vTo.addr == NULL) {\r
- appData.monoMode = True;\r
- forceMono = True;\r
- } else {\r
- premoveHighlightColor = *(Pixel *) vTo.addr;\r
- }\r
- }\r
-\r
- if (forceMono) {\r
- fprintf(stderr, "%s: too few colors available; trying monochrome mode\n",\r
- programName);\r
- }\r
-\r
- if (appData.monoMode && appData.debugMode) {\r
- fprintf(stderr, "white pixel = 0x%lx, black pixel = 0x%lx\n",\r
- (unsigned long) XWhitePixel(xDisplay, xScreen),\r
- (unsigned long) XBlackPixel(xDisplay, xScreen));\r
- }\r
- \r
- if (parse_cpair(ColorShout, appData.colorShout) < 0 ||\r
- parse_cpair(ColorSShout, appData.colorSShout) < 0 ||\r
- parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||\r
- parse_cpair(ColorChannel, appData.colorChannel) < 0 ||\r
- parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||\r
- parse_cpair(ColorTell, appData.colorTell) < 0 ||\r
- parse_cpair(ColorChallenge, appData.colorChallenge) < 0 ||\r
- parse_cpair(ColorRequest, appData.colorRequest) < 0 ||\r
- parse_cpair(ColorSeek, appData.colorSeek) < 0 ||\r
- parse_cpair(ColorNormal, appData.colorNormal) < 0)\r
- {\r
- if (appData.colorize) {\r
- fprintf(stderr,\r
- "%s: can't parse color names; disabling colorization\n",\r
- programName);\r
- }\r
- appData.colorize = FALSE;\r
- }\r
- textColors[ColorNone].fg = textColors[ColorNone].bg = -1;\r
- textColors[ColorNone].attr = 0;\r
- \r
- XtAppAddActions(appContext, boardActions, XtNumber(boardActions));\r
- \r
- /*\r
- * widget hierarchy\r
- */\r
- if (tinyLayout) {\r
- layoutName = "tinyLayout";\r
- } else if (smallLayout) {\r
- layoutName = "smallLayout";\r
- } else {\r
- layoutName = "normalLayout";\r
- }\r
- /* Outer layoutWidget is there only to provide a name for use in\r
- resources that depend on the layout style */\r
- layoutWidget =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,\r
- layoutArgs, XtNumber(layoutArgs));\r
- formWidget =\r
- XtCreateManagedWidget("form", formWidgetClass, layoutWidget,\r
- formArgs, XtNumber(formArgs));\r
- XtSetArg(args[0], XtNdefaultDistance, &sep);\r
- XtGetValues(formWidget, args, 1);\r
- \r
- j = 0;\r
- widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);\r
-\r
- widgetList[j++] = whiteTimerWidget =\r
- XtCreateWidget("whiteTime", labelWidgetClass,\r
- formWidget, timerArgs, XtNumber(timerArgs));\r
- XtSetArg(args[0], XtNfont, clockFontStruct);\r
- XtSetValues(whiteTimerWidget, args, 1);\r
- \r
- widgetList[j++] = blackTimerWidget =\r
- XtCreateWidget("blackTime", labelWidgetClass,\r
- formWidget, timerArgs, XtNumber(timerArgs));\r
- XtSetArg(args[0], XtNfont, clockFontStruct);\r
- XtSetValues(blackTimerWidget, args, 1);\r
- \r
- if (appData.titleInWindow) {\r
- widgetList[j++] = titleWidget = \r
- XtCreateWidget("title", labelWidgetClass, formWidget,\r
- titleArgs, XtNumber(titleArgs));\r
- }\r
-\r
- if (appData.showButtonBar) {\r
- widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);\r
- }\r
-\r
- widgetList[j++] = messageWidget =\r
- XtCreateWidget("message", labelWidgetClass, formWidget,\r
- messageArgs, XtNumber(messageArgs));\r
- \r
- widgetList[j++] = boardWidget =\r
- XtCreateWidget("board", widgetClass, formWidget, boardArgs,\r
- XtNumber(boardArgs));\r
-\r
- XtManageChildren(widgetList, j);\r
- \r
- timerWidth = (boardWidth - sep) / 2;\r
- XtSetArg(args[0], XtNwidth, timerWidth);\r
- XtSetValues(whiteTimerWidget, args, 1);\r
- XtSetValues(blackTimerWidget, args, 1);\r
- \r
- XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);\r
- XtSetArg(args[1], XtNforeground, &timerForegroundPixel);\r
- XtGetValues(whiteTimerWidget, args, 2);\r
- \r
- if (appData.showButtonBar) {\r
- XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);\r
- XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);\r
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);\r
- }\r
-\r
- /*\r
- * formWidget uses these constraints but they are stored\r
- * in the children.\r
- */\r
- i = 0;\r
- XtSetArg(args[i], XtNfromHoriz, 0); i++;\r
- XtSetValues(menuBarWidget, args, i);\r
- if (appData.titleInWindow) {\r
- if (smallLayout) {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
- XtSetValues(whiteTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
- XtSetValues(blackTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
- XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;\r
- XtSetValues(titleWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
- XtSetValues(messageWidget, args, i);\r
- if (appData.showButtonBar) {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
- XtSetValues(buttonBarWidget, args, i);\r
- }\r
- } else {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
- XtSetValues(whiteTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, titleWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
- XtSetValues(blackTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;\r
- XtSetValues(titleWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
- XtSetValues(messageWidget, args, i);\r
- if (appData.showButtonBar) {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
- XtSetValues(buttonBarWidget, args, i);\r
- }\r
- }\r
- } else {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
- XtSetValues(whiteTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;\r
- XtSetValues(blackTimerWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
- XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;\r
- XtSetValues(messageWidget, args, i);\r
- if (appData.showButtonBar) {\r
- i = 0;\r
- XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;\r
- XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;\r
- XtSetValues(buttonBarWidget, args, i);\r
- }\r
- }\r
- i = 0;\r
- XtSetArg(args[0], XtNfromVert, messageWidget);\r
- XtSetValues(boardWidget, args, 1);\r
-\r
- XtRealizeWidget(shellWidget);\r
-\r
- /*\r
- * Correct the width of the message and title widgets.\r
- * It is not known why some systems need the extra fudge term.\r
- * The value "2" is probably larger than needed.\r
- */\r
- XawFormDoLayout(formWidget, False);\r
-#define WIDTH_FUDGE 2\r
- i = 0;\r
- XtSetArg(args[i], XtNborderWidth, &bor); i++;\r
- XtSetArg(args[i], XtNheight, &h); i++;\r
- XtGetValues(messageWidget, args, i);\r
- if (appData.showButtonBar) {\r
- i = 0;\r
- XtSetArg(args[i], XtNwidth, &w); i++;\r
- XtGetValues(buttonBarWidget, args, i);\r
- w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;\r
- } else {\r
- w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */\r
- }\r
-\r
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);\r
- if (gres != XtGeometryYes && appData.debugMode) {\r
- fprintf(stderr, "%s: messageWidget geometry error %d %d %d %d %d\n",\r
- programName, gres, w, h, wr, hr);\r
- }\r
- \r
- /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */\r
- /* The size used for the child widget in layout lags one resize behind\r
- its true size, so we resize a second time, 1 pixel smaller. Yeech! */\r
- w--;\r
- gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);\r
- if (gres != XtGeometryYes && appData.debugMode) {\r
- fprintf(stderr, "%s: messageWidget geometry error %d %d %d %d %d\n",\r
- programName, gres, w, h, wr, hr);\r
- }\r
- /* !! end hack */\r
-\r
- if (appData.titleInWindow) {\r
- i = 0;\r
- XtSetArg(args[i], XtNborderWidth, &bor); i++;\r
- XtSetArg(args[i], XtNheight, &h); i++;\r
- XtGetValues(titleWidget, args, i);\r
- if (smallLayout) {\r
- w = boardWidth - 2*bor;\r
- } else {\r
- XtSetArg(args[0], XtNwidth, &w);\r
- XtGetValues(menuBarWidget, args, 1);\r
- w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;\r
- }\r
-\r
- gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);\r
- if (gres != XtGeometryYes && appData.debugMode) {\r
- fprintf(stderr,\r
- "%s: titleWidget geometry error %d %d %d %d %d\n",\r
- programName, gres, w, h, wr, hr);\r
- }\r
- }\r
- XawFormDoLayout(formWidget, True);\r
-\r
- xBoardWindow = XtWindow(boardWidget);\r
-\r
- // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would\r
- // not need to go into InitDrawingSizes().\r
-#endif \r
-\r
- /* \r
- * Create X checkmark bitmap and initialize option menu checks.\r
- */\r
- ReadBitmap(&xMarkPixmap, "checkmark.bm",\r
- checkmark_bits, checkmark_width, checkmark_height);\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- if (appData.alwaysPromoteToQueen) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),\r
- args, 1);\r
- }\r
- if (appData.animateDragging) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Animate Dragging"),\r
- args, 1);\r
- }\r
- if (appData.animate) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),\r
- args, 1);\r
- }\r
- if (appData.autoComment) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),\r
- args, 1);\r
- }\r
- if (appData.autoCallFlag) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),\r
- args, 1);\r
- }\r
- if (appData.autoFlipView) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),\r
- args, 1);\r
- }\r
- if (appData.autoObserve) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),\r
- args, 1);\r
- }\r
- if (appData.autoRaiseBoard) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Auto Raise Board"), args, 1);\r
- }\r
- if (appData.autoSaveGames) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
- args, 1);\r
- }\r
- if (appData.saveGameFile[0] != NULLCHAR) {\r
- /* Can't turn this off from menu */\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
- args, 1);\r
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
- False);\r
-\r
- }\r
- if (appData.blindfold) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Blindfold"), args, 1);\r
- }\r
- if (appData.flashCount > 0) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Flash Moves"),\r
- args, 1);\r
- }\r
- if (appData.getMoveList) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),\r
- args, 1);\r
- }\r
-#if HIGHDRAG\r
- if (appData.highlightDragging) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Highlight Dragging"),\r
- args, 1);\r
- }\r
-#endif\r
- if (appData.highlightLastMove) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Highlight Last Move"),\r
- args, 1);\r
- }\r
- if (appData.icsAlarm) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),\r
- args, 1);\r
- }\r
- if (appData.ringBellAfterMoves) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),\r
- args, 1);\r
- }\r
- if (appData.oldSaveStyle) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Old Save Style"), args, 1);\r
- }\r
- if (appData.periodicUpdates) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Periodic Updates"), args, 1);\r
- } \r
- if (appData.ponderNextMove) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Ponder Next Move"), args, 1);\r
- } \r
- if (appData.popupExitMessage) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Popup Exit Message"), args, 1);\r
- } \r
- if (appData.popupMoveErrors) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Popup Move Errors"), args, 1);\r
- } \r
- if (appData.premove) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Premove"), args, 1);\r
- }\r
- if (appData.quietPlay) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Quiet Play"), args, 1);\r
- }\r
- if (appData.showCoords) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),\r
- args, 1);\r
- }\r
- if (appData.showThinking) {\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),\r
- args, 1);\r
- }\r
- if (appData.testLegality) {\r
- XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),\r
- args, 1);\r
- }\r
-\r
- /*\r
- * Create an icon.\r
- */\r
- ReadBitmap(&wIconPixmap, "icon_white.bm",\r
- icon_white_bits, icon_white_width, icon_white_height);\r
- ReadBitmap(&bIconPixmap, "icon_black.bm",\r
- icon_black_bits, icon_black_width, icon_black_height);\r
- iconPixmap = wIconPixmap;\r
- i = 0;\r
- XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;\r
- XtSetValues(shellWidget, args, i);\r
- \r
- /*\r
- * Create a cursor for the board widget.\r
- */\r
- window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);\r
- XChangeWindowAttributes(xDisplay, xBoardWindow,\r
- CWCursor, &window_attributes);\r
- \r
- /*\r
- * Inhibit shell resizing.\r
- */\r
- shellArgs[0].value = (XtArgVal) &w;\r
- shellArgs[1].value = (XtArgVal) &h;\r
- XtGetValues(shellWidget, shellArgs, 2);\r
- shellArgs[4].value = shellArgs[2].value = w;\r
- shellArgs[5].value = shellArgs[3].value = h;\r
- XtSetValues(shellWidget, &shellArgs[2], 4);\r
- \r
- CatchDeleteWindow(shellWidget, "QuitProc");\r
-\r
- CreateGCs();\r
- CreateGrid();\r
-#if HAVE_LIBXPM\r
- if (appData.bitmapDirectory[0] != NULLCHAR) {\r
- CreatePieces();\r
- } else {\r
- CreateXPMPieces();\r
- }\r
-#else\r
- CreateXIMPieces();\r
- /* Create regular pieces */\r
- if (!useImages) CreatePieces();\r
-#endif \r
-\r
- CreatePieceMenus();\r
-\r
- if (appData.animate || appData.animateDragging)\r
- CreateAnimVars();\r
- \r
- XtAugmentTranslations(formWidget,\r
- XtParseTranslationTable(globalTranslations));\r
- XtAugmentTranslations(boardWidget,\r
- XtParseTranslationTable(boardTranslations));\r
- XtAugmentTranslations(whiteTimerWidget,\r
- XtParseTranslationTable(whiteTranslations));\r
- XtAugmentTranslations(blackTimerWidget,\r
- XtParseTranslationTable(blackTranslations));\r
-\r
- /* Why is the following needed on some versions of X instead\r
- * of a translation? */\r
- XtAddEventHandler(boardWidget, ExposureMask, False,\r
- (XtEventHandler) EventProc, NULL);\r
- /* end why */\r
-\r
- InitBackEnd2();\r
- \r
- if (errorExitStatus == -1) {\r
- if (appData.icsActive) {\r
- /* We now wait until we see "login:" from the ICS before\r
- sending the logon script (problems with timestamp otherwise) */\r
- /*ICSInitScript();*/\r
- if (appData.icsInputBox) ICSInputBoxPopUp();\r
- }\r
-\r
- signal(SIGINT, IntSigHandler);\r
- signal(SIGTERM, IntSigHandler);\r
- if (*appData.cmailGameName != NULLCHAR) {\r
- signal(SIGUSR1, CmailSigHandler);\r
- }\r
- }\r
- InitPosition(TRUE);\r
-\r
- XtAppMainLoop(appContext);\r
- return 0;\r
-}\r
-\r
-void\r
-ShutDownFrontEnd()\r
-{\r
- if (appData.icsActive && oldICSInteractionTitle != NULL) {\r
- DisplayIcsInteractionTitle(oldICSInteractionTitle);\r
- }\r
- unlink(gameCopyFilename);\r
- unlink(gamePasteFilename);\r
-}\r
-\r
-RETSIGTYPE\r
-IntSigHandler(sig)\r
- int sig;\r
-{\r
- ExitEvent(sig);\r
-}\r
-\r
-RETSIGTYPE\r
-CmailSigHandler(sig)\r
- int sig;\r
-{\r
- int dummy = 0;\r
- int error;\r
-\r
- signal(SIGUSR1, SIG_IGN); /* suspend handler */\r
-\r
- /* Activate call-back function CmailSigHandlerCallBack() */\r
- OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);\r
-\r
- signal(SIGUSR1, CmailSigHandler); /* re-activate handler */\r
-}\r
-\r
-void\r
-CmailSigHandlerCallBack(isr, closure, message, count, error)\r
- InputSourceRef isr;\r
- VOIDSTAR closure;\r
- char *message;\r
- int count;\r
- int error;\r
-{\r
- BoardToTop();\r
- ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */\r
-}\r
-/**** end signal code ****/\r
-\r
-\r
-void\r
-ICSInitScript()\r
-{\r
- FILE *f;\r
- char buf[MSG_SIZ];\r
- char *p;\r
-\r
- f = fopen(appData.icsLogon, "r");\r
- if (f == NULL) {\r
- p = getenv("HOME");\r
- if (p != NULL) {\r
- strcpy(buf, p);\r
- strcat(buf, "/");\r
- strcat(buf, appData.icsLogon);\r
- f = fopen(buf, "r");\r
- }\r
- }\r
- if (f != NULL)\r
- ProcessICSInitScript(f);\r
-}\r
-\r
-void\r
-ResetFrontEnd()\r
-{\r
- CommentPopDown();\r
- EditCommentPopDown();\r
- TagsPopDown();\r
- return;\r
-}\r
-\r
-typedef struct {\r
- char *name;\r
- Boolean value;\r
-} Enables;\r
-\r
-void\r
-SetMenuEnables(enab)\r
- Enables *enab;\r
-{\r
- Widget w;\r
- if (!menuBarWidget) return;\r
- while (enab->name != NULL) {\r
- w = XtNameToWidget(menuBarWidget, enab->name);\r
- if (w == NULL) {\r
- DisplayError(enab->name, 0);\r
- } else {\r
- XtSetSensitive(w, enab->value);\r
- }\r
- enab++;\r
- }\r
-}\r
-\r
-Enables icsEnables[] = {\r
- { "menuFile.Mail Move", False },\r
- { "menuFile.Reload CMail Message", False },\r
- { "menuMode.Machine Black", False },\r
- { "menuMode.Machine White", False },\r
- { "menuMode.Analysis Mode", False },\r
- { "menuMode.Analyze File", False },\r
- { "menuMode.Two Machines", False },\r
-#ifndef ZIPPY\r
- { "menuHelp.Hint", False },\r
- { "menuHelp.Book", False },\r
- { "menuStep.Move Now", False },\r
- { "menuOptions.Periodic Updates", False }, \r
- { "menuOptions.Show Thinking", False },\r
- { "menuOptions.Ponder Next Move", False },\r
-#endif\r
- { NULL, False }\r
-};\r
-\r
-Enables ncpEnables[] = { \r
- { "menuFile.Mail Move", False },\r
- { "menuFile.Reload CMail Message", False },\r
- { "menuMode.Machine White", False },\r
- { "menuMode.Machine Black", False },\r
- { "menuMode.Analysis Mode", False },\r
- { "menuMode.Analyze File", False },\r
- { "menuMode.Two Machines", False },\r
- { "menuMode.ICS Client", False },\r
- { "menuMode.ICS Input Box", False },\r
- { "Action", False },\r
- { "menuStep.Revert", False },\r
- { "menuStep.Move Now", False },\r
- { "menuStep.Retract Move", False },\r
- { "menuOptions.Auto Comment", False },\r
- { "menuOptions.Auto Flag", False },\r
- { "menuOptions.Auto Flip View", False },\r
- { "menuOptions.Auto Observe", False },\r
- { "menuOptions.Auto Raise Board", False },\r
- { "menuOptions.Get Move List", False },\r
- { "menuOptions.ICS Alarm", False },\r
- { "menuOptions.Move Sound", False },\r
- { "menuOptions.Quiet Play", False },\r
- { "menuOptions.Show Thinking", False },\r
- { "menuOptions.Periodic Updates", False }, \r
- { "menuOptions.Ponder Next Move", False },\r
- { "menuHelp.Hint", False },\r
- { "menuHelp.Book", False },\r
- { NULL, False }\r
-};\r
-\r
-Enables gnuEnables[] = { \r
- { "menuMode.ICS Client", False },\r
- { "menuMode.ICS Input Box", False },\r
- { "menuAction.Accept", False },\r
- { "menuAction.Decline", False },\r
- { "menuAction.Rematch", False },\r
- { "menuAction.Adjourn", False },\r
- { "menuAction.Stop Examining", False },\r
- { "menuAction.Stop Observing", False },\r
- { "menuStep.Revert", False },\r
- { "menuOptions.Auto Comment", False },\r
- { "menuOptions.Auto Observe", False },\r
- { "menuOptions.Auto Raise Board", False },\r
- { "menuOptions.Get Move List", False },\r
- { "menuOptions.Premove", False },\r
- { "menuOptions.Quiet Play", False },\r
-\r
- /* The next two options rely on SetCmailMode being called *after* */\r
- /* SetGNUMode so that when GNU is being used to give hints these */\r
- /* menu options are still available */\r
-\r
- { "menuFile.Mail Move", False },\r
- { "menuFile.Reload CMail Message", False },\r
- { NULL, False }\r
-};\r
-\r
-Enables cmailEnables[] = { \r
- { "Action", True },\r
- { "menuAction.Call Flag", False },\r
- { "menuAction.Draw", True },\r
- { "menuAction.Adjourn", False },\r
- { "menuAction.Abort", False },\r
- { "menuAction.Stop Observing", False },\r
- { "menuAction.Stop Examining", False },\r
- { "menuFile.Mail Move", True },\r
- { "menuFile.Reload CMail Message", True },\r
- { NULL, False }\r
-};\r
-\r
-Enables trainingOnEnables[] = { \r
- { "menuMode.Edit Comment", False },\r
- { "menuMode.Pause", False },\r
- { "menuStep.Forward", False },\r
- { "menuStep.Backward", False },\r
- { "menuStep.Forward to End", False },\r
- { "menuStep.Back to Start", False },\r
- { "menuStep.Move Now", False },\r
- { "menuStep.Truncate Game", False },\r
- { NULL, False }\r
-};\r
-\r
-Enables trainingOffEnables[] = { \r
- { "menuMode.Edit Comment", True },\r
- { "menuMode.Pause", True },\r
- { "menuStep.Forward", True },\r
- { "menuStep.Backward", True },\r
- { "menuStep.Forward to End", True },\r
- { "menuStep.Back to Start", True },\r
- { "menuStep.Move Now", True },\r
- { "menuStep.Truncate Game", True },\r
- { NULL, False }\r
-};\r
-\r
-Enables machineThinkingEnables[] = {\r
- { "menuFile.Load Game", False },\r
- { "menuFile.Load Next Game", False },\r
- { "menuFile.Load Previous Game", False },\r
- { "menuFile.Reload Same Game", False },\r
- { "menuFile.Paste Game", False },\r
- { "menuFile.Load Position", False },\r
- { "menuFile.Load Next Position", False },\r
- { "menuFile.Load Previous Position", False },\r
- { "menuFile.Reload Same Position", False },\r
- { "menuFile.Paste Position", False },\r
- { "menuMode.Machine White", False },\r
- { "menuMode.Machine Black", False },\r
- { "menuMode.Two Machines", False },\r
- { "menuStep.Retract Move", False },\r
- { NULL, False }\r
-};\r
-\r
-Enables userThinkingEnables[] = {\r
- { "menuFile.Load Game", True },\r
- { "menuFile.Load Next Game", True },\r
- { "menuFile.Load Previous Game", True },\r
- { "menuFile.Reload Same Game", True },\r
- { "menuFile.Paste Game", True },\r
- { "menuFile.Load Position", True },\r
- { "menuFile.Load Next Position", True },\r
- { "menuFile.Load Previous Position", True },\r
- { "menuFile.Reload Same Position", True },\r
- { "menuFile.Paste Position", True },\r
- { "menuMode.Machine White", True },\r
- { "menuMode.Machine Black", True },\r
- { "menuMode.Two Machines", True },\r
- { "menuStep.Retract Move", True },\r
- { NULL, False }\r
-};\r
-\r
-void SetICSMode()\r
-{\r
- SetMenuEnables(icsEnables);\r
-}\r
-\r
-void\r
-SetNCPMode()\r
-{\r
- SetMenuEnables(ncpEnables);\r
-}\r
-\r
-void\r
-SetGNUMode()\r
-{\r
- SetMenuEnables(gnuEnables);\r
-}\r
-\r
-void\r
-SetCmailMode()\r
-{\r
- SetMenuEnables(cmailEnables);\r
-}\r
-\r
-void\r
-SetTrainingModeOn()\r
-{\r
- SetMenuEnables(trainingOnEnables);\r
- if (appData.showButtonBar) {\r
- XtSetSensitive(buttonBarWidget, False);\r
- }\r
- CommentPopDown();\r
-}\r
-\r
-void\r
-SetTrainingModeOff()\r
-{\r
- SetMenuEnables(trainingOffEnables);\r
- if (appData.showButtonBar) {\r
- XtSetSensitive(buttonBarWidget, True);\r
- }\r
-}\r
-\r
-void\r
-SetUserThinkingEnables()\r
-{\r
- if (appData.noChessProgram) return;\r
- SetMenuEnables(userThinkingEnables);\r
-}\r
-\r
-void\r
-SetMachineThinkingEnables()\r
-{\r
- if (appData.noChessProgram) return;\r
- SetMenuEnables(machineThinkingEnables);\r
- switch (gameMode) {\r
- case MachinePlaysBlack:\r
- case MachinePlaysWhite:\r
- case TwoMachinesPlay:\r
- XtSetSensitive(XtNameToWidget(menuBarWidget,\r
- ModeToWidgetName(gameMode)), True);\r
- break;\r
- default:\r
- break;\r
- }\r
-}\r
-\r
-#define Abs(n) ((n)<0 ? -(n) : (n))\r
-\r
-/*\r
- * Find a font that matches "pattern" that is as close as\r
- * possible to the targetPxlSize. Prefer fonts that are k\r
- * pixels smaller to fonts that are k pixels larger. The\r
- * pattern must be in the X Consortium standard format, \r
- * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".\r
- * The return value should be freed with XtFree when no\r
- * longer needed.\r
- */\r
-char *FindFont(pattern, targetPxlSize)\r
- char *pattern;\r
- int targetPxlSize;\r
-{\r
- char **fonts, *p, *best, *scalable, *scalableTail;\r
- int i, j, nfonts, minerr, err, pxlSize;\r
-\r
- fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);\r
- if (nfonts < 1) {\r
- fprintf(stderr, "%s: no fonts match pattern %s\n",\r
- programName, pattern);\r
- exit(2);\r
- }\r
- best = fonts[0];\r
- scalable = NULL;\r
- minerr = 999999;\r
- for (i=0; i<nfonts; i++) {\r
- j = 0;\r
- p = fonts[i];\r
- if (*p != '-') continue;\r
- while (j < 7) {\r
- if (*p == NULLCHAR) break;\r
- if (*p++ == '-') j++;\r
- }\r
- if (j < 7) continue;\r
- pxlSize = atoi(p);\r
- if (pxlSize == 0) {\r
- scalable = fonts[i];\r
- scalableTail = p;\r
- } else {\r
- err = pxlSize - targetPxlSize;\r
- if (Abs(err) < Abs(minerr) ||\r
- (minerr > 0 && err < 0 && -err == minerr)) {\r
- best = fonts[i];\r
- minerr = err;\r
- }\r
- }\r
- }\r
- if (scalable && Abs(minerr) > appData.fontSizeTolerance) {\r
- /* If the error is too big and there is a scalable font,\r
- use the scalable font. */\r
- int headlen = scalableTail - scalable;\r
- p = (char *) XtMalloc(strlen(scalable) + 10);\r
- while (isdigit(*scalableTail)) scalableTail++;\r
- sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);\r
- } else {\r
- p = (char *) XtMalloc(strlen(best) + 1);\r
- strcpy(p, best);\r
- }\r
- if (appData.debugMode) {\r
- fprintf(debugFP, "resolved %s at pixel size %d\n to %s\n",\r
- pattern, targetPxlSize, p);\r
- }\r
- XFreeFontNames(fonts);\r
- return p;\r
-}\r
-\r
-void CreateGCs()\r
-{\r
- XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground\r
- | GCBackground | GCFunction | GCPlaneMask;\r
- XGCValues gc_values;\r
- GC copyInvertedGC;\r
- \r
- gc_values.plane_mask = AllPlanes;\r
- gc_values.line_width = lineGap;\r
- gc_values.line_style = LineSolid;\r
- gc_values.function = GXcopy;\r
- \r
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
- gc_values.background = XBlackPixel(xDisplay, xScreen);\r
- lineGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
- gc_values.background = XWhitePixel(xDisplay, xScreen);\r
- coordGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- XSetFont(xDisplay, coordGC, coordFontID);\r
- \r
- if (appData.monoMode) {\r
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);\r
- gc_values.background = XWhitePixel(xDisplay, xScreen);\r
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values); \r
-\r
- gc_values.foreground = XWhitePixel(xDisplay, xScreen);\r
- gc_values.background = XBlackPixel(xDisplay, xScreen);\r
- lightSquareGC = wbPieceGC \r
- = XtGetGC(shellWidget, value_mask, &gc_values);\r
-\r
- gc_values.foreground = XBlackPixel(xDisplay, xScreen);\r
- gc_values.background = XWhitePixel(xDisplay, xScreen);\r
- darkSquareGC = bwPieceGC\r
- = XtGetGC(shellWidget, value_mask, &gc_values);\r
-\r
- if (DefaultDepth(xDisplay, xScreen) == 1) {\r
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */\r
- gc_values.function = GXcopyInverted;\r
- copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- gc_values.function = GXcopy;\r
- if (XBlackPixel(xDisplay, xScreen) == 1) {\r
- bwPieceGC = darkSquareGC;\r
- wbPieceGC = copyInvertedGC;\r
- } else {\r
- bwPieceGC = copyInvertedGC;\r
- wbPieceGC = lightSquareGC;\r
- }\r
- }\r
- } else {\r
- gc_values.foreground = highlightSquareColor;\r
- gc_values.background = highlightSquareColor;\r
- highlineGC = XtGetGC(shellWidget, value_mask, &gc_values); \r
-\r
- gc_values.foreground = premoveHighlightColor;\r
- gc_values.background = premoveHighlightColor;\r
- prelineGC = XtGetGC(shellWidget, value_mask, &gc_values); \r
-\r
- gc_values.foreground = lightSquareColor;\r
- gc_values.background = darkSquareColor;\r
- lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = darkSquareColor;\r
- gc_values.background = lightSquareColor;\r
- darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
-\r
- gc_values.foreground = jailSquareColor;\r
- gc_values.background = jailSquareColor;\r
- jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
-\r
- gc_values.foreground = whitePieceColor;\r
- gc_values.background = darkSquareColor;\r
- wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = whitePieceColor;\r
- gc_values.background = lightSquareColor;\r
- wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = whitePieceColor;\r
- gc_values.background = jailSquareColor;\r
- wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = blackPieceColor;\r
- gc_values.background = darkSquareColor;\r
- bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- \r
- gc_values.foreground = blackPieceColor;\r
- gc_values.background = lightSquareColor;\r
- blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
-\r
- gc_values.foreground = blackPieceColor;\r
- gc_values.background = jailSquareColor;\r
- bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);\r
- }\r
-}\r
-\r
-void loadXIM(xim, xmask, filename, dest, mask)\r
- XImage *xim;\r
- XImage *xmask;\r
- char *filename;\r
- Pixmap *dest;\r
- Pixmap *mask;\r
-{\r
- int x, y, w, h, p;\r
- FILE *fp;\r
- Pixmap temp;\r
- XGCValues values;\r
- GC maskGC;\r
-\r
- fp = fopen(filename, "rb");\r
- if (!fp) {\r
- fprintf(stderr, "%s: error loading XIM!\n", programName);\r
- exit(1);\r
- }\r
- \r
- w = fgetc(fp);\r
- h = fgetc(fp);\r
- \r
- for (y=0; y<h; ++y) {\r
- for (x=0; x<h; ++x) {\r
- p = fgetc(fp);\r
-\r
- switch (p) {\r
- case 0: \r
- XPutPixel(xim, x, y, blackPieceColor); \r
- if (xmask)\r
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));\r
- break;\r
- case 1: \r
- XPutPixel(xim, x, y, darkSquareColor); \r
- if (xmask)\r
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));\r
- break;\r
- case 2: \r
- XPutPixel(xim, x, y, whitePieceColor); \r
- if (xmask)\r
- XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));\r
- break;\r
- case 3: \r
- XPutPixel(xim, x, y, lightSquareColor);\r
- if (xmask)\r
- XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));\r
- break;\r
- }\r
- }\r
- }\r
-\r
- /* create Pixmap of piece */\r
- *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
- w, h, xim->depth);\r
- XPutImage(xDisplay, *dest, lightSquareGC, xim,\r
- 0, 0, 0, 0, w, h); \r
-\r
- /* create Pixmap of clipmask \r
- Note: We assume the white/black pieces have the same\r
- outline, so we make only 6 masks. This is okay\r
- since the XPM clipmask routines do the same. */\r
- if (xmask) {\r
- temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
- w, h, xim->depth);\r
- XPutImage(xDisplay, temp, lightSquareGC, xmask,\r
- 0, 0, 0, 0, w, h); \r
-\r
- /* now create the 1-bit version */\r
- *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),\r
- w, h, 1);\r
-\r
- values.foreground = 1;\r
- values.background = 0;\r
-\r
- /* Don't use XtGetGC, not read only */\r
- maskGC = XCreateGC(xDisplay, *mask, \r
- GCForeground | GCBackground, &values);\r
- XCopyPlane(xDisplay, temp, *mask, maskGC, \r
- 0, 0, squareSize, squareSize, 0, 0, 1);\r
- XFreePixmap(xDisplay, temp);\r
- }\r
-}\r
-\r
-void CreateXIMPieces()\r
-{\r
- int piece, kind;\r
- char buf[MSG_SIZ];\r
- u_int ss;\r
- static char *ximkind[] = { "ll", "ld", "dl", "dd" };\r
- XImage *ximtemp;\r
-\r
- ss = squareSize;\r
-\r
- /* The XSynchronize calls were copied from CreatePieces.\r
- Not sure if needed, but can't hurt */\r
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt\r
- buffering bug */\r
- \r
- /* temp needed by loadXIM() */\r
- ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
- 0, 0, ss, ss, AllPlanes, XYPixmap);\r
-\r
- if (strlen(appData.pixmapDirectory) == 0) {\r
- useImages = 0;\r
- } else {\r
- useImages = 1;\r
- if (appData.monoMode) {\r
- DisplayFatalError("XIM pieces cannot be used in monochrome mode",\r
- 0, 2);\r
- ExitEvent(2);\r
- }\r
- fprintf(stderr, "\nLoading XIMs...\n");\r
- /* Load pieces */\r
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
- fprintf(stderr, "%d", piece+1);\r
- for (kind=0; kind<4; kind++) {\r
- fprintf(stderr, ".");\r
- sprintf(buf, "%s/%c%s%u.xim",\r
- ExpandPathName(appData.pixmapDirectory),\r
- ToLower(PieceToChar((ChessSquare)piece)),\r
- ximkind[kind], ss);\r
- ximPieceBitmap[kind][piece] =\r
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
- 0, 0, ss, ss, AllPlanes, XYPixmap);\r
- if (appData.debugMode)\r
- fprintf(stderr, "(File:%s:) ", buf);\r
- loadXIM(ximPieceBitmap[kind][piece], \r
- ximtemp, buf,\r
- &(xpmPieceBitmap[kind][piece]),\r
- &(ximMaskPm[piece%(int)BlackPawn]));\r
- }\r
- fprintf(stderr," ");\r
- }\r
- /* Load light and dark squares */\r
- /* If the LSQ and DSQ pieces don't exist, we will \r
- draw them with solid squares. */\r
- sprintf(buf, "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);\r
- if (access(buf, 0) != 0) {\r
- useImageSqs = 0;\r
- } else {\r
- useImageSqs = 1;\r
- fprintf(stderr, "light square ");\r
- ximLightSquare= \r
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
- 0, 0, ss, ss, AllPlanes, XYPixmap);\r
- if (appData.debugMode)\r
- fprintf(stderr, "(File:%s:) ", buf);\r
-\r
- loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);\r
- fprintf(stderr, "dark square ");\r
- sprintf(buf, "%s/dsq%u.xim",\r
- ExpandPathName(appData.pixmapDirectory), ss);\r
- if (appData.debugMode)\r
- fprintf(stderr, "(File:%s:) ", buf);\r
- ximDarkSquare= \r
- XGetImage(xDisplay, DefaultRootWindow(xDisplay),\r
- 0, 0, ss, ss, AllPlanes, XYPixmap);\r
- loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);\r
- xpmJailSquare = xpmLightSquare;\r
- }\r
- fprintf(stderr, "Done.\n");\r
- }\r
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */\r
-}\r
-\r
-#if HAVE_LIBXPM\r
-void CreateXPMPieces()\r
-{\r
- int piece, kind, r;\r
- char buf[MSG_SIZ];\r
- u_int ss = squareSize;\r
- XpmAttributes attr;\r
- static char *xpmkind[] = { "ll", "ld", "dl", "dd" };\r
- XpmColorSymbol symbols[4];\r
-\r
-#if 0\r
- /* Apparently some versions of Xpm don't define XpmFormat at all --tpm */\r
- if (appData.debugMode) {\r
- fprintf(stderr, "XPM Library Version: %d.%d%c\n", \r
- XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));\r
- }\r
-#endif\r
- \r
- /* The XSynchronize calls were copied from CreatePieces.\r
- Not sure if needed, but can't hurt */\r
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */\r
- \r
- /* Setup translations so piece colors match square colors */\r
- symbols[0].name = "light_piece";\r
- symbols[0].value = appData.whitePieceColor;\r
- symbols[1].name = "dark_piece";\r
- symbols[1].value = appData.blackPieceColor;\r
- symbols[2].name = "light_square";\r
- symbols[2].value = appData.lightSquareColor;\r
- symbols[3].name = "dark_square";\r
- symbols[3].value = appData.darkSquareColor;\r
-\r
- attr.valuemask = XpmColorSymbols;\r
- attr.colorsymbols = symbols;\r
- attr.numsymbols = 4;\r
-\r
- if (appData.monoMode) {\r
- DisplayFatalError("XPM pieces cannot be used in monochrome mode",\r
- 0, 2);\r
- ExitEvent(2);\r
- }\r
- if (strlen(appData.pixmapDirectory) == 0) {\r
- XpmPieces* pieces = builtInXpms;\r
- useImages = 1;\r
- /* Load pieces */\r
- while (pieces->size != squareSize && pieces->size) pieces++;\r
- if (!pieces->size) {\r
- fprintf(stderr, "No builtin XPM pieces of size %d\n", squareSize);\r
- exit(1);\r
- }\r
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
- for (kind=0; kind<4; kind++) {\r
-\r
- if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,\r
- pieces->xpm[piece][kind],\r
- &(xpmPieceBitmap[kind][piece]),\r
- NULL, &attr)) != 0) {\r
- fprintf(stderr, "Error %d loading XPM image \"%s\"\n",\r
- r, buf);\r
- exit(1); \r
- } \r
- } \r
- }\r
- useImageSqs = 0;\r
- xpmJailSquare = xpmLightSquare;\r
- } else {\r
- useImages = 1;\r
- \r
- fprintf(stderr, "\nLoading XPMs...\n");\r
-\r
- /* Load pieces */\r
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
- fprintf(stderr, "%d ", piece+1);\r
- for (kind=0; kind<4; kind++) {\r
- sprintf(buf, "%s/%c%s%u.xpm",\r
- ExpandPathName(appData.pixmapDirectory),\r
- ToLower(PieceToChar((ChessSquare)piece)),\r
- xpmkind[kind], ss);\r
- if (appData.debugMode) {\r
- fprintf(stderr, "(File:%s:) ", buf);\r
- }\r
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,\r
- &(xpmPieceBitmap[kind][piece]),\r
- NULL, &attr)) != 0) {\r
- fprintf(stderr, "Error %d loading XPM file \"%s\"\n",\r
- r, buf);\r
- exit(1); \r
- } \r
- } \r
- }\r
- /* Load light and dark squares */\r
- /* If the LSQ and DSQ pieces don't exist, we will \r
- draw them with solid squares. */\r
- fprintf(stderr, "light square ");\r
- sprintf(buf, "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);\r
- if (access(buf, 0) != 0) {\r
- useImageSqs = 0;\r
- } else {\r
- useImageSqs = 1;\r
- if (appData.debugMode)\r
- fprintf(stderr, "(File:%s:) ", buf);\r
-\r
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,\r
- &xpmLightSquare, NULL, &attr)) != 0) {\r
- fprintf(stderr, "Error %d loading XPM file \"%s\"\n", r, buf);\r
- exit(1);\r
- }\r
- fprintf(stderr, "dark square ");\r
- sprintf(buf, "%s/dsq%u.xpm",\r
- ExpandPathName(appData.pixmapDirectory), ss);\r
- if (appData.debugMode) {\r
- fprintf(stderr, "(File:%s:) ", buf);\r
- }\r
- if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,\r
- &xpmDarkSquare, NULL, &attr)) != 0) {\r
- fprintf(stderr, "Error %d loading XPM file \"%s\"\n", r, buf);\r
- exit(1);\r
- }\r
- }\r
- xpmJailSquare = xpmLightSquare;\r
- fprintf(stderr, "Done.\n");\r
- }\r
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt\r
- buffering bug */ \r
-}\r
-#endif /* HAVE_LIBXPM */\r
-\r
-#if HAVE_LIBXPM\r
-/* No built-in bitmaps */\r
-void CreatePieces()\r
-{\r
- int piece, kind;\r
- char buf[MSG_SIZ];\r
- u_int ss = squareSize;\r
- \r
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt\r
- buffering bug */\r
-\r
- for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {\r
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),\r
- ss, kind == SOLID ? 's' : 'o');\r
- ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);\r
- }\r
- }\r
- \r
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt\r
- buffering bug */\r
-}\r
-#else\r
-/* With built-in bitmaps */\r
-void CreatePieces()\r
-{\r
- BuiltInBits* bib = builtInBits;\r
- int piece, kind;\r
- char buf[MSG_SIZ];\r
- u_int ss = squareSize;\r
- \r
- XSynchronize(xDisplay, True); /* Work-around for xlib/xt\r
- buffering bug */\r
-\r
- while (bib->squareSize != ss && bib->squareSize != 0) bib++;\r
-\r
- for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {\r
- for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {\r
- sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),\r
- ss, kind == SOLID ? 's' : 'o');\r
- ReadBitmap(&pieceBitmap[kind][piece], buf,\r
- bib->bits[kind][piece], ss, ss);\r
- }\r
- }\r
- \r
- XSynchronize(xDisplay, False); /* Work-around for xlib/xt\r
- buffering bug */\r
-}\r
-#endif\r
-\r
-void ReadBitmap(pm, name, bits, wreq, hreq)\r
- Pixmap *pm;\r
- String name;\r
- unsigned char bits[];\r
- u_int wreq, hreq;\r
-{\r
- int x_hot, y_hot;\r
- u_int w, h;\r
- int errcode;\r
- char msg[MSG_SIZ], fullname[MSG_SIZ];\r
- \r
- if (*appData.bitmapDirectory != NULLCHAR) {\r
- strcpy(fullname, appData.bitmapDirectory);\r
- strcat(fullname, "/");\r
- strcat(fullname, name);\r
- errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,\r
- &w, &h, pm, &x_hot, &y_hot);\r
- if (errcode != BitmapSuccess) {\r
- switch (errcode) {\r
- case BitmapOpenFailed:\r
- sprintf(msg, "Can't open bitmap file %s", fullname);\r
- break;\r
- case BitmapFileInvalid:\r
- sprintf(msg, "Invalid bitmap in file %s", fullname);\r
- break;\r
- case BitmapNoMemory:\r
- sprintf(msg, "Ran out of memory reading bitmap file %s",\r
- fullname);\r
- break;\r
- default:\r
- sprintf(msg, "Unknown XReadBitmapFile error %d on file %s",\r
- errcode, fullname);\r
- break;\r
- }\r
- fprintf(stderr, "%s: %s...using built-in\n",\r
- programName, msg);\r
- } else if (w != wreq || h != hreq) {\r
- fprintf(stderr,\r
- "%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n",\r
- programName, fullname, w, h, wreq, hreq);\r
- } else {\r
- return;\r
- }\r
- }\r
- if (bits == NULL) {\r
-#if 0\r
- fprintf(stderr, "%s: No built-in bitmap for %s; giving up\n",\r
- programName, name);\r
- exit(1);\r
-#endif\r
- ; // [HGM] bitmaps: make it non-fatal if we have no bitmap;\r
- } else {\r
- *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,\r
- wreq, hreq);\r
- }\r
-}\r
-\r
-void CreateGrid()\r
-{\r
- int i, j;\r
- \r
- if (lineGap == 0) return;\r
-\r
- /* [HR] Split this into 2 loops for non-square boards. */\r
-\r
- for (i = 0; i < BOARD_HEIGHT + 1; i++) {\r
- gridSegments[i].x1 = 0;\r
- gridSegments[i].x2 =\r
- lineGap + BOARD_WIDTH * (squareSize + lineGap);\r
- gridSegments[i].y1 = gridSegments[i].y2\r
- = lineGap / 2 + (i * (squareSize + lineGap));\r
- }\r
-\r
- for (j = 0; j < BOARD_WIDTH + 1; j++) {\r
- gridSegments[j + i].y1 = 0;\r
- gridSegments[j + i].y2 =\r
- lineGap + BOARD_HEIGHT * (squareSize + lineGap);\r
- gridSegments[j + i].x1 = gridSegments[j + i].x2\r
- = lineGap / 2 + (j * (squareSize + lineGap));\r
- }\r
-}\r
-\r
-static void MenuBarSelect(w, addr, index)\r
- Widget w;\r
- caddr_t addr;\r
- caddr_t index;\r
-{\r
- XtActionProc proc = (XtActionProc) addr;\r
-\r
- (proc)(NULL, NULL, NULL, NULL);\r
-}\r
-\r
-void CreateMenuBarPopup(parent, name, mb)\r
- Widget parent;\r
- String name;\r
- Menu *mb;\r
-{\r
- int j;\r
- Widget menu, entry;\r
- MenuItem *mi;\r
- Arg args[16];\r
-\r
- menu = XtCreatePopupShell(name, simpleMenuWidgetClass,\r
- parent, NULL, 0);\r
- j = 0;\r
- XtSetArg(args[j], XtNleftMargin, 20); j++;\r
- XtSetArg(args[j], XtNrightMargin, 20); j++;\r
- mi = mb->mi;\r
- while (mi->string != NULL) {\r
- if (strcmp(mi->string, "----") == 0) {\r
- entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,\r
- menu, args, j);\r
- } else {\r
- entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,\r
- menu, args, j);\r
- XtAddCallback(entry, XtNcallback,\r
- (XtCallbackProc) MenuBarSelect,\r
- (caddr_t) mi->proc);\r
- }\r
- mi++;\r
- }\r
-} \r
-\r
-Widget CreateMenuBar(mb)\r
- Menu *mb;\r
-{\r
- int j;\r
- Widget anchor, menuBar;\r
- Arg args[16];\r
- char menuName[MSG_SIZ];\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;\r
- XtSetArg(args[j], XtNvSpace, 0); j++;\r
- XtSetArg(args[j], XtNborderWidth, 0); j++;\r
- menuBar = XtCreateWidget("menuBar", boxWidgetClass,\r
- formWidget, args, j);\r
-\r
- while (mb->name != NULL) {\r
- strcpy(menuName, "menu");\r
- strcat(menuName, mb->name);\r
- j = 0;\r
- XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;\r
- if (tinyLayout) {\r
- char shortName[2];\r
- shortName[0] = mb->name[0];\r
- shortName[1] = NULLCHAR;\r
- XtSetArg(args[j], XtNlabel, XtNewString(shortName)); j++;\r
- }\r
- XtSetArg(args[j], XtNborderWidth, 0); j++;\r
- anchor = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,\r
- menuBar, args, j);\r
- CreateMenuBarPopup(menuBar, menuName, mb);\r
- mb++;\r
- }\r
- return menuBar;\r
-}\r
-\r
-Widget CreateButtonBar(mi)\r
- MenuItem *mi;\r
-{\r
- int j;\r
- Widget button, buttonBar;\r
- Arg args[16];\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;\r
- if (tinyLayout) {\r
- XtSetArg(args[j], XtNhSpace, 0); j++;\r
- }\r
- XtSetArg(args[j], XtNborderWidth, 0); j++;\r
- XtSetArg(args[j], XtNvSpace, 0); j++;\r
- buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,\r
- formWidget, args, j);\r
-\r
- while (mi->string != NULL) {\r
- j = 0;\r
- if (tinyLayout) {\r
- XtSetArg(args[j], XtNinternalWidth, 2); j++;\r
- XtSetArg(args[j], XtNborderWidth, 0); j++;\r
- }\r
- button = XtCreateManagedWidget(mi->string, commandWidgetClass,\r
- buttonBar, args, j);\r
- XtAddCallback(button, XtNcallback,\r
- (XtCallbackProc) MenuBarSelect,\r
- (caddr_t) mi->proc);\r
- mi++;\r
- }\r
- return buttonBar;\r
-} \r
-\r
-Widget\r
-CreatePieceMenu(name, color)\r
- char *name;\r
- int color;\r
-{\r
- int i;\r
- Widget entry, menu;\r
- Arg args[16];\r
- ChessSquare selection;\r
-\r
- menu = XtCreatePopupShell(name, simpleMenuWidgetClass,\r
- boardWidget, args, 0);\r
- \r
- for (i = 0; i < PIECE_MENU_SIZE; i++) {\r
- String item = pieceMenuStrings[color][i];\r
- \r
- if (strcmp(item, "----") == 0) {\r
- entry = XtCreateManagedWidget(item, smeLineObjectClass,\r
- menu, NULL, 0);\r
- } else {\r
- entry = XtCreateManagedWidget(item, smeBSBObjectClass,\r
- menu, NULL, 0);\r
- selection = pieceMenuTranslation[color][i];\r
- XtAddCallback(entry, XtNcallback,\r
- (XtCallbackProc) PieceMenuSelect,\r
- (caddr_t) selection);\r
- if (selection == WhitePawn || selection == BlackPawn) {\r
- XtSetArg(args[0], XtNpopupOnEntry, entry);\r
- XtSetValues(menu, args, 1);\r
- }\r
- }\r
- }\r
- return menu;\r
-}\r
-\r
-void\r
-CreatePieceMenus()\r
-{\r
- int i;\r
- Widget entry;\r
- Arg args[16];\r
- ChessSquare selection;\r
-\r
- whitePieceMenu = CreatePieceMenu("menuW", 0);\r
- blackPieceMenu = CreatePieceMenu("menuB", 1);\r
- \r
- XtRegisterGrabAction(PieceMenuPopup, True,\r
- (unsigned)(ButtonPressMask|ButtonReleaseMask),\r
- GrabModeAsync, GrabModeAsync);\r
-\r
- XtSetArg(args[0], XtNlabel, "Drop");\r
- dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,\r
- boardWidget, args, 1);\r
- for (i = 0; i < DROP_MENU_SIZE; i++) {\r
- String item = dropMenuStrings[i];\r
- \r
- if (strcmp(item, "----") == 0) {\r
- entry = XtCreateManagedWidget(item, smeLineObjectClass,\r
- dropMenu, NULL, 0);\r
- } else {\r
- entry = XtCreateManagedWidget(item, smeBSBObjectClass,\r
- dropMenu, NULL, 0);\r
- selection = dropMenuTranslation[i];\r
- XtAddCallback(entry, XtNcallback,\r
- (XtCallbackProc) DropMenuSelect,\r
- (caddr_t) selection);\r
- }\r
- }\r
-} \r
-\r
-void SetupDropMenu()\r
-{\r
- int i, j, count;\r
- char label[32];\r
- Arg args[16];\r
- Widget entry;\r
- char* p;\r
-\r
- for (i=0; i<sizeof(dmEnables)/sizeof(DropMenuEnables); i++) {\r
- entry = XtNameToWidget(dropMenu, dmEnables[i].widget);\r
- p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,\r
- dmEnables[i].piece);\r
- XtSetSensitive(entry, p != NULL || !appData.testLegality\r
- /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse\r
- && !appData.icsActive));\r
- count = 0;\r
- while (p && *p++ == dmEnables[i].piece) count++;\r
- sprintf(label, "%s %d", dmEnables[i].widget, count);\r
- j = 0;\r
- XtSetArg(args[j], XtNlabel, label); j++;\r
- XtSetValues(entry, args, j);\r
- }\r
-}\r
-\r
-void PieceMenuPopup(w, event, params, num_params)\r
- Widget w;\r
- XEvent *event;\r
- String *params;\r
- Cardinal *num_params;\r
-{\r
- String whichMenu;\r
- if (event->type != ButtonPress) return;\r
- if (errorUp) ErrorPopDown();\r
- switch (gameMode) {\r
- case EditPosition:\r
- case IcsExamining:\r
- whichMenu = params[0];\r
- break;\r
- case IcsPlayingWhite:\r
- case IcsPlayingBlack:\r
- case EditGame:\r
- case MachinePlaysWhite:\r
- case MachinePlaysBlack:\r
- if (appData.testLegality &&\r
- gameInfo.variant != VariantBughouse &&\r
- gameInfo.variant != VariantCrazyhouse) return;\r
- SetupDropMenu();\r
- whichMenu = "menuD";\r
- break;\r
- default:\r
- return;\r
- }\r
- \r
- if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_WIDTH)) < 0) ||\r
- ((pmFromY = EventToSquare(event->xbutton.y, BOARD_HEIGHT)) < 0)) {\r
- pmFromX = pmFromY = -1;\r
- return;\r
- }\r
- if (flipView)\r
- pmFromX = BOARD_WIDTH - 1 - pmFromX;\r
- else\r
- pmFromY = BOARD_HEIGHT - 1 - pmFromY;\r
- \r
- XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));\r
-}\r
-\r
-static void PieceMenuSelect(w, piece, junk)\r
- Widget w;\r
- ChessSquare piece;\r
- caddr_t junk;\r
-{\r
- if (pmFromX < 0 || pmFromY < 0) return;\r
- EditPositionMenuEvent(piece, pmFromX, pmFromY);\r
-}\r
-\r
-static void DropMenuSelect(w, piece, junk)\r
- Widget w;\r
- ChessSquare piece;\r
- caddr_t junk;\r
-{\r
- if (pmFromX < 0 || pmFromY < 0) return;\r
- DropMenuEvent(piece, pmFromX, pmFromY);\r
-}\r
-\r
-void WhiteClock(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (gameMode == EditPosition || gameMode == IcsExamining) {\r
- SetWhiteToPlayEvent();\r
- } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {\r
- CallFlagEvent();\r
- }\r
-}\r
-\r
-void BlackClock(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (gameMode == EditPosition || gameMode == IcsExamining) {\r
- SetBlackToPlayEvent();\r
- } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {\r
- CallFlagEvent();\r
- }\r
-}\r
-\r
-\r
-/*\r
- * If the user selects on a border boundary, return -1; if off the board,\r
- * return -2. Otherwise map the event coordinate to the square.\r
- */\r
-int EventToSquare(x, limit)\r
- int x;\r
-{\r
- if (x <= 0) \r
- return -2;\r
- if (x < lineGap)\r
- return -1;\r
- x -= lineGap;\r
- if ((x % (squareSize + lineGap)) >= squareSize)\r
- return -1;\r
- x /= (squareSize + lineGap);\r
- if (x >= limit)\r
- return -2;\r
- return x;\r
-}\r
-\r
-static void do_flash_delay(msec)\r
- unsigned long msec;\r
-{\r
- TimeDelay(msec);\r
-}\r
-\r
-static void drawHighlight(file, rank, gc)\r
- int file, rank;\r
- GC gc;\r
-{\r
- int x, y;\r
-\r
- if (lineGap == 0 || appData.blindfold) return;\r
- \r
- if (flipView) {\r
- x = lineGap/2 + ((BOARD_WIDTH-1)-file) * \r
- (squareSize + lineGap);\r
- y = lineGap/2 + rank * (squareSize + lineGap);\r
- } else {\r
- x = lineGap/2 + file * (squareSize + lineGap);\r
- y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) * \r
- (squareSize + lineGap);\r
- }\r
- \r
- XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,\r
- squareSize+lineGap, squareSize+lineGap);\r
-}\r
-\r
-int hi1X = -1, hi1Y = -1, hi2X = -1, hi2Y = -1;\r
-int pm1X = -1, pm1Y = -1, pm2X = -1, pm2Y = -1;\r
-\r
-void\r
-SetHighlights(fromX, fromY, toX, toY)\r
- int fromX, fromY, toX, toY;\r
-{\r
- if (hi1X != fromX || hi1Y != fromY) {\r
- if (hi1X >= 0 && hi1Y >= 0) {\r
- drawHighlight(hi1X, hi1Y, lineGC);\r
- }\r
- if (fromX >= 0 && fromY >= 0) {\r
- drawHighlight(fromX, fromY, highlineGC);\r
- }\r
- }\r
- if (hi2X != toX || hi2Y != toY) {\r
- if (hi2X >= 0 && hi2Y >= 0) {\r
- drawHighlight(hi2X, hi2Y, lineGC);\r
- }\r
- if (toX >= 0 && toY >= 0) {\r
- drawHighlight(toX, toY, highlineGC);\r
- }\r
- }\r
- hi1X = fromX;\r
- hi1Y = fromY;\r
- hi2X = toX;\r
- hi2Y = toY;\r
-}\r
-\r
-void\r
-ClearHighlights()\r
-{\r
- SetHighlights(-1, -1, -1, -1);\r
-}\r
-\r
-\r
-void\r
-SetPremoveHighlights(fromX, fromY, toX, toY)\r
- int fromX, fromY, toX, toY;\r
-{\r
- if (pm1X != fromX || pm1Y != fromY) {\r
- if (pm1X >= 0 && pm1Y >= 0) {\r
- drawHighlight(pm1X, pm1Y, lineGC);\r
- }\r
- if (fromX >= 0 && fromY >= 0) {\r
- drawHighlight(fromX, fromY, prelineGC);\r
- }\r
- }\r
- if (pm2X != toX || pm2Y != toY) {\r
- if (pm2X >= 0 && pm2Y >= 0) {\r
- drawHighlight(pm2X, pm2Y, lineGC);\r
- }\r
- if (toX >= 0 && toY >= 0) {\r
- drawHighlight(toX, toY, prelineGC);\r
- }\r
- }\r
- pm1X = fromX;\r
- pm1Y = fromY;\r
- pm2X = toX;\r
- pm2Y = toY;\r
-}\r
-\r
-void\r
-ClearPremoveHighlights()\r
-{\r
- SetPremoveHighlights(-1, -1, -1, -1);\r
-}\r
-\r
-static void BlankSquare(x, y, color, piece, dest)\r
- int x, y, color;\r
- ChessSquare piece;\r
- Drawable dest;\r
-{\r
- if (useImages && useImageSqs) {\r
- Pixmap pm;\r
- switch (color) {\r
- case 1: /* light */\r
- pm = xpmLightSquare;\r
- break;\r
- case 0: /* dark */\r
- pm = xpmDarkSquare;\r
- break;\r
- case 2: /* neutral */\r
- default:\r
- pm = xpmJailSquare;\r
- break;\r
- }\r
- XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,\r
- squareSize, squareSize, x, y);\r
- } else {\r
- GC gc;\r
- switch (color) {\r
- case 1: /* light */\r
- gc = lightSquareGC;\r
- break;\r
- case 0: /* dark */\r
- gc = darkSquareGC;\r
- break;\r
- case 2: /* neutral */\r
- default:\r
- gc = jailSquareGC;\r
- break;\r
- }\r
- XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);\r
- }\r
-}\r
-\r
-/*\r
- I split out the routines to draw a piece so that I could\r
- make a generic flash routine.\r
-*/\r
-static void monoDrawPiece_1bit(piece, square_color, x, y, dest)\r
- ChessSquare piece;\r
- int square_color, x, y;\r
- Drawable dest;\r
-{\r
- /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */\r
- switch (square_color) {\r
- case 1: /* light */\r
- case 2: /* neutral */\r
- default:\r
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn\r
- ? *pieceToOutline(piece)\r
- : *pieceToSolid(piece),\r
- dest, bwPieceGC, 0, 0,\r
- squareSize, squareSize, x, y);\r
- break;\r
- case 0: /* dark */\r
- XCopyArea(xDisplay, (int) piece < (int) BlackPawn\r
- ? *pieceToSolid(piece)\r
- : *pieceToOutline(piece),\r
- dest, wbPieceGC, 0, 0,\r
- squareSize, squareSize, x, y);\r
- break;\r
- }\r
-}\r
-\r
-static void monoDrawPiece(piece, square_color, x, y, dest)\r
- ChessSquare piece;\r
- int square_color, x, y;\r
- Drawable dest;\r
-{\r
- switch (square_color) {\r
- case 1: /* light */\r
- case 2: /* neutral */\r
- default:\r
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn\r
- ? *pieceToOutline(piece)\r
- : *pieceToSolid(piece),\r
- dest, bwPieceGC, 0, 0,\r
- squareSize, squareSize, x, y, 1);\r
- break;\r
- case 0: /* dark */\r
- XCopyPlane(xDisplay, (int) piece < (int) BlackPawn\r
- ? *pieceToSolid(piece)\r
- : *pieceToOutline(piece),\r
- dest, wbPieceGC, 0, 0,\r
- squareSize, squareSize, x, y, 1);\r
- break;\r
- }\r
-}\r
-\r
-static void colorDrawPiece(piece, square_color, x, y, dest)\r
- ChessSquare piece;\r
- int square_color, x, y;\r
- Drawable dest;\r
-{\r
- if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;\r
- switch (square_color) {\r
- case 1: /* light */\r
- XCopyPlane(xDisplay, *pieceToSolid(piece),\r
- dest, (int) piece < (int) BlackPawn\r
- ? wlPieceGC : blPieceGC, 0, 0,\r
- squareSize, squareSize, x, y, 1);\r
- break;\r
- case 0: /* dark */\r
- XCopyPlane(xDisplay, *pieceToSolid(piece),\r
- dest, (int) piece < (int) BlackPawn\r
- ? wdPieceGC : bdPieceGC, 0, 0,\r
- squareSize, squareSize, x, y, 1);\r
- break;\r
- case 2: /* neutral */\r
- default:\r
- XCopyPlane(xDisplay, *pieceToSolid(piece),\r
- dest, (int) piece < (int) BlackPawn\r
- ? wjPieceGC : bjPieceGC, 0, 0,\r
- squareSize, squareSize, x, y, 1);\r
- break;\r
- }\r
-}\r
-\r
-static void colorDrawPieceImage(piece, square_color, x, y, dest)\r
- ChessSquare piece;\r
- int square_color, x, y;\r
- Drawable dest;\r
-{\r
- int kind;\r
-\r
- switch (square_color) {\r
- case 1: /* light */\r
- case 2: /* neutral */\r
- default:\r
- if ((int)piece < (int) BlackPawn) {\r
- kind = 0;\r
- } else {\r
- kind = 2;\r
- piece -= BlackPawn;\r
- }\r
- break;\r
- case 0: /* dark */\r
- if ((int)piece < (int) BlackPawn) {\r
- kind = 1;\r
- } else {\r
- kind = 3;\r
- piece -= BlackPawn;\r
- }\r
- break;\r
- }\r
- XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],\r
- dest, wlPieceGC, 0, 0,\r
- squareSize, squareSize, x, y); \r
-}\r
-\r
-typedef void (*DrawFunc)();\r
-\r
-DrawFunc ChooseDrawFunc()\r
-{\r
- if (appData.monoMode) {\r
- if (DefaultDepth(xDisplay, xScreen) == 1) {\r
- return monoDrawPiece_1bit;\r
- } else {\r
- return monoDrawPiece;\r
- }\r
- } else {\r
- if (useImages)\r
- return colorDrawPieceImage;\r
- else\r
- return colorDrawPiece;\r
- }\r
-}\r
-\r
-/* [HR] determine square color depending on chess variant. */\r
-static int SquareColor(row, column)\r
- int row, column;\r
-{\r
- int square_color;\r
-\r
- if (gameInfo.variant == VariantXiangqi) {\r
- if (column >= 3 && column <= 5 && row >= 0 && row <= 2) {\r
- square_color = 0;\r
- } else if (column >= 3 && column <= 5 && row >= 7 && row <= 9) {\r
- square_color = 1;\r
- } else if (row <= 4) {\r
- square_color = 1;\r
- } else {\r
- square_color = 0;\r
- }\r
- } else {\r
- square_color = ((column + row) % 2) == 1;\r
- }\r
-\r
- /* [hgm] holdings: next line makes all holdings squares light */\r
- if(column < BOARD_LEFT || column >= BOARD_RGHT) square_color = 0;\r
- \r
- return square_color;\r
-}\r
-\r
-void DrawSquare(row, column, piece, do_flash)\r
- int row, column, do_flash;\r
- ChessSquare piece;\r
-{\r
- int square_color, x, y, direction, font_ascent, font_descent;\r
- int i;\r
- char string[2];\r
- XCharStruct overall;\r
- DrawFunc drawfunc;\r
- int flash_delay;\r
-\r
- /* Calculate delay in milliseconds (2-delays per complete flash) */\r
- flash_delay = 500 / appData.flashRate;\r
- \r
- if (flipView) {\r
- x = lineGap + ((BOARD_WIDTH-1)-column) * \r
- (squareSize + lineGap);\r
- y = lineGap + row * (squareSize + lineGap);\r
- } else {\r
- x = lineGap + column * (squareSize + lineGap);\r
- y = lineGap + ((BOARD_HEIGHT-1)-row) * \r
- (squareSize + lineGap);\r
- }\r
- \r
- square_color = SquareColor(row, column);\r
- \r
- if ( // [HGM] holdings: next 5 lines blank out area between board and holdings\r
- column == BOARD_LEFT-1 || column == BOARD_RGHT\r
- || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)\r
- || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {\r
- BlankSquare(x, y, 2, EmptySquare, xBoardWindow);\r
- } else {\r
- if (piece == EmptySquare || appData.blindfold) {\r
- BlankSquare(x, y, square_color, piece, xBoardWindow);\r
- } else {\r
- drawfunc = ChooseDrawFunc();\r
- if (do_flash && appData.flashCount > 0) {\r
- for (i=0; i<appData.flashCount; ++i) {\r
-\r
- drawfunc(piece, square_color, x, y, xBoardWindow);\r
- XSync(xDisplay, False);\r
- do_flash_delay(flash_delay);\r
-\r
- BlankSquare(x, y, square_color, piece, xBoardWindow);\r
- XSync(xDisplay, False);\r
- do_flash_delay(flash_delay);\r
- }\r
- }\r
- drawfunc(piece, square_color, x, y, xBoardWindow);\r
- }\r
- }\r
- \r
- string[1] = NULLCHAR;\r
- if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)) {\r
- string[0] = 'a' + column;\r
- XTextExtents(coordFontStruct, string, 1, &direction, \r
- &font_ascent, &font_descent, &overall);\r
- if (appData.monoMode) {\r
- XDrawImageString(xDisplay, xBoardWindow, coordGC,\r
- x + squareSize - overall.width - 2, \r
- y + squareSize - font_descent - 1, string, 1);\r
- } else {\r
- XDrawString(xDisplay, xBoardWindow, coordGC,\r
- x + squareSize - overall.width - 2, \r
- y + squareSize - font_descent - 1, string, 1);\r
- }\r
- }\r
- if (appData.showCoords && column == (flipView ? BOARD_WIDTH-1 : 0)) {\r
- string[0] = ONE + row;\r
- XTextExtents(coordFontStruct, string, 1, &direction, \r
- &font_ascent, &font_descent, &overall);\r
- if (appData.monoMode) {\r
- XDrawImageString(xDisplay, xBoardWindow, coordGC,\r
- x + 2, y + font_ascent + 1, string, 1);\r
- } else {\r
- XDrawString(xDisplay, xBoardWindow, coordGC,\r
- x + 2, y + font_ascent + 1, string, 1);\r
- } \r
- } \r
-}\r
-\r
-\r
-/* Why is this needed on some versions of X? */\r
-void EventProc(widget, unused, event)\r
- Widget widget;\r
- caddr_t unused;\r
- XEvent *event;\r
-{\r
- if (!XtIsRealized(widget))\r
- return;\r
-\r
- switch (event->type) {\r
- case Expose:\r
- if (event->xexpose.count > 0) return; /* no clipping is done */\r
- XDrawPosition(widget, True, NULL);\r
- break;\r
- default:\r
- return;\r
- }\r
-}\r
-/* end why */\r
-\r
-void DrawPosition(fullRedraw, board)\r
- /*Boolean*/int fullRedraw;\r
- Board board;\r
-{\r
- XDrawPosition(boardWidget, fullRedraw, board);\r
-}\r
-\r
-/* Returns 1 if there are "too many" differences between b1 and b2\r
- (i.e. more than 1 move was made) */\r
-static int too_many_diffs(b1, b2)\r
- Board b1, b2;\r
-{\r
- int i, j;\r
- int c = 0;\r
- \r
- for (i=0; i<BOARD_HEIGHT; ++i) {\r
- for (j=0; j<BOARD_WIDTH; ++j) {\r
- if (b1[i][j] != b2[i][j]) {\r
- if (++c > 4) /* Castling causes 4 diffs */\r
- return 1;\r
- }\r
- }\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-/* Matrix describing castling maneuvers */\r
-/* Row, ColRookFrom, ColKingFrom, ColRookTo, ColKingTo */\r
-static int castling_matrix[4][5] = {\r
- { 0, 0, 4, 3, 2 }, /* 0-0-0, white */\r
- { 0, 7, 4, 5, 6 }, /* 0-0, white */\r
- { 7, 0, 4, 3, 2 }, /* 0-0-0, black */\r
- { 7, 7, 4, 5, 6 } /* 0-0, black */\r
-};\r
-\r
-/* Checks whether castling occurred. If it did, *rrow and *rcol\r
- are set to the destination (row,col) of the rook that moved.\r
- \r
- Returns 1 if castling occurred, 0 if not.\r
- \r
- Note: Only handles a max of 1 castling move, so be sure\r
- to call too_many_diffs() first.\r
- */\r
-static int check_castle_draw(newb, oldb, rrow, rcol)\r
- Board newb, oldb;\r
- int *rrow, *rcol;\r
-{\r
- int i, *r, j;\r
- int match;\r
-\r
- /* For each type of castling... */\r
- for (i=0; i<4; ++i) {\r
- r = castling_matrix[i];\r
-\r
- /* Check the 4 squares involved in the castling move */\r
- match = 0;\r
- for (j=1; j<=4; ++j) {\r
- if (newb[r[0]][r[j]] == oldb[r[0]][r[j]]) {\r
- match = 1;\r
- break;\r
- }\r
- }\r
-\r
- if (!match) {\r
- /* All 4 changed, so it must be a castling move */\r
- *rrow = r[0];\r
- *rcol = r[3];\r
- return 1;\r
- }\r
- }\r
- return 0;\r
-}\r
-\r
-static int damage[BOARD_SIZE][BOARD_SIZE];\r
-\r
-/*\r
- * event handler for redrawing the board\r
- */\r
-void XDrawPosition(w, repaint, board)\r
- Widget w;\r
- /*Boolean*/int repaint;\r
- Board board;\r
-{\r
- int i, j, do_flash;\r
- static int lastFlipView = 0;\r
- static int lastBoardValid = 0;\r
- static Board lastBoard;\r
- Arg args[16];\r
- int rrow, rcol;\r
- \r
- if (board == NULL) {\r
- if (!lastBoardValid) return;\r
- board = lastBoard;\r
- }\r
- if (!lastBoardValid || lastFlipView != flipView) {\r
- XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),\r
- args, 1);\r
- }\r
-\r
- /*\r
- * It would be simpler to clear the window with XClearWindow()\r
- * but this causes a very distracting flicker.\r
- */\r
- \r
- if (!repaint && lastBoardValid && lastFlipView == flipView) {\r
-\r
- /* If too much changes (begin observing new game, etc.), don't\r
- do flashing */\r
- do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;\r
-\r
- /* Special check for castling so we don't flash both the king\r
- and the rook (just flash the king). */\r
- if (do_flash) {\r
- if (check_castle_draw(board, lastBoard, &rrow, &rcol)) {\r
- /* Draw rook with NO flashing. King will be drawn flashing later */\r
- DrawSquare(rrow, rcol, board[rrow][rcol], 0);\r
- lastBoard[rrow][rcol] = board[rrow][rcol];\r
- }\r
- }\r
-\r
- /* First pass -- Draw (newly) empty squares and repair damage. \r
- This prevents you from having a piece show up twice while it \r
- is flashing on its new square */\r
- for (i = 0; i < BOARD_HEIGHT; i++)\r
- for (j = 0; j < BOARD_WIDTH; j++)\r
- if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)\r
- || damage[i][j]) {\r
- DrawSquare(i, j, board[i][j], 0);\r
- damage[i][j] = False;\r
- }\r
-\r
- /* Second pass -- Draw piece(s) in new position and flash them */\r
- for (i = 0; i < BOARD_HEIGHT; i++)\r
- for (j = 0; j < BOARD_WIDTH; j++)\r
- if (board[i][j] != lastBoard[i][j]) {\r
- DrawSquare(i, j, board[i][j], do_flash); \r
- }\r
- } else {\r
- if (lineGap > 0)\r
- XDrawSegments(xDisplay, xBoardWindow, lineGC,\r
- gridSegments, (BOARD_SIZE + 1) * 2);\r
- \r
- for (i = 0; i < BOARD_HEIGHT; i++)\r
- for (j = 0; j < BOARD_WIDTH; j++) {\r
- DrawSquare(i, j, board[i][j], 0);\r
- damage[i][j] = False;\r
- }\r
- }\r
-\r
- CopyBoard(lastBoard, board);\r
- lastBoardValid = 1;\r
- lastFlipView = flipView;\r
-\r
- /* Draw highlights */\r
- if (pm1X >= 0 && pm1Y >= 0) {\r
- drawHighlight(pm1X, pm1Y, prelineGC);\r
- }\r
- if (pm2X >= 0 && pm2Y >= 0) {\r
- drawHighlight(pm2X, pm2Y, prelineGC);\r
- }\r
- if (hi1X >= 0 && hi1Y >= 0) {\r
- drawHighlight(hi1X, hi1Y, highlineGC);\r
- }\r
- if (hi2X >= 0 && hi2Y >= 0) {\r
- drawHighlight(hi2X, hi2Y, highlineGC);\r
- }\r
-\r
- /* If piece being dragged around board, must redraw that too */\r
- DrawDragPiece();\r
-\r
- XSync(xDisplay, False);\r
-}\r
-\r
-\r
-/*\r
- * event handler for redrawing the board\r
- */\r
-void DrawPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- XDrawPosition(w, True, NULL);\r
-}\r
-\r
-\r
-/*\r
- * event handler for parsing user moves\r
- */\r
-// [HGM] This routine will need quite some reworking. Although the backend still supports the old\r
-// way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform\r
-// it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it\r
-// should be made to use the new way, of calling UserMoveTest early to determine the legality of the\r
-// move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),\r
-// and at the end FinishMove() to perform the move after optional promotion popups.\r
-// For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.\r
-void HandleUserMove(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- int x, y;\r
- Boolean saveAnimate;\r
- static int second = 0;\r
- \r
- if (w != boardWidget || errorExitStatus != -1) return;\r
-\r
- if (event->type == ButtonPress) ErrorPopDown();\r
-\r
- if (promotionUp) {\r
- if (event->type == ButtonPress) {\r
- XtPopdown(promotionShell);\r
- XtDestroyWidget(promotionShell);\r
- promotionUp = False;\r
- ClearHighlights();\r
- fromX = fromY = -1;\r
- } else {\r
- return;\r
- }\r
- }\r
- \r
- x = EventToSquare(event->xbutton.x, BOARD_WIDTH);\r
- y = EventToSquare(event->xbutton.y, BOARD_HEIGHT);\r
- if (!flipView && y >= 0) {\r
- y = BOARD_HEIGHT - 1 - y;\r
- }\r
- if (flipView && x >= 0) {\r
- x = BOARD_WIDTH - 1 - x;\r
- }\r
-\r
- /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */\r
- if(event->type == ButtonPress\r
- && ( x == BOARD_LEFT-1 || x == BOARD_RGHT\r
- || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize\r
- || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )\r
- return;\r
-\r
- if (fromX == -1) {\r
- if (event->type == ButtonPress) {\r
- /* First square */ \r
- if (OKToStartUserMove(x, y)) {\r
- fromX = x;\r
- fromY = y;\r
- second = 0;\r
- DragPieceBegin(event->xbutton.x, event->xbutton.y);\r
- if (appData.highlightDragging) {\r
- SetHighlights(x, y, -1, -1);\r
- }\r
- } \r
- }\r
- return;\r
- }\r
-\r
- /* fromX != -1 */\r
- if (event->type == ButtonPress && gameMode != EditPosition &&\r
- x >= 0 && y >= 0) {\r
- ChessSquare fromP;\r
- ChessSquare toP;\r
-\r
- /* Check if clicking again on the same color piece */\r
- fromP = boards[currentMove][fromY][fromX];\r
- toP = boards[currentMove][y][x];\r
- if ((WhitePawn <= fromP && fromP < WhiteKing && // [HGM] this test should go, as UserMoveTest now does it.\r
- WhitePawn <= toP && toP <= WhiteKing) || // For now I made it less critical by exempting King\r
- (BlackPawn <= fromP && fromP < BlackKing && // moves, to not interfere with FRC castlings.\r
- BlackPawn <= toP && toP <= BlackKing)) {\r
- /* Clicked again on same color piece -- changed his mind */\r
- second = (x == fromX && y == fromY);\r
- if (appData.highlightDragging) {\r
- SetHighlights(x, y, -1, -1);\r
- } else {\r
- ClearHighlights();\r
- }\r
- if (OKToStartUserMove(x, y)) {\r
- fromX = x;\r
- fromY = y;\r
- DragPieceBegin(event->xbutton.x, event->xbutton.y);\r
- }\r
- return;\r
- }\r
- }\r
-\r
- if (event->type == ButtonRelease && x == fromX && y == fromY) {\r
- DragPieceEnd(event->xbutton.x, event->xbutton.y);\r
- if (appData.animateDragging) {\r
- /* Undo animation damage if any */\r
- DrawPosition(FALSE, NULL);\r
- }\r
- if (second) {\r
- /* Second up/down in same square; just abort move */\r
- second = 0;\r
- fromX = fromY = -1;\r
- ClearHighlights();\r
- gotPremove = 0;\r
- ClearPremoveHighlights();\r
- } else {\r
- /* First upclick in same square; start click-click mode */\r
- SetHighlights(x, y, -1, -1);\r
- }\r
- return;\r
- } \r
-\r
- /* Completed move */\r
- toX = x;\r
- toY = y;\r
- saveAnimate = appData.animate;\r
- if (event->type == ButtonPress) {\r
- /* Finish clickclick move */\r
- if (appData.animate || appData.highlightLastMove) {\r
- SetHighlights(fromX, fromY, toX, toY);\r
- } else {\r
- ClearHighlights();\r
- }\r
- } else {\r
- /* Finish drag move */\r
- if (appData.highlightLastMove) {\r
- SetHighlights(fromX, fromY, toX, toY);\r
- } else {\r
- ClearHighlights();\r
- }\r
- DragPieceEnd(event->xbutton.x, event->xbutton.y);\r
- /* Don't animate move and drag both */\r
- appData.animate = FALSE;\r
- }\r
- if (IsPromotion(fromX, fromY, toX, toY)) {\r
- if (appData.alwaysPromoteToQueen) {\r
- UserMoveEvent(fromX, fromY, toX, toY, 'q');\r
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();\r
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);\r
- fromX = fromY = -1;\r
- } else {\r
- SetHighlights(fromX, fromY, toX, toY);\r
- PromotionPopUp();\r
- }\r
- } else {\r
- UserMoveEvent(fromX, fromY, toX, toY, NULLCHAR);\r
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();\r
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);\r
- fromX = fromY = -1;\r
- }\r
- appData.animate = saveAnimate;\r
- if (appData.animate || appData.animateDragging) {\r
- /* Undo animation damage if needed */\r
- DrawPosition(FALSE, NULL);\r
- }\r
-}\r
-\r
-void AnimateUserMove (Widget w, XEvent * event,\r
- String * params, Cardinal * nParams)\r
-{\r
- DragPieceMove(event->xmotion.x, event->xmotion.y);\r
-}\r
-\r
-Widget CommentCreate(name, text, mutable, callback, lines)\r
- char *name, *text;\r
- int /*Boolean*/ mutable;\r
- XtCallbackProc callback;\r
- int lines;\r
-{\r
- Arg args[16];\r
- Widget shell, layout, form, edit, b_ok, b_cancel, b_clear, b_close, b_edit;\r
- Dimension bw_width;\r
- int j;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNwidth, &bw_width); j++;\r
- XtGetValues(boardWidget, args, j);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNresizable, True); j++;\r
-#if TOPLEVEL\r
- shell =\r
- XtCreatePopupShell(name, topLevelShellWidgetClass,\r
- shellWidget, args, j);\r
-#else\r
- shell =\r
- XtCreatePopupShell(name, transientShellWidgetClass,\r
- shellWidget, args, j);\r
-#endif\r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, shell,\r
- layoutArgs, XtNumber(layoutArgs));\r
- form =\r
- XtCreateManagedWidget("form", formWidgetClass, layout,\r
- formArgs, XtNumber(formArgs));\r
-\r
- j = 0;\r
- if (mutable) {\r
- XtSetArg(args[j], XtNeditType, XawtextEdit); j++;\r
- XtSetArg(args[j], XtNuseStringInPlace, False); j++;\r
- }\r
- XtSetArg(args[j], XtNstring, text); j++;\r
- XtSetArg(args[j], XtNtop, XtChainTop); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainRight); j++;\r
- XtSetArg(args[j], XtNresizable, True); j++;\r
- XtSetArg(args[j], XtNwidth, bw_width); j++; /*force wider than buttons*/\r
-#if 0\r
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded); j++;\r
-#else\r
- /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */\r
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;\r
-#endif\r
- XtSetArg(args[j], XtNautoFill, True); j++;\r
- XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;\r
- edit =\r
- XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);\r
-\r
- if (mutable) {\r
- j = 0;\r
- XtSetArg(args[j], XtNfromVert, edit); j++;\r
- XtSetArg(args[j], XtNtop, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainLeft); j++;\r
- b_ok =\r
- XtCreateManagedWidget("ok", commandWidgetClass, form, args, j);\r
- XtAddCallback(b_ok, XtNcallback, callback, (XtPointer) 0);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNfromVert, edit); j++;\r
- XtSetArg(args[j], XtNfromHoriz, b_ok); j++;\r
- XtSetArg(args[j], XtNtop, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainLeft); j++;\r
- b_cancel =\r
- XtCreateManagedWidget("cancel", commandWidgetClass, form, args, j);\r
- XtAddCallback(b_cancel, XtNcallback, callback, (XtPointer) 0);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNfromVert, edit); j++;\r
- XtSetArg(args[j], XtNfromHoriz, b_cancel); j++;\r
- XtSetArg(args[j], XtNtop, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainLeft); j++;\r
- b_clear =\r
- XtCreateManagedWidget("clear", commandWidgetClass, form, args, j);\r
- XtAddCallback(b_clear, XtNcallback, callback, (XtPointer) 0);\r
- } else {\r
- j = 0;\r
- XtSetArg(args[j], XtNfromVert, edit); j++;\r
- XtSetArg(args[j], XtNtop, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainLeft); j++;\r
- b_close =\r
- XtCreateManagedWidget("close", commandWidgetClass, form, args, j);\r
- XtAddCallback(b_close, XtNcallback, callback, (XtPointer) 0);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNfromVert, edit); j++;\r
- XtSetArg(args[j], XtNfromHoriz, b_close); j++;\r
- XtSetArg(args[j], XtNtop, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainLeft); j++;\r
- b_edit =\r
- XtCreateManagedWidget("edit", commandWidgetClass, form, args, j);\r
- XtAddCallback(b_edit, XtNcallback, callback, (XtPointer) 0);\r
- }\r
-\r
- XtRealizeWidget(shell);\r
-\r
- if (commentX == -1) {\r
- int xx, yy;\r
- Window junk;\r
- Dimension pw_height;\r
- Dimension ew_height;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, &ew_height); j++;\r
- XtGetValues(edit, args, j);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, &pw_height); j++;\r
- XtGetValues(shell, args, j);\r
- commentH = pw_height + (lines - 1) * ew_height;\r
- commentW = bw_width - 16;\r
-\r
- XSync(xDisplay, False);\r
-#ifdef NOTDEF\r
- /* This code seems to tickle an X bug if it is executed too soon\r
- after xboard starts up. The coordinates get transformed as if\r
- the main window was positioned at (0, 0).\r
- */\r
- XtTranslateCoords(shellWidget,\r
- (bw_width - commentW) / 2, 0 - commentH / 2,\r
- &commentX, &commentY);\r
-#else /*!NOTDEF*/\r
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),\r
- RootWindowOfScreen(XtScreen(shellWidget)),\r
- (bw_width - commentW) / 2, 0 - commentH / 2,\r
- &xx, &yy, &junk);\r
- commentX = xx;\r
- commentY = yy;\r
-#endif /*!NOTDEF*/\r
- if (commentY < 0) commentY = 0; /*avoid positioning top offscreen*/\r
- }\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, commentH); j++;\r
- XtSetArg(args[j], XtNwidth, commentW); j++;\r
- XtSetArg(args[j], XtNx, commentX); j++;\r
- XtSetArg(args[j], XtNy, commentY); j++;\r
- XtSetValues(shell, args, j);\r
- XtSetKeyboardFocus(shell, edit);\r
-\r
- return shell;\r
-}\r
-\r
-/* Used for analysis window and ICS input window */\r
-Widget MiscCreate(name, text, mutable, callback, lines)\r
- char *name, *text;\r
- int /*Boolean*/ mutable;\r
- XtCallbackProc callback;\r
- int lines;\r
-{\r
- Arg args[16];\r
- Widget shell, layout, form, edit;\r
- Position x, y;\r
- Dimension bw_width, pw_height, ew_height, w, h;\r
- int j;\r
- int xx, yy;\r
- Window junk;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNresizable, True); j++;\r
-#if TOPLEVEL\r
- shell =\r
- XtCreatePopupShell(name, topLevelShellWidgetClass,\r
- shellWidget, args, j);\r
-#else\r
- shell =\r
- XtCreatePopupShell(name, transientShellWidgetClass,\r
- shellWidget, args, j);\r
-#endif\r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, shell,\r
- layoutArgs, XtNumber(layoutArgs));\r
- form =\r
- XtCreateManagedWidget("form", formWidgetClass, layout,\r
- formArgs, XtNumber(formArgs));\r
-\r
- j = 0;\r
- if (mutable) {\r
- XtSetArg(args[j], XtNeditType, XawtextEdit); j++;\r
- XtSetArg(args[j], XtNuseStringInPlace, False); j++;\r
- }\r
- XtSetArg(args[j], XtNstring, text); j++;\r
- XtSetArg(args[j], XtNtop, XtChainTop); j++;\r
- XtSetArg(args[j], XtNbottom, XtChainBottom); j++;\r
- XtSetArg(args[j], XtNleft, XtChainLeft); j++;\r
- XtSetArg(args[j], XtNright, XtChainRight); j++;\r
- XtSetArg(args[j], XtNresizable, True); j++;\r
-#if 0\r
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded); j++;\r
-#else\r
- /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */\r
- XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;\r
-#endif\r
- XtSetArg(args[j], XtNautoFill, True); j++;\r
- XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;\r
- edit =\r
- XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);\r
-\r
- XtRealizeWidget(shell);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNwidth, &bw_width); j++;\r
- XtGetValues(boardWidget, args, j);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, &ew_height); j++;\r
- XtGetValues(edit, args, j);\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, &pw_height); j++;\r
- XtGetValues(shell, args, j);\r
- h = pw_height + (lines - 1) * ew_height;\r
- w = bw_width - 16;\r
-\r
- XSync(xDisplay, False);\r
-#ifdef NOTDEF\r
- /* This code seems to tickle an X bug if it is executed too soon\r
- after xboard starts up. The coordinates get transformed as if\r
- the main window was positioned at (0, 0).\r
- */\r
- XtTranslateCoords(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);\r
-#else /*!NOTDEF*/\r
- XTranslateCoordinates(xDisplay, XtWindow(shellWidget),\r
- RootWindowOfScreen(XtScreen(shellWidget)),\r
- (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);\r
-#endif /*!NOTDEF*/\r
- x = xx;\r
- y = yy;\r
- if (y < 0) y = 0; /*avoid positioning top offscreen*/\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNheight, h); j++;\r
- XtSetArg(args[j], XtNwidth, w); j++;\r
- XtSetArg(args[j], XtNx, x); j++;\r
- XtSetArg(args[j], XtNy, y); j++;\r
- XtSetValues(shell, args, j);\r
-\r
- return shell;\r
-}\r
-\r
-\r
-static int savedIndex; /* gross that this is global */\r
-\r
-void EditCommentPopUp(index, title, text)\r
- int index;\r
- char *title, *text;\r
-{\r
- Widget edit;\r
- Arg args[16];\r
- int j;\r
-\r
- savedIndex = index;\r
- if (text == NULL) text = "";\r
-\r
- if (editShell == NULL) {\r
- editShell =\r
- CommentCreate(title, text, True, EditCommentCallback, 4); \r
- XtRealizeWidget(editShell);\r
- CatchDeleteWindow(editShell, "EditCommentPopDown");\r
- } else {\r
- edit = XtNameToWidget(editShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, text); j++;\r
- XtSetValues(edit, args, j);\r
- j = 0;\r
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;\r
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;\r
- XtSetValues(editShell, args, j);\r
- }\r
-\r
- XtPopup(editShell, XtGrabNone);\r
-\r
- editUp = True;\r
- j = 0;\r
- XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),\r
- args, j);\r
-}\r
-\r
-void EditCommentCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- String name, val;\r
- Arg args[16];\r
- int j;\r
- Widget edit;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNlabel, &name); j++;\r
- XtGetValues(w, args, j);\r
-\r
- if (strcmp(name, "ok") == 0) {\r
- edit = XtNameToWidget(editShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, &val); j++;\r
- XtGetValues(edit, args, j);\r
- ReplaceComment(savedIndex, val);\r
- EditCommentPopDown();\r
- } else if (strcmp(name, "cancel") == 0) {\r
- EditCommentPopDown();\r
- } else if (strcmp(name, "clear") == 0) {\r
- edit = XtNameToWidget(editShell, "*form.text");\r
- XtCallActionProc(edit, "select-all", NULL, NULL, 0);\r
- XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);\r
- }\r
-}\r
-\r
-void EditCommentPopDown()\r
-{\r
- Arg args[16];\r
- int j;\r
-\r
- if (!editUp) return;\r
- j = 0;\r
- XtSetArg(args[j], XtNx, &commentX); j++;\r
- XtSetArg(args[j], XtNy, &commentY); j++;\r
- XtSetArg(args[j], XtNheight, &commentH); j++;\r
- XtSetArg(args[j], XtNwidth, &commentW); j++;\r
- XtGetValues(editShell, args, j);\r
- XtPopdown(editShell);\r
- editUp = False;\r
- j = 0;\r
- XtSetArg(args[j], XtNleftBitmap, None); j++;\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),\r
- args, j);\r
-}\r
-\r
-void ICSInputBoxPopUp()\r
-{\r
- Widget edit;\r
- Arg args[16];\r
- int j;\r
- char *title = "ICS Input";\r
- XtTranslations tr;\r
- \r
- if (ICSInputShell == NULL) {\r
- ICSInputShell = MiscCreate(title, "", True, NULL, 1);\r
- tr = XtParseTranslationTable(ICSInputTranslations);\r
- edit = XtNameToWidget(ICSInputShell, "*form.text");\r
- XtOverrideTranslations(edit, tr);\r
- XtRealizeWidget(ICSInputShell);\r
- CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");\r
- \r
- } else {\r
- edit = XtNameToWidget(ICSInputShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, ""); j++;\r
- XtSetValues(edit, args, j);\r
- j = 0;\r
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;\r
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;\r
- XtSetValues(ICSInputShell, args, j);\r
- }\r
-\r
- XtPopup(ICSInputShell, XtGrabNone);\r
- XtSetKeyboardFocus(ICSInputShell, edit);\r
-\r
- ICSInputBoxUp = True;\r
- j = 0;\r
- XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),\r
- args, j);\r
-}\r
-\r
-void ICSInputSendText()\r
-{\r
- Widget edit;\r
- int j;\r
- Arg args[16];\r
- String val;\r
- \r
- edit = XtNameToWidget(ICSInputShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, &val); j++;\r
- XtGetValues(edit, args, j);\r
- SendMultiLineToICS(val);\r
- XtCallActionProc(edit, "select-all", NULL, NULL, 0);\r
- XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);\r
-}\r
-\r
-void ICSInputBoxPopDown()\r
-{\r
- Arg args[16];\r
- int j;\r
-\r
- if (!ICSInputBoxUp) return;\r
- j = 0;\r
- XtPopdown(ICSInputShell);\r
- ICSInputBoxUp = False;\r
- j = 0;\r
- XtSetArg(args[j], XtNleftBitmap, None); j++;\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),\r
- args, j);\r
-}\r
-\r
-void CommentPopUp(title, text)\r
- char *title, *text;\r
-{\r
- Arg args[16];\r
- int j;\r
- Widget edit;\r
-\r
- if (commentShell == NULL) {\r
- commentShell =\r
- CommentCreate(title, text, False, CommentCallback, 4);\r
- XtRealizeWidget(commentShell);\r
- CatchDeleteWindow(commentShell, "CommentPopDown");\r
- } else {\r
- edit = XtNameToWidget(commentShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, text); j++;\r
- XtSetValues(edit, args, j);\r
- j = 0;\r
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;\r
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;\r
- XtSetValues(commentShell, args, j);\r
- }\r
-\r
- XtPopup(commentShell, XtGrabNone);\r
- XSync(xDisplay, False);\r
-\r
- commentUp = True;\r
-}\r
-\r
-void AnalysisPopUp(title, text)\r
- char *title, *text;\r
-{\r
- Arg args[16];\r
- int j;\r
- Widget edit;\r
-\r
- if (analysisShell == NULL) {\r
- analysisShell = MiscCreate(title, text, False, NULL, 4);\r
- XtRealizeWidget(analysisShell);\r
- CatchDeleteWindow(analysisShell, "AnalysisPopDown");\r
-\r
- } else {\r
- edit = XtNameToWidget(analysisShell, "*form.text");\r
- j = 0;\r
- XtSetArg(args[j], XtNstring, text); j++;\r
- XtSetValues(edit, args, j);\r
- j = 0;\r
- XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;\r
- XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;\r
- XtSetValues(analysisShell, args, j);\r
- }\r
-\r
- if (!analysisUp) {\r
- XtPopup(analysisShell, XtGrabNone);\r
- }\r
- XSync(xDisplay, False);\r
-\r
- analysisUp = True;\r
-}\r
-\r
-void CommentCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- String name;\r
- Arg args[16];\r
- int j;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNlabel, &name); j++;\r
- XtGetValues(w, args, j);\r
-\r
- if (strcmp(name, "close") == 0) {\r
- CommentPopDown();\r
- } else if (strcmp(name, "edit") == 0) {\r
- CommentPopDown();\r
- EditCommentEvent();\r
- }\r
-}\r
-\r
-\r
-void CommentPopDown()\r
-{\r
- Arg args[16];\r
- int j;\r
-\r
- if (!commentUp) return;\r
- j = 0;\r
- XtSetArg(args[j], XtNx, &commentX); j++;\r
- XtSetArg(args[j], XtNy, &commentY); j++;\r
- XtSetArg(args[j], XtNwidth, &commentW); j++;\r
- XtSetArg(args[j], XtNheight, &commentH); j++;\r
- XtGetValues(commentShell, args, j);\r
- XtPopdown(commentShell);\r
- XSync(xDisplay, False);\r
- commentUp = False;\r
-}\r
-\r
-void AnalysisPopDown()\r
-{\r
- if (!analysisUp) return;\r
- XtPopdown(analysisShell);\r
- XSync(xDisplay, False);\r
- analysisUp = False;\r
-}\r
-\r
-\r
-void FileNamePopUp(label, def, proc, openMode)\r
- char *label;\r
- char *def;\r
- FileProc proc;\r
- char *openMode;\r
-{\r
- Arg args[16];\r
- Widget popup, layout, dialog, edit;\r
- Window root, child;\r
- int x, y, i;\r
- int win_x, win_y;\r
- unsigned int mask;\r
- \r
- fileProc = proc; /* I can't see a way not */\r
- fileOpenMode = openMode; /* to use globals here */\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNresizable, True); i++;\r
- XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;\r
- fileNameShell = popup =\r
- XtCreatePopupShell("File name prompt", transientShellWidgetClass,\r
- shellWidget, args, i);\r
- \r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,\r
- layoutArgs, XtNumber(layoutArgs));\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNlabel, label); i++;\r
- XtSetArg(args[i], XtNvalue, def); i++;\r
- XtSetArg(args[i], XtNborderWidth, 0); i++;\r
- dialog = XtCreateManagedWidget("fileName", dialogWidgetClass,\r
- layout, args, i);\r
- \r
- XawDialogAddButton(dialog, "ok", FileNameCallback, (XtPointer) dialog);\r
- XawDialogAddButton(dialog, "cancel", FileNameCallback,\r
- (XtPointer) dialog);\r
- \r
- XtRealizeWidget(popup);\r
- CatchDeleteWindow(popup, "FileNamePopDown");\r
- \r
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,\r
- &x, &y, &win_x, &win_y, &mask);\r
- \r
- XtSetArg(args[0], XtNx, x - 10);\r
- XtSetArg(args[1], XtNy, y - 30);\r
- XtSetValues(popup, args, 2);\r
- \r
- XtPopup(popup, XtGrabExclusive);\r
- filenameUp = True;\r
- \r
- edit = XtNameToWidget(dialog, "*value");\r
- XtSetKeyboardFocus(popup, edit);\r
-}\r
-\r
-void FileNamePopDown()\r
-{\r
- if (!filenameUp) return;\r
- XtPopdown(fileNameShell);\r
- XtDestroyWidget(fileNameShell);\r
- filenameUp = False;\r
- ModeHighlight();\r
-}\r
-\r
-void FileNameCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- String name;\r
- Arg args[16];\r
- \r
- XtSetArg(args[0], XtNlabel, &name);\r
- XtGetValues(w, args, 1);\r
- \r
- if (strcmp(name, "cancel") == 0) {\r
- FileNamePopDown();\r
- return;\r
- }\r
- \r
- FileNameAction(w, NULL, NULL, NULL);\r
-}\r
-\r
-void FileNameAction(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- char buf[MSG_SIZ];\r
- String name;\r
- FILE *f;\r
- char *p, *fullname;\r
- int index;\r
-\r
- name = XawDialogGetValueString(w = XtParent(w));\r
- \r
- if ((name != NULL) && (*name != NULLCHAR)) {\r
- strcpy(buf, name);\r
- XtPopdown(w = XtParent(XtParent(w)));\r
- XtDestroyWidget(w);\r
- filenameUp = False;\r
-\r
- p = strrchr(buf, ' ');\r
- if (p == NULL) {\r
- index = 0;\r
- } else {\r
- *p++ = NULLCHAR;\r
- index = atoi(p);\r
- }\r
- fullname = ExpandPathName(buf);\r
- if (!fullname) {\r
- ErrorPopUp("Error", "Can't open file", FALSE);\r
- }\r
- else {\r
- f = fopen(fullname, fileOpenMode);\r
- if (f == NULL) {\r
- DisplayError("Failed to open file", errno);\r
- } else {\r
- (void) (*fileProc)(f, index, buf);\r
- }\r
- }\r
- ModeHighlight();\r
- return;\r
- }\r
- \r
- XtPopdown(w = XtParent(XtParent(w)));\r
- XtDestroyWidget(w);\r
- filenameUp = False;\r
- ModeHighlight();\r
-}\r
-\r
-void PromotionPopUp()\r
-{\r
- Arg args[16];\r
- Widget dialog, layout;\r
- Position x, y;\r
- Dimension bw_width, pw_width;\r
- int j;\r
-\r
- j = 0;\r
- XtSetArg(args[j], XtNwidth, &bw_width); j++;\r
- XtGetValues(boardWidget, args, j);\r
- \r
- j = 0;\r
- XtSetArg(args[j], XtNresizable, True); j++;\r
- promotionShell =\r
- XtCreatePopupShell("Promotion", transientShellWidgetClass,\r
- shellWidget, args, j);\r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,\r
- layoutArgs, XtNumber(layoutArgs));\r
- \r
- j = 0;\r
- XtSetArg(args[j], XtNlabel, "Promote pawn to what?"); j++;\r
- XtSetArg(args[j], XtNborderWidth, 0); j++;\r
- dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,\r
- layout, args, j);\r
- \r
- XawDialogAddButton(dialog, "Queen", PromotionCallback, \r
- (XtPointer) dialog);\r
- XawDialogAddButton(dialog, "Rook", PromotionCallback, \r
- (XtPointer) dialog);\r
- XawDialogAddButton(dialog, "Bishop", PromotionCallback, \r
- (XtPointer) dialog);\r
- XawDialogAddButton(dialog, "Knight", PromotionCallback, \r
- (XtPointer) dialog);\r
- if (!appData.testLegality || gameInfo.variant == VariantSuicide ||\r
- gameInfo.variant == VariantGiveaway) {\r
- XawDialogAddButton(dialog, "King", PromotionCallback, \r
- (XtPointer) dialog);\r
- }\r
- XawDialogAddButton(dialog, "cancel", PromotionCallback, \r
- (XtPointer) dialog);\r
- \r
- XtRealizeWidget(promotionShell);\r
- CatchDeleteWindow(promotionShell, "PromotionPopDown");\r
- \r
- j = 0;\r
- XtSetArg(args[j], XtNwidth, &pw_width); j++;\r
- XtGetValues(promotionShell, args, j);\r
- \r
- XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,\r
- lineGap + squareSize/3 +\r
- ((toY == BOARD_HEIGHT-1) ^ (flipView) ?\r
- 0 : 6*(squareSize + lineGap)), &x, &y);\r
- \r
- j = 0;\r
- XtSetArg(args[j], XtNx, x); j++;\r
- XtSetArg(args[j], XtNy, y); j++;\r
- XtSetValues(promotionShell, args, j);\r
- \r
- XtPopup(promotionShell, XtGrabNone);\r
- \r
- promotionUp = True;\r
-}\r
-\r
-void PromotionPopDown()\r
-{\r
- if (!promotionUp) return;\r
- XtPopdown(promotionShell);\r
- XtDestroyWidget(promotionShell);\r
- promotionUp = False;\r
-}\r
-\r
-void PromotionCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- String name;\r
- Arg args[16];\r
- int promoChar;\r
- \r
- XtSetArg(args[0], XtNlabel, &name);\r
- XtGetValues(w, args, 1);\r
- \r
- PromotionPopDown();\r
- \r
- if (fromX == -1) return;\r
- \r
- if (strcmp(name, "cancel") == 0) {\r
- fromX = fromY = -1;\r
- ClearHighlights();\r
- return;\r
- } else if (strcmp(name, "Knight") == 0) {\r
- promoChar = 'n';\r
- } else {\r
- promoChar = ToLower(name[0]);\r
- }\r
-\r
- UserMoveEvent(fromX, fromY, toX, toY, promoChar);\r
-\r
- if (!appData.highlightLastMove || gotPremove) ClearHighlights();\r
- if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);\r
- fromX = fromY = -1;\r
-}\r
-\r
-\r
-void ErrorCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- errorUp = False;\r
- XtPopdown(w = XtParent(XtParent(XtParent(w))));\r
- XtDestroyWidget(w);\r
- if (errorExitStatus != -1) ExitEvent(errorExitStatus);\r
-}\r
-\r
-\r
-void ErrorPopDown()\r
-{\r
- if (!errorUp) return;\r
- errorUp = False;\r
- XtPopdown(errorShell);\r
- XtDestroyWidget(errorShell);\r
- if (errorExitStatus != -1) ExitEvent(errorExitStatus);\r
-}\r
-\r
-void ErrorPopUp(title, label, modal)\r
- char *title, *label;\r
- int modal;\r
-{\r
- Arg args[16];\r
- Widget dialog, layout;\r
- Position x, y;\r
- int xx, yy;\r
- Window junk;\r
- Dimension bw_width, pw_width;\r
- Dimension pw_height;\r
- int i;\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNresizable, True); i++;\r
- XtSetArg(args[i], XtNtitle, title); i++;\r
- errorShell = \r
- XtCreatePopupShell("errorpopup", transientShellWidgetClass,\r
- shellWidget, args, i);\r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,\r
- layoutArgs, XtNumber(layoutArgs));\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNlabel, label); i++;\r
- XtSetArg(args[i], XtNborderWidth, 0); i++;\r
- dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,\r
- layout, args, i);\r
- \r
- XawDialogAddButton(dialog, "ok", ErrorCallback, (XtPointer) dialog);\r
- \r
- XtRealizeWidget(errorShell);\r
- CatchDeleteWindow(errorShell, "ErrorPopDown");\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNwidth, &bw_width); i++;\r
- XtGetValues(boardWidget, args, i);\r
- i = 0;\r
- XtSetArg(args[i], XtNwidth, &pw_width); i++;\r
- XtSetArg(args[i], XtNheight, &pw_height); i++;\r
- XtGetValues(errorShell, args, i);\r
-\r
-#ifdef NOTDEF\r
- /* This code seems to tickle an X bug if it is executed too soon\r
- after xboard starts up. The coordinates get transformed as if\r
- the main window was positioned at (0, 0).\r
- */\r
- XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,\r
- 0 - pw_height + squareSize / 3, &x, &y);\r
-#else\r
- XTranslateCoordinates(xDisplay, XtWindow(boardWidget),\r
- RootWindowOfScreen(XtScreen(boardWidget)),\r
- (bw_width - pw_width) / 2,\r
- 0 - pw_height + squareSize / 3, &xx, &yy, &junk);\r
- x = xx;\r
- y = yy;\r
-#endif\r
- if (y < 0) y = 0; /*avoid positioning top offscreen*/\r
-\r
- i = 0;\r
- XtSetArg(args[i], XtNx, x); i++;\r
- XtSetArg(args[i], XtNy, y); i++;\r
- XtSetValues(errorShell, args, i);\r
-\r
- errorUp = True;\r
- XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);\r
-}\r
-\r
-/* Disable all user input other than deleting the window */\r
-static int frozen = 0;\r
-void FreezeUI()\r
-{\r
- if (frozen) return;\r
- /* Grab by a widget that doesn't accept input */\r
- XtAddGrab(messageWidget, TRUE, FALSE);\r
- frozen = 1;\r
-}\r
-\r
-/* Undo a FreezeUI */\r
-void ThawUI()\r
-{\r
- if (!frozen) return;\r
- XtRemoveGrab(messageWidget);\r
- frozen = 0;\r
-}\r
-\r
-char *ModeToWidgetName(mode)\r
- GameMode mode;\r
-{\r
- switch (mode) {\r
- case BeginningOfGame:\r
- if (appData.icsActive)\r
- return "menuMode.ICS Client";\r
- else if (appData.noChessProgram ||\r
- *appData.cmailGameName != NULLCHAR)\r
- return "menuMode.Edit Game";\r
- else\r
- return "menuMode.Machine Black";\r
- case MachinePlaysBlack:\r
- return "menuMode.Machine Black";\r
- case MachinePlaysWhite:\r
- return "menuMode.Machine White";\r
- case AnalyzeMode:\r
- return "menuMode.Analysis Mode";\r
- case AnalyzeFile:\r
- return "menuMode.Analyze File";\r
- case TwoMachinesPlay:\r
- return "menuMode.Two Machines";\r
- case EditGame:\r
- return "menuMode.Edit Game";\r
- case PlayFromGameFile:\r
- return "menuFile.Load Game";\r
- case EditPosition:\r
- return "menuMode.Edit Position";\r
- case Training:\r
- return "menuMode.Training";\r
- case IcsPlayingWhite:\r
- case IcsPlayingBlack:\r
- case IcsObserving:\r
- case IcsIdle:\r
- case IcsExamining:\r
- return "menuMode.ICS Client";\r
- default:\r
- case EndOfGame:\r
- return NULL;\r
- }\r
-} \r
-\r
-void ModeHighlight()\r
-{\r
- Arg args[16];\r
- static int oldPausing = FALSE;\r
- static GameMode oldmode = (GameMode) -1;\r
- char *wname;\r
- \r
- if (!boardWidget || !XtIsRealized(boardWidget)) return;\r
-\r
- if (pausing != oldPausing) {\r
- oldPausing = pausing;\r
- if (pausing) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Pause"),\r
- args, 1);\r
-\r
- if (appData.showButtonBar) {\r
-#if 0\r
- if (pausing) {\r
- XtSetArg(args[0], XtNbackground, buttonForegroundPixel);\r
- XtSetArg(args[1], XtNforeground, buttonBackgroundPixel);\r
- } else {\r
- XtSetArg(args[0], XtNbackground, buttonBackgroundPixel);\r
- XtSetArg(args[1], XtNforeground, buttonForegroundPixel);\r
- }\r
-#else\r
- /* Always toggle, don't set. Previous code messes up when\r
- invoked while the button is pressed, as releasing it\r
- toggles the state again. */\r
- {\r
- Pixel oldbg, oldfg;\r
- XtSetArg(args[0], XtNbackground, &oldbg);\r
- XtSetArg(args[1], XtNforeground, &oldfg);\r
- XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),\r
- args, 2);\r
- XtSetArg(args[0], XtNbackground, oldfg);\r
- XtSetArg(args[1], XtNforeground, oldbg);\r
- }\r
-#endif\r
- XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);\r
- }\r
- }\r
-\r
- wname = ModeToWidgetName(oldmode);\r
- if (wname != NULL) {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);\r
- }\r
- wname = ModeToWidgetName(gameMode);\r
- if (wname != NULL) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);\r
- }\r
- oldmode = gameMode;\r
-\r
- /* Maybe all the enables should be handled here, not just this one */\r
- XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Training"),\r
- gameMode == Training || gameMode == PlayFromGameFile);\r
-}\r
-\r
-\r
-/*\r
- * Button/menu procedures\r
- */\r
-void ResetProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ResetGameEvent();\r
- AnalysisPopDown();\r
-}\r
-\r
-int LoadGamePopUp(f, gameNumber, title)\r
- FILE *f;\r
- int gameNumber;\r
- char *title;\r
-{\r
- cmailMsgLoaded = FALSE;\r
- if (gameNumber == 0) {\r
- int error = GameListBuild(f);\r
- if (error) {\r
- DisplayError("Cannot build game list", error);\r
- } else if (!ListEmpty(&gameList) &&\r
- ((ListGame *) gameList.tailPred)->number > 1) {\r
- GameListPopUp(f, title);\r
- return TRUE;\r
- }\r
- GameListDestroy();\r
- gameNumber = 1;\r
- }\r
- return LoadGame(f, gameNumber, title, FALSE);\r
-}\r
-\r
-void LoadGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {\r
- Reset(FALSE, TRUE);\r
- }\r
- FileNamePopUp("Load game file name?", "", LoadGamePopUp, "rb");\r
-}\r
-\r
-void LoadNextGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadGame(1);\r
-}\r
-\r
-void LoadPrevGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadGame(-1);\r
-}\r
-\r
-void ReloadGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadGame(0);\r
-}\r
-\r
-void LoadNextPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadPosition(1);\r
-}\r
-\r
-void LoadPrevPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadPosition(-1);\r
-}\r
-\r
-void ReloadPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadPosition(0);\r
-}\r
-\r
-void LoadPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {\r
- Reset(FALSE, TRUE);\r
- }\r
- FileNamePopUp("Load position file name?", "", LoadPosition, "rb");\r
-}\r
-\r
-void SaveGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- FileNamePopUp("Save game file name?",\r
- DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),\r
- SaveGame, "a");\r
-}\r
-\r
-void SavePositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- FileNamePopUp("Save position file name?",\r
- DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),\r
- SavePosition, "a");\r
-}\r
-\r
-void ReloadCmailMsgProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ReloadCmailMsgEvent(FALSE);\r
-}\r
-\r
-void MailMoveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- MailMoveEvent();\r
-}\r
-\r
-/* this variable is shared between CopyPositionProc and SendPositionSelection */\r
-static char *selected_fen_position=NULL;\r
-\r
-static Boolean\r
-SendPositionSelection(Widget w, Atom *selection, Atom *target,\r
- Atom *type_return, XtPointer *value_return,\r
- unsigned long *length_return, int *format_return)\r
-{\r
- char *selection_tmp;\r
-\r
- if (!selected_fen_position) return False; /* should never happen */\r
- if (*target == XA_STRING){\r
- /* note: since no XtSelectionDoneProc was registered, Xt will\r
- * automatically call XtFree on the value returned. So have to\r
- * make a copy of it allocated with XtMalloc */\r
- selection_tmp= XtMalloc(strlen(selected_fen_position)+16);\r
- strcpy(selection_tmp, selected_fen_position);\r
-\r
- *value_return=selection_tmp;\r
- *length_return=strlen(selection_tmp);\r
- *type_return=XA_STRING;\r
- *format_return = 8; /* bits per byte */\r
- return True;\r
- } else {\r
- return False;\r
- } \r
-}\r
-\r
-/* note: when called from menu all parameters are NULL, so no clue what the\r
- * Widget which was clicked on was, or what the click event was\r
- */\r
-void CopyPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
- {\r
- int ret;\r
-\r
- if (selected_fen_position) free(selected_fen_position);\r
- selected_fen_position = (char *)PositionToFEN(currentMove,1);\r
- if (!selected_fen_position) return;\r
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,\r
- CurrentTime,\r
- SendPositionSelection,\r
- NULL/* lose_ownership_proc */ ,\r
- NULL/* transfer_done_proc */);\r
- if (!ret) {\r
- free(selected_fen_position);\r
- selected_fen_position=NULL;\r
- }\r
- }\r
-\r
-/* function called when the data to Paste is ready */\r
-static void\r
-PastePositionCB(Widget w, XtPointer client_data, Atom *selection,\r
- Atom *type, XtPointer value, unsigned long *len, int *format)\r
-{\r
- char *fenstr=value;\r
- if (value==NULL || *len==0) return; /* nothing had been selected to copy */\r
- fenstr[*len]='\0'; /* normally this string is terminated, but be safe */\r
- EditPositionPasteFEN(fenstr);\r
- XtFree(value);\r
-}\r
-\r
-/* called when Paste Position button is pressed,\r
- * all parameters will be NULL */\r
-void PastePositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,\r
- /* (XtSelectionCallbackProc) */ PastePositionCB,\r
- NULL, /* client_data passed to PastePositionCB */\r
-\r
- /* better to use the time field from the event that triggered the\r
- * call to this function, but that isn't trivial to get\r
- */\r
- CurrentTime\r
- );\r
- return;\r
-}\r
-\r
-static Boolean\r
-SendGameSelection(Widget w, Atom *selection, Atom *target,\r
- Atom *type_return, XtPointer *value_return,\r
- unsigned long *length_return, int *format_return)\r
-{\r
- char *selection_tmp;\r
-\r
- if (*target == XA_STRING){\r
- FILE* f = fopen(gameCopyFilename, "r");\r
- long len;\r
- size_t count;\r
- if (f == NULL) return False;\r
- fseek(f, 0, 2);\r
- len = ftell(f);\r
- rewind(f);\r
- selection_tmp = XtMalloc(len + 1);\r
- count = fread(selection_tmp, 1, len, f);\r
- if (len != count) {\r
- XtFree(selection_tmp);\r
- return False;\r
- }\r
- selection_tmp[len] = NULLCHAR;\r
- *value_return = selection_tmp;\r
- *length_return = len;\r
- *type_return = XA_STRING;\r
- *format_return = 8; /* bits per byte */\r
- return True;\r
- } else {\r
- return False;\r
- } \r
-}\r
-\r
-/* note: when called from menu all parameters are NULL, so no clue what the\r
- * Widget which was clicked on was, or what the click event was\r
- */\r
-void CopyGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- int ret;\r
-\r
- ret = SaveGameToFile(gameCopyFilename, FALSE);\r
- if (!ret) return;\r
-\r
- ret = XtOwnSelection(menuBarWidget, XA_PRIMARY,\r
- CurrentTime,\r
- SendGameSelection,\r
- NULL/* lose_ownership_proc */ ,\r
- NULL/* transfer_done_proc */);\r
-}\r
-\r
-/* function called when the data to Paste is ready */\r
-static void\r
-PasteGameCB(Widget w, XtPointer client_data, Atom *selection,\r
- Atom *type, XtPointer value, unsigned long *len, int *format)\r
-{\r
- FILE* f;\r
- if (value == NULL || *len == 0) {\r
- return; /* nothing had been selected to copy */\r
- }\r
- f = fopen(gamePasteFilename, "w");\r
- if (f == NULL) {\r
- DisplayError("Can't open temp file", errno);\r
- return;\r
- }\r
- fwrite(value, 1, *len, f);\r
- fclose(f);\r
- XtFree(value);\r
- LoadGameFromFile(gamePasteFilename, 0, gamePasteFilename, TRUE);\r
-}\r
-\r
-/* called when Paste Game button is pressed,\r
- * all parameters will be NULL */\r
-void PasteGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- XtGetSelectionValue(menuBarWidget, XA_PRIMARY, XA_STRING,\r
- /* (XtSelectionCallbackProc) */ PasteGameCB,\r
- NULL, /* client_data passed to PasteGameCB */\r
-\r
- /* better to use the time field from the event that triggered the\r
- * call to this function, but that isn't trivial to get\r
- */\r
- CurrentTime\r
- );\r
- return;\r
-}\r
-\r
-\r
-void AutoSaveGame()\r
-{\r
- SaveGameProc(NULL, NULL, NULL, NULL);\r
-}\r
-\r
-\r
-void QuitProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ExitEvent(0);\r
-}\r
-\r
-void PauseProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- PauseEvent();\r
-}\r
-\r
-\r
-void MachineBlackProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- MachineBlackEvent();\r
-}\r
-\r
-void MachineWhiteProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- MachineWhiteEvent();\r
-}\r
-\r
-void AnalyzeModeProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (!first.analysisSupport) {\r
- char buf[MSG_SIZ];\r
- sprintf(buf, "%s does not support analysis", first.tidy);\r
- DisplayError(buf, 0);\r
- return;\r
- }\r
- if (!appData.showThinking)\r
- ShowThinkingProc(w,event,prms,nprms);\r
-\r
- AnalyzeModeEvent();\r
-}\r
-\r
-void AnalyzeFileProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (!first.analysisSupport) {\r
- char buf[MSG_SIZ];\r
- sprintf(buf, "%s does not support analysis", first.tidy);\r
- DisplayError(buf, 0);\r
- return;\r
- }\r
- Reset(FALSE, TRUE);\r
-\r
- if (!appData.showThinking)\r
- ShowThinkingProc(w,event,prms,nprms);\r
-\r
- AnalyzeFileEvent();\r
- FileNamePopUp("File to analyze", "", LoadGamePopUp, "rb");\r
- AnalysisPeriodicEvent(1);\r
-}\r
-\r
-void TwoMachinesProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- TwoMachinesEvent();\r
-}\r
-\r
-void IcsClientProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- IcsClientEvent();\r
-}\r
-\r
-void EditGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- EditGameEvent();\r
-}\r
-\r
-void EditPositionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- EditPositionEvent();\r
-}\r
-\r
-void TrainingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- TrainingEvent();\r
-}\r
-\r
-void EditCommentProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (editUp) {\r
- EditCommentPopDown();\r
- } else {\r
- EditCommentEvent();\r
- }\r
-}\r
-\r
-void IcsInputBoxProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (ICSInputBoxUp) {\r
- ICSInputBoxPopDown();\r
- } else {\r
- ICSInputBoxPopUp();\r
- }\r
-}\r
-\r
-void AcceptProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- AcceptEvent();\r
-}\r
-\r
-void DeclineProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- DeclineEvent();\r
-}\r
-\r
-void RematchProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- RematchEvent();\r
-}\r
-\r
-void CallFlagProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- CallFlagEvent();\r
-}\r
-\r
-void DrawProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- DrawEvent();\r
-}\r
-\r
-void AbortProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- AbortEvent();\r
-}\r
-\r
-void AdjournProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- AdjournEvent();\r
-}\r
-\r
-void ResignProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ResignEvent();\r
-}\r
-\r
-void EnterKeyProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (ICSInputBoxUp == True)\r
- ICSInputSendText();\r
-}\r
-\r
-void StopObservingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- StopObservingEvent();\r
-}\r
-\r
-void StopExaminingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- StopExaminingEvent();\r
-}\r
-\r
-\r
-void ForwardProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ForwardEvent();\r
-}\r
-\r
-\r
-void BackwardProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- BackwardEvent();\r
-}\r
-\r
-void ToStartProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ToStartEvent();\r
-}\r
-\r
-void ToEndProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- ToEndEvent();\r
-}\r
-\r
-void RevertProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- RevertEvent();\r
-}\r
-\r
-void TruncateGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- TruncateGameEvent();\r
-}\r
-void RetractMoveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- RetractMoveEvent();\r
-}\r
-\r
-void MoveNowProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- MoveNowEvent();\r
-}\r
-\r
-\r
-void AlwaysQueenProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;\r
-\r
- if (appData.alwaysPromoteToQueen) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),\r
- args, 1);\r
-}\r
-\r
-void AnimateDraggingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.animateDragging = !appData.animateDragging;\r
-\r
- if (appData.animateDragging) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- CreateAnimVars();\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Dragging"),\r
- args, 1);\r
-}\r
-\r
-void AnimateMovingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.animate = !appData.animate;\r
-\r
- if (appData.animate) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- CreateAnimVars();\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),\r
- args, 1);\r
-}\r
-\r
-void AutocommProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoComment = !appData.autoComment;\r
-\r
- if (appData.autoComment) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),\r
- args, 1);\r
-}\r
-\r
-\r
-void AutoflagProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoCallFlag = !appData.autoCallFlag;\r
-\r
- if (appData.autoCallFlag) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),\r
- args, 1);\r
-}\r
-\r
-void AutoflipProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoFlipView = !appData.autoFlipView;\r
-\r
- if (appData.autoFlipView) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),\r
- args, 1);\r
-}\r
-\r
-void AutobsProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoObserve = !appData.autoObserve;\r
-\r
- if (appData.autoObserve) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),\r
- args, 1);\r
-}\r
-\r
-void AutoraiseProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoRaiseBoard = !appData.autoRaiseBoard;\r
-\r
- if (appData.autoRaiseBoard) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Raise Board"),\r
- args, 1);\r
-}\r
-\r
-void AutosaveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.autoSaveGames = !appData.autoSaveGames;\r
-\r
- if (appData.autoSaveGames) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),\r
- args, 1);\r
-}\r
-\r
-void BlindfoldProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.blindfold = !appData.blindfold;\r
-\r
- if (appData.blindfold) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Blindfold"),\r
- args, 1);\r
-\r
- DrawPosition(True, NULL);\r
-}\r
-\r
-void TestLegalityProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.testLegality = !appData.testLegality;\r
-\r
- if (appData.testLegality) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Test Legality"),\r
- args, 1);\r
-}\r
-\r
-\r
-void FlashMovesProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- if (appData.flashCount == 0) {\r
- appData.flashCount = 3;\r
- } else {\r
- appData.flashCount = -appData.flashCount;\r
- }\r
-\r
- if (appData.flashCount > 0) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flash Moves"),\r
- args, 1);\r
-}\r
-\r
-void FlipViewProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- flipView = !flipView;\r
- DrawPosition(True, NULL);\r
-}\r
-\r
-void GetMoveListProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.getMoveList = !appData.getMoveList;\r
-\r
- if (appData.getMoveList) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- GetMoveListEvent();\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),\r
- args, 1);\r
-}\r
-\r
-#if HIGHDRAG\r
-void HighlightDraggingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.highlightDragging = !appData.highlightDragging;\r
-\r
- if (appData.highlightDragging) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Highlight Dragging"), args, 1);\r
-}\r
-#endif\r
-\r
-void HighlightLastMoveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.highlightLastMove = !appData.highlightLastMove;\r
-\r
- if (appData.highlightLastMove) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Highlight Last Move"), args, 1);\r
-}\r
-\r
-void IcsAlarmProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.icsAlarm = !appData.icsAlarm;\r
-\r
- if (appData.icsAlarm) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.ICS Alarm"), args, 1);\r
-}\r
-\r
-void MoveSoundProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.ringBellAfterMoves = !appData.ringBellAfterMoves;\r
-\r
- if (appData.ringBellAfterMoves) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),\r
- args, 1);\r
-}\r
-\r
-\r
-void OldSaveStyleProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.oldSaveStyle = !appData.oldSaveStyle;\r
-\r
- if (appData.oldSaveStyle) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Old Save Style"),\r
- args, 1);\r
-}\r
-\r
-void PeriodicUpdatesProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- PeriodicUpdatesEvent(!appData.periodicUpdates);\r
- \r
- if (appData.periodicUpdates) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Periodic Updates"),\r
- args, 1);\r
-}\r
-\r
-void PonderNextMoveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- PonderNextMoveEvent(!appData.ponderNextMove);\r
-\r
- if (appData.ponderNextMove) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Ponder Next Move"),\r
- args, 1);\r
-}\r
-\r
-void PopupExitMessageProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.popupExitMessage = !appData.popupExitMessage;\r
-\r
- if (appData.popupExitMessage) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Popup Exit Message"), args, 1);\r
-}\r
-\r
-void PopupMoveErrorsProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.popupMoveErrors = !appData.popupMoveErrors;\r
-\r
- if (appData.popupMoveErrors) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Popup Move Errors"),\r
- args, 1);\r
-}\r
-\r
-void PremoveProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.premove = !appData.premove;\r
-\r
- if (appData.premove) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget,\r
- "menuOptions.Premove"), args, 1);\r
-}\r
-\r
-void QuietPlayProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.quietPlay = !appData.quietPlay;\r
-\r
- if (appData.quietPlay) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Quiet Play"),\r
- args, 1);\r
-}\r
-\r
-void ShowCoordsProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- appData.showCoords = !appData.showCoords;\r
-\r
- if (appData.showCoords) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),\r
- args, 1);\r
-\r
- DrawPosition(True, NULL);\r
-}\r
-\r
-void ShowThinkingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
-\r
- ShowThinkingEvent(!appData.showThinking);\r
-\r
- if (appData.showThinking) {\r
- XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);\r
- } else {\r
- XtSetArg(args[0], XtNleftBitmap, None);\r
- }\r
- XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),\r
- args, 1);\r
-}\r
-\r
-void InfoProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- char buf[MSG_SIZ];\r
- sprintf(buf, "xterm -e info --directory %s --directory . -f %s &",\r
- INFODIR, INFOFILE);\r
- system(buf);\r
-}\r
-\r
-void ManProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- char buf[MSG_SIZ];\r
- String name;\r
- if (nprms && *nprms > 0)\r
- name = prms[0];\r
- else\r
- name = "xboard";\r
- sprintf(buf, "xterm -e man %s &", name);\r
- system(buf);\r
-}\r
-\r
-void HintProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- HintEvent();\r
-}\r
-\r
-void BookProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- BookEvent();\r
-}\r
-\r
-void AboutProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- char buf[MSG_SIZ];\r
-#if ZIPPY\r
- char *zippy = " (with Zippy code)";\r
-#else\r
- char *zippy = "";\r
-#endif\r
- sprintf(buf, "%s%s\n\n%s\n%s\n\n%s%s\n%s",\r
- programVersion, zippy,\r
- "Copyright 1991 Digital Equipment Corporation",\r
- "Enhancements Copyright 1992-2001 Free Software Foundation",\r
- PRODUCT, " is free software and carries NO WARRANTY;",\r
- "see the file COPYING for more information.");\r
- ErrorPopUp("About XBoard", buf, FALSE);\r
-}\r
-\r
-void DebugProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- appData.debugMode = !appData.debugMode;\r
-}\r
-\r
-void AboutGameProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- AboutGameEvent();\r
-}\r
-\r
-void NothingProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- return;\r
-}\r
-\r
-void Iconify(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- Arg args[16];\r
- \r
- fromX = fromY = -1;\r
- XtSetArg(args[0], XtNiconic, True);\r
- XtSetValues(shellWidget, args, 1);\r
-}\r
-\r
-void DisplayMessage(message, extMessage)\r
- char *message, *extMessage;\r
-{\r
- char buf[MSG_SIZ];\r
- Arg arg;\r
- \r
- if (extMessage) {\r
- if (*message) {\r
- sprintf(buf, "%s %s", message, extMessage);\r
- message = buf;\r
- } else {\r
- message = extMessage;\r
- }\r
- }\r
- XtSetArg(arg, XtNlabel, message);\r
- XtSetValues(messageWidget, &arg, 1);\r
-}\r
-\r
-void DisplayTitle(text)\r
- char *text;\r
-{\r
- Arg args[16];\r
- int i;\r
- char title[MSG_SIZ];\r
- char icon[MSG_SIZ];\r
-\r
- if (text == NULL) text = "";\r
-\r
- if (appData.titleInWindow) {\r
- i = 0;\r
- XtSetArg(args[i], XtNlabel, text); i++;\r
- XtSetValues(titleWidget, args, i);\r
- }\r
-\r
- if (*text != NULLCHAR) {\r
- strcpy(icon, text);\r
- strcpy(title, text);\r
- } else if (appData.icsActive) {\r
- sprintf(icon, "%s", appData.icsHost);\r
- sprintf(title, "%s: %s", programName, appData.icsHost);\r
- } else if (appData.cmailGameName[0] != NULLCHAR) {\r
- sprintf(icon, "%s", "CMail");\r
- sprintf(title, "%s: %s", programName, "CMail");\r
- } else if (appData.noChessProgram) {\r
- strcpy(icon, programName);\r
- strcpy(title, programName);\r
- } else {\r
- strcpy(icon, first.tidy);\r
- sprintf(title, "%s: %s", programName, first.tidy);\r
- }\r
- i = 0;\r
- XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;\r
- XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;\r
- XtSetValues(shellWidget, args, i);\r
-}\r
-\r
-\r
-void DisplayError(message, error)\r
- String message;\r
- int error;\r
-{\r
- char buf[MSG_SIZ];\r
-\r
- if (error == 0) {\r
- if (appData.debugMode || appData.matchMode) {\r
- fprintf(stderr, "%s: %s\n", programName, message);\r
- }\r
- } else {\r
- if (appData.debugMode || appData.matchMode) {\r
- fprintf(stderr, "%s: %s: %s\n",\r
- programName, message, strerror(error));\r
- }\r
- sprintf(buf, "%s: %s", message, strerror(error));\r
- message = buf;\r
- } \r
- ErrorPopUp("Error", message, FALSE);\r
-}\r
-\r
-\r
-void DisplayMoveError(message)\r
- String message;\r
-{\r
- fromX = fromY = -1;\r
- ClearHighlights();\r
- DrawPosition(FALSE, NULL);\r
- if (appData.debugMode || appData.matchMode) {\r
- fprintf(stderr, "%s: %s\n", programName, message);\r
- }\r
- if (appData.popupMoveErrors) {\r
- ErrorPopUp("Error", message, FALSE);\r
- } else {\r
- DisplayMessage(message, "");\r
- }\r
-}\r
-\r
-\r
-void DisplayFatalError(message, error, status)\r
- String message;\r
- int error, status;\r
-{\r
- char buf[MSG_SIZ];\r
-\r
- errorExitStatus = status;\r
- if (error == 0) {\r
- fprintf(stderr, "%s: %s\n", programName, message);\r
- } else {\r
- fprintf(stderr, "%s: %s: %s\n",\r
- programName, message, strerror(error));\r
- sprintf(buf, "%s: %s", message, strerror(error));\r
- message = buf;\r
- }\r
- if (appData.popupExitMessage && boardWidget && XtIsRealized(boardWidget)) {\r
- ErrorPopUp(status ? "Fatal Error" : "Exiting", message, TRUE);\r
- } else {\r
- ExitEvent(status);\r
- }\r
-}\r
-\r
-void DisplayInformation(message)\r
- String message;\r
-{\r
- ErrorPopDown();\r
- ErrorPopUp("Information", message, TRUE);\r
-}\r
-\r
-void DisplayNote(message)\r
- String message;\r
-{\r
- ErrorPopDown();\r
- ErrorPopUp("Note", message, FALSE);\r
-}\r
-\r
-static int\r
-NullXErrorCheck(dpy, error_event)\r
- Display *dpy;\r
- XErrorEvent *error_event;\r
-{\r
- return 0;\r
-}\r
-\r
-void DisplayIcsInteractionTitle(message)\r
- String message;\r
-{\r
- if (oldICSInteractionTitle == NULL) {\r
- /* Magic to find the old window title, adapted from vim */\r
- char *wina = getenv("WINDOWID");\r
- if (wina != NULL) {\r
- Window win = (Window) atoi(wina);\r
- Window root, parent, *children;\r
- unsigned int nchildren;\r
- int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);\r
- for (;;) {\r
- if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;\r
- if (!XQueryTree(xDisplay, win, &root, &parent,\r
- &children, &nchildren)) break;\r
- if (children) XFree((void *)children);\r
- if (parent == root || parent == 0) break;\r
- win = parent;\r
- }\r
- XSetErrorHandler(oldHandler);\r
- }\r
- if (oldICSInteractionTitle == NULL) {\r
- oldICSInteractionTitle = "xterm"; \r
- }\r
- } \r
- printf("\033]0;%s\007", message);\r
- fflush(stdout);\r
-}\r
-\r
-char pendingReplyPrefix[MSG_SIZ];\r
-ProcRef pendingReplyPR;\r
-\r
-void AskQuestionProc(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- if (*nprms != 4) {\r
- fprintf(stderr, "AskQuestionProc needed 4 parameters, got %d\n",\r
- *nprms);\r
- return;\r
- }\r
- AskQuestionEvent(prms[0], prms[1], prms[2], prms[3]);\r
-}\r
-\r
-void AskQuestionPopDown()\r
-{\r
- if (!askQuestionUp) return;\r
- XtPopdown(askQuestionShell);\r
- XtDestroyWidget(askQuestionShell);\r
- askQuestionUp = False;\r
-}\r
-\r
-void AskQuestionReplyAction(w, event, prms, nprms)\r
- Widget w;\r
- XEvent *event;\r
- String *prms;\r
- Cardinal *nprms;\r
-{\r
- char buf[MSG_SIZ];\r
- int err;\r
- String reply;\r
-\r
- reply = XawDialogGetValueString(w = XtParent(w));\r
- strcpy(buf, pendingReplyPrefix);\r
- if (*buf) strcat(buf, " ");\r
- strcat(buf, reply);\r
- strcat(buf, "\n");\r
- OutputToProcess(pendingReplyPR, buf, strlen(buf), &err);\r
- AskQuestionPopDown();\r
-\r
- if (err) DisplayFatalError("Error writing to chess program", err, 0);\r
-}\r
-\r
-void AskQuestionCallback(w, client_data, call_data)\r
- Widget w;\r
- XtPointer client_data, call_data;\r
-{\r
- String name;\r
- Arg args[16];\r
-\r
- XtSetArg(args[0], XtNlabel, &name);\r
- XtGetValues(w, args, 1);\r
- \r
- if (strcmp(name, "cancel") == 0) {\r
- AskQuestionPopDown();\r
- } else {\r
- AskQuestionReplyAction(w, NULL, NULL, NULL);\r
- }\r
-}\r
-\r
-void AskQuestion(title, question, replyPrefix, pr)\r
- char *title, *question, *replyPrefix;\r
- ProcRef pr;\r
-{\r
- Arg args[16];\r
- Widget popup, layout, dialog, edit;\r
- Window root, child;\r
- int x, y, i;\r
- int win_x, win_y;\r
- unsigned int mask;\r
- \r
- strcpy(pendingReplyPrefix, replyPrefix);\r
- pendingReplyPR = pr;\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNresizable, True); i++;\r
- XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;\r
- askQuestionShell = popup =\r
- XtCreatePopupShell(title, transientShellWidgetClass,\r
- shellWidget, args, i);\r
- \r
- layout =\r
- XtCreateManagedWidget(layoutName, formWidgetClass, popup,\r
- layoutArgs, XtNumber(layoutArgs));\r
- \r
- i = 0;\r
- XtSetArg(args[i], XtNlabel, question); i++;\r
- XtSetArg(args[i], XtNvalue, ""); i++;\r
- XtSetArg(args[i], XtNborderWidth, 0); i++;\r
- dialog = XtCreateManagedWidget("question", dialogWidgetClass,\r
- layout, args, i);\r
- \r
- XawDialogAddButton(dialog, "enter", AskQuestionCallback,\r
- (XtPointer) dialog);\r
- XawDialogAddButton(dialog, "cancel", AskQuestionCallback,\r
- (XtPointer) dialog);\r
-\r
- XtRealizeWidget(popup);\r
- CatchDeleteWindow(popup, "AskQuestionPopDown");\r
- \r
- XQueryPointer(xDisplay, xBoardWindow, &root, &child,\r
- &x, &y, &win_x, &win_y, &mask);\r
- \r
- XtSetArg(args[0], XtNx, x - 10);\r
- XtSetArg(args[1], XtNy, y - 30);\r
- XtSetValues(popup, args, 2);\r
- \r
- XtPopup(popup, XtGrabExclusive);\r
- askQuestionUp = True;\r
- \r
- edit = XtNameToWidget(dialog, "*value");\r
- XtSetKeyboardFocus(popup, edit);\r
-}\r
-\r
-\r
-void\r
-PlaySound(name)\r
- char *name;\r
-{\r
- if (*name == NULLCHAR) {\r
- return;\r
- } else if (strcmp(name, "$") == 0) {\r
- putc(BELLCHAR, stderr);\r
- } else {\r
- char buf[2048];\r
- sprintf(buf, "%s '%s' &", appData.soundProgram, name);\r
- system(buf);\r
- }\r
-}\r
-\r
-void\r
-RingBell()\r
-{\r
- PlaySound(appData.soundMove);\r
-}\r
-\r
-void\r
-PlayIcsWinSound()\r
-{\r
- PlaySound(appData.soundIcsWin);\r
-}\r
-\r
-void\r
-PlayIcsLossSound()\r
-{\r
- PlaySound(appData.soundIcsLoss);\r
-}\r
-\r
-void\r
-PlayIcsDrawSound()\r
-{\r
- PlaySound(appData.soundIcsDraw);\r
-}\r
-\r
-void\r
-PlayIcsUnfinishedSound()\r
-{\r
- PlaySound(appData.soundIcsUnfinished);\r
-}\r
-\r
-void\r
-PlayAlarmSound()\r
-{\r
- PlaySound(appData.soundIcsAlarm);\r
-}\r
-\r
-void\r
-EchoOn()\r
-{\r
- system("stty echo");\r
-}\r
-\r
-void\r
-EchoOff()\r
-{\r
- system("stty -echo");\r
-}\r
-\r
-void\r
-Colorize(cc, continuation)\r
- ColorClass cc;\r
- int continuation;\r
-{\r
- char buf[MSG_SIZ];\r
- int count, outCount, error;\r
-\r
- if (textColors[(int)cc].bg > 0) {\r
- if (textColors[(int)cc].fg > 0) {\r
- sprintf(buf, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,\r
- textColors[(int)cc].fg, textColors[(int)cc].bg);\r
- } else {\r
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,\r
- textColors[(int)cc].bg);\r
- }\r
- } else {\r
- if (textColors[(int)cc].fg > 0) {\r
- sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,\r
- textColors[(int)cc].fg);\r
- } else {\r
- sprintf(buf, "\033[0;%dm", textColors[(int)cc].attr);\r
- }\r
- }\r
- count = strlen(buf);\r
- outCount = OutputToProcess(NoProc, buf, count, &error);\r
- if (outCount < count) {\r
- DisplayFatalError("Error writing to display", error, 1);\r
- }\r
-\r
- if (continuation) return;\r
- switch (cc) {\r
- case ColorShout:\r
- PlaySound(appData.soundShout);\r
- break;\r
- case ColorSShout:\r
- PlaySound(appData.soundSShout);\r
- break;\r
- case ColorChannel1:\r
- PlaySound(appData.soundChannel1);\r
- break;\r
- case ColorChannel:\r
- PlaySound(appData.soundChannel);\r
- break;\r
- case ColorKibitz:\r
- PlaySound(appData.soundKibitz);\r
- break;\r
- case ColorTell:\r
- PlaySound(appData.soundTell);\r
- break;\r
- case ColorChallenge:\r
- PlaySound(appData.soundChallenge);\r
- break;\r
- case ColorRequest:\r
- PlaySound(appData.soundRequest);\r
- break;\r
- case ColorSeek:\r
- PlaySound(appData.soundSeek);\r
- break;\r
- case ColorNormal:\r
- case ColorNone:\r
- default:\r
- break;\r
- }\r
-}\r
-\r
-char *UserName()\r
-{\r
- return getpwuid(getuid())->pw_name;\r
-}\r
-\r
-static char *ExpandPathName(path)\r
- char *path;\r
-{\r
- static char static_buf[2000];\r
- char *d, *s, buf[2000];\r
- struct passwd *pwd;\r
- \r
- s = path;\r
- d = static_buf;\r
-\r
- while (*s && isspace(*s))\r
- ++s;\r
-\r
- if (!*s) {\r
- *d = 0;\r
- return static_buf;\r
- }\r
-\r
- if (*s == '~') {\r
- if (*(s+1) == '/') {\r
- strcpy(d, getpwuid(getuid())->pw_dir);\r
- strcat(d, s+1);\r
- }\r
- else {\r
- strcpy(buf, s+1);\r
- *strchr(buf, '/') = 0;\r
- pwd = getpwnam(buf);\r
- if (!pwd)\r
- {\r
- fprintf(stderr, "ERROR: Unknown user %s (in path %s)\n",\r
- buf, path);\r
- return NULL;\r
- }\r
- strcpy(d, pwd->pw_dir);\r
- strcat(d, strchr(s+1, '/'));\r
- }\r
- }\r
- else\r
- strcpy(d, s);\r
-\r
- return static_buf;\r
-} \r
-\r
-char *HostName()\r
-{\r
- static char host_name[MSG_SIZ];\r
- \r
-#if HAVE_GETHOSTNAME\r
- gethostname(host_name, MSG_SIZ);\r
- return host_name;\r
-#else /* not HAVE_GETHOSTNAME */\r
-# if HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H\r
- sysinfo(SI_HOSTNAME, host_name, MSG_SIZ);\r
- return host_name;\r
-# else /* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */\r
- return "localhost";\r
-# endif/* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */\r
-#endif /* not HAVE_GETHOSTNAME */\r
-}\r
-\r
-XtIntervalId delayedEventTimerXID = 0;\r
-DelayedEventCallback delayedEventCallback = 0;\r
-\r
-void\r
-FireDelayedEvent()\r
-{\r
- delayedEventTimerXID = 0;\r
- delayedEventCallback();\r
-}\r
-\r
-void\r
-ScheduleDelayedEvent(cb, millisec)\r
- DelayedEventCallback cb; long millisec;\r
-{\r
- delayedEventCallback = cb;\r
- delayedEventTimerXID =\r
- XtAppAddTimeOut(appContext, millisec,\r
- (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);\r
-}\r
-\r
-DelayedEventCallback\r
-GetDelayedEvent()\r
-{\r
- if (delayedEventTimerXID) {\r
- return delayedEventCallback;\r
- } else {\r
- return NULL;\r
- }\r
-}\r
-\r
-void\r
-CancelDelayedEvent()\r
-{\r
- if (delayedEventTimerXID) {\r
- XtRemoveTimeOut(delayedEventTimerXID);\r
- delayedEventTimerXID = 0;\r
- }\r
-}\r
-\r
-XtIntervalId loadGameTimerXID = 0;\r
-\r
-int LoadGameTimerRunning()\r
-{\r
- return loadGameTimerXID != 0;\r
-}\r
-\r
-int StopLoadGameTimer()\r
-{\r
- if (loadGameTimerXID != 0) {\r
- XtRemoveTimeOut(loadGameTimerXID);\r
- loadGameTimerXID = 0;\r
- return TRUE;\r
- } else {\r
- return FALSE;\r
- }\r
-}\r
-\r
-void\r
-LoadGameTimerCallback(arg, id)\r
- XtPointer arg;\r
- XtIntervalId *id;\r
-{\r
- loadGameTimerXID = 0;\r
- AutoPlayGameLoop();\r
-}\r
-\r
-void\r
-StartLoadGameTimer(millisec)\r
- long millisec;\r
-{\r
- loadGameTimerXID =\r
- XtAppAddTimeOut(appContext, millisec,\r
- (XtTimerCallbackProc) LoadGameTimerCallback,\r
- (XtPointer) 0);\r
-}\r
-\r
-XtIntervalId analysisClockXID = 0;\r
-\r
-void\r
-AnalysisClockCallback(arg, id)\r
- XtPointer arg;\r
- XtIntervalId *id;\r
-{\r
- if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {\r
- AnalysisPeriodicEvent(0);\r
- StartAnalysisClock();\r
- }\r
-}\r
-\r
-void\r
-StartAnalysisClock()\r
-{\r
- analysisClockXID =\r
- XtAppAddTimeOut(appContext, 2000,\r
- (XtTimerCallbackProc) AnalysisClockCallback,\r
- (XtPointer) 0);\r
-}\r
-\r
-XtIntervalId clockTimerXID = 0;\r
-\r
-int ClockTimerRunning()\r
-{\r
- return clockTimerXID != 0;\r
-}\r
-\r
-int StopClockTimer()\r
-{\r
- if (clockTimerXID != 0) {\r
- XtRemoveTimeOut(clockTimerXID);\r
- clockTimerXID = 0;\r
- return TRUE;\r
- } else {\r
- return FALSE;\r
- }\r
-}\r
-\r
-void\r
-ClockTimerCallback(arg, id)\r
- XtPointer arg;\r
- XtIntervalId *id;\r
-{\r
- clockTimerXID = 0;\r
- DecrementClocks();\r
-}\r
-\r
-void\r
-StartClockTimer(millisec)\r
- long millisec;\r
-{\r
- clockTimerXID =\r
- XtAppAddTimeOut(appContext, millisec,\r
- (XtTimerCallbackProc) ClockTimerCallback,\r
- (XtPointer) 0);\r
-}\r
-\r
-void\r
-DisplayTimerLabel(w, color, timer, highlight)\r
- Widget w;\r
- char *color;\r
- long timer;\r
- int highlight;\r
-{\r
- char buf[MSG_SIZ];\r
- Arg args[16];\r
- \r
- if (appData.clockMode) {\r
- sprintf(buf, "%s: %s", color, TimeString(timer));\r
- XtSetArg(args[0], XtNlabel, buf);\r
- } else {\r
- sprintf(buf, "%s ", color);\r
- XtSetArg(args[0], XtNlabel, buf);\r
- }\r
- \r
- if (highlight) {\r
- XtSetArg(args[1], XtNbackground, timerForegroundPixel);\r
- XtSetArg(args[2], XtNforeground, timerBackgroundPixel);\r
- } else {\r
- XtSetArg(args[1], XtNbackground, timerBackgroundPixel);\r
- XtSetArg(args[2], XtNforeground, timerForegroundPixel);\r
- }\r
- \r
- XtSetValues(w, args, 3);\r
-}\r
-\r
-void\r
-DisplayWhiteClock(timeRemaining, highlight)\r
- long timeRemaining;\r
- int highlight;\r
-{\r
- Arg args[16];\r
- DisplayTimerLabel(whiteTimerWidget, "White", timeRemaining, highlight);\r
- if (highlight && iconPixmap == bIconPixmap) {\r
- iconPixmap = wIconPixmap;\r
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);\r
- XtSetValues(shellWidget, args, 1);\r
- }\r
-}\r
-\r
-void\r
-DisplayBlackClock(timeRemaining, highlight)\r
- long timeRemaining;\r
- int highlight;\r
-{\r
- Arg args[16];\r
- DisplayTimerLabel(blackTimerWidget, "Black", timeRemaining, highlight);\r
- if (highlight && iconPixmap == wIconPixmap) {\r
- iconPixmap = bIconPixmap;\r
- XtSetArg(args[0], XtNiconPixmap, iconPixmap);\r
- XtSetValues(shellWidget, args, 1);\r
- }\r
-}\r
-\r
-#define CPNone 0\r
-#define CPReal 1\r
-#define CPComm 2\r
-#define CPSock 3\r
-#define CPLoop 4\r
-typedef int CPKind;\r
-\r
-typedef struct {\r
- CPKind kind;\r
- int pid;\r
- int fdTo, fdFrom; \r
-} ChildProc;\r
-\r
-\r
-int StartChildProcess(cmdLine, dir, pr)\r
- char *cmdLine; \r
- char *dir;\r
- ProcRef *pr;\r
-{\r
- char *argv[64], *p;\r
- int i, pid;\r
- int to_prog[2], from_prog[2];\r
- ChildProc *cp;\r
- char buf[MSG_SIZ];\r
- \r
- if (appData.debugMode) {\r
- fprintf(stderr, "StartChildProcess (dir=\"%s\") %s\n",dir, cmdLine);\r
- }\r
-\r
- /* We do NOT feed the cmdLine to the shell; we just\r
- parse it into blank-separated arguments in the\r
- most simple-minded way possible.\r
- */\r
- i = 0;\r
- strcpy(buf, cmdLine);\r
- p = buf;\r
- for (;;) {\r
- argv[i++] = p;\r
- p = strchr(p, ' ');\r
- if (p == NULL) break;\r
- *p++ = NULLCHAR;\r
- }\r
- argv[i] = NULL;\r
-\r
- SetUpChildIO(to_prog, from_prog);\r
-\r
- if ((pid = fork()) == 0) {\r
- /* Child process */\r
- dup2(to_prog[0], 0);\r
- dup2(from_prog[1], 1);\r
- close(to_prog[0]);\r
- close(to_prog[1]);\r
- close(from_prog[0]);\r
- close(from_prog[1]);\r
- dup2(1, fileno(stderr)); /* force stderr to the pipe */\r
-\r
- if (dir[0] != NULLCHAR && chdir(dir) != 0) {\r
- perror(dir);\r
- exit(1);\r
- }\r
-\r
- execvp(argv[0], argv);\r
- \r
- /* If we get here, exec failed */\r
- perror(argv[0]);\r
- exit(1);\r
- }\r
- \r
- /* Parent process */\r
- close(to_prog[0]);\r
- close(from_prog[1]);\r
- \r
- cp = (ChildProc *) calloc(1, sizeof(ChildProc));\r
- cp->kind = CPReal;\r
- cp->pid = pid;\r
- cp->fdFrom = from_prog[0];\r
- cp->fdTo = to_prog[1];\r
- *pr = (ProcRef) cp;\r
- return 0;\r
-}\r
-\r
-void\r
-DestroyChildProcess(pr, signal)\r
- ProcRef pr;\r
- int signal;\r
-{\r
- ChildProc *cp = (ChildProc *) pr;\r
-\r
- if (cp->kind != CPReal) return;\r
- cp->kind = CPNone;\r
- if (signal) {\r
- kill(cp->pid, SIGTERM);\r
- }\r
- /* Process is exiting either because of the kill or because of\r
- a quit command sent by the backend; either way, wait for it to die.\r
- */\r
- wait((int *) 0);\r
- close(cp->fdFrom);\r
- close(cp->fdTo);\r
-}\r
-\r
-void\r
-InterruptChildProcess(pr)\r
- ProcRef pr;\r
-{\r
- ChildProc *cp = (ChildProc *) pr;\r
-\r
- if (cp->kind != CPReal) return;\r
- (void) kill(cp->pid, SIGINT); /* stop it thinking */\r
-}\r
-\r
-int OpenTelnet(host, port, pr)\r
- char *host;\r
- char *port;\r
- ProcRef *pr;\r
-{\r
- char cmdLine[MSG_SIZ];\r
-\r
- if (port[0] == NULLCHAR) {\r
- sprintf(cmdLine, "%s %s", appData.telnetProgram, host);\r
- } else {\r
- sprintf(cmdLine, "%s %s %s", appData.telnetProgram, host, port);\r
- }\r
- return StartChildProcess(cmdLine, "", pr);\r
-}\r
-\r
-int OpenTCP(host, port, pr)\r
- char *host;\r
- char *port;\r
- ProcRef *pr;\r
-{\r
-#if OMIT_SOCKETS\r
- DisplayFatalError("Socket support is not configured in", 0, 2);\r
-#else /* !OMIT_SOCKETS */\r
- int s;\r
- struct sockaddr_in sa;\r
- struct hostent *hp;\r
- unsigned short uport;\r
- ChildProc *cp;\r
-\r
- if ((s = socket(AF_INET, SOCK_STREAM, 6)) < 0) {\r
- return errno;\r
- }\r
-\r
- memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));\r
- sa.sin_family = AF_INET;\r
- sa.sin_addr.s_addr = INADDR_ANY;\r
- uport = (unsigned short) 0;\r
- sa.sin_port = htons(uport);\r
- if (bind(s, (struct sockaddr *) &sa, sizeof(struct sockaddr_in)) < 0) {\r
- return errno;\r
- }\r
-\r
- memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));\r
- if (!(hp = gethostbyname(host))) {\r
- int b0, b1, b2, b3;\r
- if (sscanf(host, "%d.%d.%d.%d", &b0, &b1, &b2, &b3) == 4) {\r
- hp = (struct hostent *) calloc(1, sizeof(struct hostent));\r
- hp->h_addrtype = AF_INET;\r
- hp->h_length = 4;\r
- hp->h_addr_list = (char **) calloc(2, sizeof(char *));\r
- hp->h_addr_list[0] = (char *) malloc(4);\r
- hp->h_addr_list[0][0] = b0;\r
- hp->h_addr_list[0][1] = b1;\r
- hp->h_addr_list[0][2] = b2;\r
- hp->h_addr_list[0][3] = b3;\r
- } else {\r
- return ENOENT;\r
- }\r
- }\r
- sa.sin_family = hp->h_addrtype;\r
- uport = (unsigned short) atoi(port);\r
- sa.sin_port = htons(uport);\r
- memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);\r
-\r
- if (connect(s, (struct sockaddr *) &sa, \r
- sizeof(struct sockaddr_in)) < 0) {\r
- return errno;\r
- }\r
-\r
- cp = (ChildProc *) calloc(1, sizeof(ChildProc));\r
- cp->kind = CPSock;\r
- cp->pid = 0;\r
- cp->fdFrom = s;\r
- cp->fdTo = s;\r
- *pr = (ProcRef) cp;\r
-\r
-#endif /* !OMIT_SOCKETS */\r
-\r
- return 0;\r
-}\r
-\r
-int OpenCommPort(name, pr)\r
- char *name;\r
- ProcRef *pr;\r
-{\r
- int fd;\r
- ChildProc *cp;\r
-\r
- fd = open(name, 2, 0);\r
- if (fd < 0) return errno;\r
-\r
- cp = (ChildProc *) calloc(1, sizeof(ChildProc));\r
- cp->kind = CPComm;\r
- cp->pid = 0;\r
- cp->fdFrom = fd;\r
- cp->fdTo = fd;\r
- *pr = (ProcRef) cp;\r
-\r
- return 0;\r
-}\r
-\r
-int OpenLoopback(pr)\r
- ProcRef *pr;\r
-{\r
- ChildProc *cp;\r
- int to[2], from[2];\r
-\r
- SetUpChildIO(to, from);\r
-\r
- cp = (ChildProc *) calloc(1, sizeof(ChildProc));\r
- cp->kind = CPLoop;\r
- cp->pid = 0;\r
- cp->fdFrom = to[0]; /* note not from[0]; we are doing a loopback */\r
- cp->fdTo = to[1];\r
- *pr = (ProcRef) cp;\r
-\r
- return 0;\r
-}\r
-\r
-int OpenRcmd(host, user, cmd, pr)\r
- char *host, *user, *cmd;\r
- ProcRef *pr;\r
-{\r
- DisplayFatalError("internal rcmd not implemented for Unix", 0, 1);\r
- return -1;\r
-} \r
-\r
-#define INPUT_SOURCE_BUF_SIZE 8192\r
-\r
-typedef struct {\r
- CPKind kind;\r
- int fd;\r
- int lineByLine;\r
- char *unused;\r
- InputCallback func;\r
- XtInputId xid;\r
- char buf[INPUT_SOURCE_BUF_SIZE];\r
- VOIDSTAR closure;\r
-} InputSource;\r
-\r
-void\r
-DoInputCallback(closure, source, xid) \r
- caddr_t closure;\r
- int *source;\r
- XtInputId *xid;\r
-{\r
- InputSource *is = (InputSource *) closure;\r
- int count;\r
- int error;\r
- char *p, *q;\r
-\r
- if (is->lineByLine) {\r
- count = read(is->fd, is->unused,\r
- INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));\r
- if (count <= 0) {\r
- (is->func)(is, is->closure, is->buf, count, count ? errno : 0);\r
- return;\r
- }\r
- is->unused += count;\r
- p = is->buf;\r
- while (p < is->unused) {\r
- q = memchr(p, '\n', is->unused - p);\r
- if (q == NULL) break;\r
- q++;\r
- (is->func)(is, is->closure, p, q - p, 0);\r
- p = q;\r
- }\r
- q = is->buf;\r
- while (p < is->unused) {\r
- *q++ = *p++;\r
- }\r
- is->unused = q;\r
- } else {\r
- count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);\r
- if (count == -1)\r
- error = errno;\r
- else\r
- error = 0;\r
- (is->func)(is, is->closure, is->buf, count, error);\r
- } \r
-}\r
-\r
-InputSourceRef AddInputSource(pr, lineByLine, func, closure)\r
- ProcRef pr;\r
- int lineByLine;\r
- InputCallback func;\r
- VOIDSTAR closure;\r
-{\r
- InputSource *is;\r
- ChildProc *cp = (ChildProc *) pr;\r
-\r
- is = (InputSource *) calloc(1, sizeof(InputSource));\r
- is->lineByLine = lineByLine;\r
- is->func = func;\r
- if (pr == NoProc) {\r
- is->kind = CPReal;\r
- is->fd = fileno(stdin);\r
- } else {\r
- is->kind = cp->kind;\r
- is->fd = cp->fdFrom;\r
- }\r
- if (lineByLine) {\r
- is->unused = is->buf;\r
- }\r
- \r
- is->xid = XtAppAddInput(appContext, is->fd,\r
- (XtPointer) (XtInputReadMask),\r
- (XtInputCallbackProc) DoInputCallback,\r
- (XtPointer) is);\r
- is->closure = closure;\r
- return (InputSourceRef) is;\r
-}\r
-\r
-void\r
-RemoveInputSource(isr)\r
- InputSourceRef isr;\r
-{\r
- InputSource *is = (InputSource *) isr;\r
-\r
- if (is->xid == 0) return;\r
- XtRemoveInput(is->xid);\r
- is->xid = 0;\r
-}\r
-\r
-int OutputToProcess(pr, message, count, outError)\r
- ProcRef pr;\r
- char *message;\r
- int count;\r
- int *outError;\r
-{\r
- ChildProc *cp = (ChildProc *) pr;\r
- int outCount;\r
-\r
- if (pr == NoProc)\r
- outCount = fwrite(message, 1, count, stdout);\r
- else\r
- outCount = write(cp->fdTo, message, count);\r
-\r
- if (outCount == -1)\r
- *outError = errno;\r
- else\r
- *outError = 0;\r
-\r
- return outCount;\r
-}\r
-\r
-/* Output message to process, with "ms" milliseconds of delay\r
- between each character. This is needed when sending the logon\r
- script to ICC, which for some reason doesn't like the\r
- instantaneous send. */\r
-int OutputToProcessDelayed(pr, message, count, outError, msdelay)\r
- ProcRef pr;\r
- char *message;\r
- int count;\r
- int *outError;\r
- long msdelay;\r
-{\r
- ChildProc *cp = (ChildProc *) pr;\r
- int outCount = 0;\r
- int r;\r
- \r
- while (count--) {\r
- r = write(cp->fdTo, message++, 1);\r
- if (r == -1) {\r
- *outError = errno;\r
- return outCount;\r
- }\r
- ++outCount;\r
- if (msdelay >= 0)\r
- TimeDelay(msdelay);\r
- }\r
-\r
- return outCount;\r
-}\r
-\r
-/**** Animation code by Hugh Fisher, DCS, ANU.\r
-\r
- Known problem: if a window overlapping the board is\r
- moved away while a piece is being animated underneath,\r
- the newly exposed area won't be updated properly.\r
- I can live with this.\r
-\r
- Known problem: if you look carefully at the animation\r
- of pieces in mono mode, they are being drawn as solid\r
- shapes without interior detail while moving. Fixing\r
- this would be a major complication for minimal return.\r
-****/\r
-\r
-/* Masks for XPM pieces. Black and white pieces can have\r
- different shapes, but in the interest of retaining my\r
- sanity pieces must have the same outline on both light\r
- and dark squares, and all pieces must use the same\r
- background square colors/images. */\r
-\r
-static void\r
-CreateAnimMasks (pieceDepth)\r
- int pieceDepth;\r
-{\r
- ChessSquare piece;\r
- Pixmap buf;\r
- GC bufGC, maskGC;\r
- int kind, n;\r
- unsigned long plane;\r
- XGCValues values;\r
-\r
- /* Need a bitmap just to get a GC with right depth */\r
- buf = XCreatePixmap(xDisplay, xBoardWindow,\r
- 8, 8, 1);\r
- values.foreground = 1;\r
- values.background = 0;\r
- /* Don't use XtGetGC, not read only */\r
- maskGC = XCreateGC(xDisplay, buf,\r
- GCForeground | GCBackground, &values);\r
- XFreePixmap(xDisplay, buf);\r
-\r
- buf = XCreatePixmap(xDisplay, xBoardWindow,\r
- squareSize, squareSize, pieceDepth); \r
- values.foreground = XBlackPixel(xDisplay, xScreen);\r
- values.background = XWhitePixel(xDisplay, xScreen);\r
- bufGC = XCreateGC(xDisplay, buf,\r
- GCForeground | GCBackground, &values);\r
-\r
- for (piece = WhitePawn; piece <= BlackKing; piece++) {\r
- /* Begin with empty mask */\r
- xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,\r
- squareSize, squareSize, 1);\r
- XSetFunction(xDisplay, maskGC, GXclear);\r
- XFillRectangle(xDisplay, xpmMask[piece], maskGC,\r
- 0, 0, squareSize, squareSize);\r
- \r
- /* Take a copy of the piece */\r
- if (White(piece))\r
- kind = 0;\r
- else\r
- kind = 2;\r
- XSetFunction(xDisplay, bufGC, GXcopy);\r
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],\r
- buf, bufGC,\r
- 0, 0, squareSize, squareSize, 0, 0);\r
- \r
- /* XOR the background (light) over the piece */\r
- XSetFunction(xDisplay, bufGC, GXxor);\r
- if (useImageSqs)\r
- XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,\r
- 0, 0, squareSize, squareSize, 0, 0);\r
- else {\r
- XSetForeground(xDisplay, bufGC, lightSquareColor);\r
- XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);\r
- }\r
- \r
- /* We now have an inverted piece image with the background\r
- erased. Construct mask by just selecting all the non-zero\r
- pixels - no need to reconstruct the original image. */\r
- XSetFunction(xDisplay, maskGC, GXor);\r
- plane = 1;\r
- /* Might be quicker to download an XImage and create bitmap\r
- data from it rather than this N copies per piece, but it\r
- only takes a fraction of a second and there is a much\r
- longer delay for loading the pieces. */\r
- for (n = 0; n < pieceDepth; n ++) {\r
- XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,\r
- 0, 0, squareSize, squareSize,\r
- 0, 0, plane);\r
- plane = plane << 1;\r
- }\r
- }\r
- /* Clean up */\r
- XFreePixmap(xDisplay, buf);\r
- XFreeGC(xDisplay, bufGC);\r
- XFreeGC(xDisplay, maskGC);\r
-}\r
-\r
-static void\r
-InitAnimState (anim, info)\r
- AnimState * anim;\r
- XWindowAttributes * info;\r
-{\r
- XtGCMask mask;\r
- XGCValues values;\r
- \r
- /* Each buffer is square size, same depth as window */\r
- anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,\r
- squareSize, squareSize, info->depth);\r
- anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,\r
- squareSize, squareSize, info->depth);\r
-\r
- /* Create a plain GC for blitting */\r
- mask = GCForeground | GCBackground | GCFunction |\r
- GCPlaneMask | GCGraphicsExposures;\r
- values.foreground = XBlackPixel(xDisplay, xScreen);\r
- values.background = XWhitePixel(xDisplay, xScreen);\r
- values.function = GXcopy;\r
- values.plane_mask = AllPlanes;\r
- values.graphics_exposures = False;\r
- anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);\r
-\r
- /* Piece will be copied from an existing context at\r
- the start of each new animation/drag. */\r
- anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);\r
-\r
- /* Outline will be a read-only copy of an existing */\r
- anim->outlineGC = None;\r
-}\r
-\r
-static void\r
-CreateAnimVars ()\r
-{\r
- static int done = 0;\r
- XWindowAttributes info;\r
-\r
- if (done) return;\r
- done = 1;\r
- XGetWindowAttributes(xDisplay, xBoardWindow, &info);\r
- \r
- InitAnimState(&game, &info);\r
- InitAnimState(&player, &info);\r
- \r
- /* For XPM pieces, we need bitmaps to use as masks. */\r
- if (useImages)\r
- CreateAnimMasks(info.depth);\r
-}\r
-\r
-#ifndef HAVE_USLEEP\r
-\r
-static Boolean frameWaiting;\r
-\r
-static RETSIGTYPE FrameAlarm (sig)\r
- int sig;\r
-{\r
- frameWaiting = False;\r
- /* In case System-V style signals. Needed?? */\r
- signal(SIGALRM, FrameAlarm);\r
-}\r
-\r
-static void\r
-FrameDelay (time)\r
- int time;\r
-{\r
- struct itimerval delay;\r
- \r
- XSync(xDisplay, False);\r
-\r
- if (time > 0) {\r
- frameWaiting = True;\r
- signal(SIGALRM, FrameAlarm);\r
- delay.it_interval.tv_sec = \r
- delay.it_value.tv_sec = time / 1000;\r
- delay.it_interval.tv_usec = \r
- delay.it_value.tv_usec = (time % 1000) * 1000;\r
- setitimer(ITIMER_REAL, &delay, NULL);\r
-#if 0\r
- /* Ugh -- busy-wait! --tpm */\r
- while (frameWaiting); \r
-#else\r
- while (frameWaiting) pause();\r
-#endif\r
- delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;\r
- delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;\r
- setitimer(ITIMER_REAL, &delay, NULL);\r
- }\r
-}\r
-\r
-#else\r
-\r
-static void\r
-FrameDelay (time)\r
- int time;\r
-{\r
- XSync(xDisplay, False);\r
- if (time > 0)\r
- usleep(time * 1000);\r
-}\r
-\r
-#endif\r
-\r
-/* Convert board position to corner of screen rect and color */\r
-\r
-static void\r
-ScreenSquare(column, row, pt, color)\r
- int column; int row; XPoint * pt; int * color;\r
-{\r
- if (flipView) {\r
- pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);\r
- pt->y = lineGap + row * (squareSize + lineGap);\r
- } else {\r
- pt->x = lineGap + column * (squareSize + lineGap);\r
- pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);\r
- }\r
- *color = SquareColor(row, column);\r
-}\r
-\r
-/* Convert window coords to square */\r
-\r
-static void\r
-BoardSquare(x, y, column, row)\r
- int x; int y; int * column; int * row;\r
-{\r
- *column = EventToSquare(x, BOARD_WIDTH);\r
- if (flipView && *column >= 0)\r
- *column = BOARD_WIDTH - 1 - *column;\r
- *row = EventToSquare(y, BOARD_HEIGHT);\r
- if (!flipView && *row >= 0)\r
- *row = BOARD_HEIGHT - 1 - *row;\r
-}\r
-\r
-/* Utilities */\r
-\r
-#undef Max /* just in case */\r
-#undef Min\r
-#define Max(a, b) ((a) > (b) ? (a) : (b))\r
-#define Min(a, b) ((a) < (b) ? (a) : (b))\r
-\r
-static void\r
-SetRect(rect, x, y, width, height)\r
- XRectangle * rect; int x; int y; int width; int height;\r
-{\r
- rect->x = x;\r
- rect->y = y;\r
- rect->width = width;\r
- rect->height = height;\r
-}\r
-\r
-/* Test if two frames overlap. If they do, return\r
- intersection rect within old and location of\r
- that rect within new. */\r
- \r
-static Boolean\r
-Intersect(old, new, size, area, pt)\r
- XPoint * old; XPoint * new;\r
- int size; XRectangle * area; XPoint * pt;\r
-{\r
- if (old->x > new->x + size || new->x > old->x + size ||\r
- old->y > new->y + size || new->y > old->y + size) {\r
- return False;\r
- } else {\r
- SetRect(area, Max(new->x - old->x, 0), Max(new->y - old->y, 0),\r
- size - abs(old->x - new->x), size - abs(old->y - new->y));\r
- pt->x = Max(old->x - new->x, 0);\r
- pt->y = Max(old->y - new->y, 0);\r
- return True;\r
- }\r
-}\r
-\r
-/* For two overlapping frames, return the rect(s)\r
- in the old that do not intersect with the new. */\r
- \r
-static void\r
-CalcUpdateRects(old, new, size, update, nUpdates)\r
- XPoint * old; XPoint * new; int size;\r
- XRectangle update[]; int * nUpdates;\r
-{\r
- int count;\r
-\r
- /* If old = new (shouldn't happen) then nothing to draw */\r
- if (old->x == new->x && old->y == new->y) {\r
- *nUpdates = 0;\r
- return;\r
- }\r
- /* Work out what bits overlap. Since we know the rects\r
- are the same size we don't need a full intersect calc. */\r
- count = 0;\r
- /* Top or bottom edge? */\r
- if (new->y > old->y) {\r
- SetRect(&(update[count]), old->x, old->y, size, new->y - old->y);\r
- count ++;\r
- } else if (old->y > new->y) {\r
- SetRect(&(update[count]), old->x, old->y + size - (old->y - new->y),\r
- size, old->y - new->y);\r
- count ++;\r
- }\r
- /* Left or right edge - don't overlap any update calculated above. */\r
- if (new->x > old->x) {\r
- SetRect(&(update[count]), old->x, Max(new->y, old->y),\r
- new->x - old->x, size - abs(new->y - old->y));\r
- count ++;\r
- } else if (old->x > new->x) {\r
- SetRect(&(update[count]), new->x + size, Max(new->y, old->y),\r
- old->x - new->x, size - abs(new->y - old->y));\r
- count ++;\r
- }\r
- /* Done */\r
- *nUpdates = count;\r
-}\r
-\r
-/* Generate a series of frame coords from start->mid->finish.\r
- The movement rate doubles until the half way point is\r
- reached, then halves back down to the final destination,\r
- which gives a nice slow in/out effect. The algorithmn\r
- may seem to generate too many intermediates for short\r
- moves, but remember that the purpose is to attract the\r
- viewers attention to the piece about to be moved and\r
- then to where it ends up. Too few frames would be less\r
- noticeable. */\r
-\r
-static void\r
-Tween(start, mid, finish, factor, frames, nFrames)\r
- XPoint * start; XPoint * mid;\r
- XPoint * finish; int factor;\r
- XPoint frames[]; int * nFrames;\r
-{\r
- int fraction, n, count;\r
-\r
- count = 0;\r
-\r
- /* Slow in, stepping 1/16th, then 1/8th, ... */\r
- fraction = 1;\r
- for (n = 0; n < factor; n++)\r
- fraction *= 2;\r
- for (n = 0; n < factor; n++) {\r
- frames[count].x = start->x + (mid->x - start->x) / fraction;\r
- frames[count].y = start->y + (mid->y - start->y) / fraction;\r
- count ++;\r
- fraction = fraction / 2;\r
- }\r
- \r
- /* Midpoint */\r
- frames[count] = *mid;\r
- count ++;\r
- \r
- /* Slow out, stepping 1/2, then 1/4, ... */\r
- fraction = 2;\r
- for (n = 0; n < factor; n++) {\r
- frames[count].x = finish->x - (finish->x - mid->x) / fraction;\r
- frames[count].y = finish->y - (finish->y - mid->y) / fraction;\r
- count ++;\r
- fraction = fraction * 2;\r
- }\r
- *nFrames = count;\r
-}\r
-\r
-/* Draw a piece on the screen without disturbing what's there */\r
-\r
-static void\r
-SelectGCMask(piece, clip, outline, mask)\r
- ChessSquare piece; GC * clip; GC * outline; Pixmap * mask;\r
-{\r
- GC source;\r
-\r
- /* Bitmap for piece being moved. */\r
- if (appData.monoMode) {\r
- *mask = *pieceToSolid(piece);\r
- } else if (useImages) {\r
-#if HAVE_LIBXPM\r
- *mask = xpmMask[piece];\r
-#else\r
- *mask = ximMaskPm[piece%(int)BlackPawn];\r
-#endif\r
- } else {\r
- *mask = *pieceToSolid(piece);\r
- }\r
-\r
- /* GC for piece being moved. Square color doesn't matter, but\r
- since it gets modified we make a copy of the original. */\r
- if (White(piece)) {\r
- if (appData.monoMode)\r
- source = bwPieceGC;\r
- else\r
- source = wlPieceGC;\r
- } else {\r
- if (appData.monoMode)\r
- source = wbPieceGC;\r
- else\r
- source = blPieceGC;\r
- }\r
- XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);\r
- \r
- /* Outline only used in mono mode and is not modified */\r
- if (White(piece))\r
- *outline = bwPieceGC;\r
- else\r
- *outline = wbPieceGC;\r
-}\r
-\r
-static void\r
-OverlayPiece(piece, clip, outline, dest)\r
- ChessSquare piece; GC clip; GC outline; Drawable dest;\r
-{\r
- int kind;\r
- \r
- if (!useImages) {\r
- /* Draw solid rectangle which will be clipped to shape of piece */\r
- XFillRectangle(xDisplay, dest, clip,\r
- 0, 0, squareSize, squareSize);\r
- if (appData.monoMode)\r
- /* Also draw outline in contrasting color for black\r
- on black / white on white cases */\r
- XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,\r
- 0, 0, squareSize, squareSize, 0, 0, 1);\r
- } else {\r
- /* Copy the piece */\r
- if (White(piece))\r
- kind = 0;\r
- else\r
- kind = 2;\r
- XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],\r
- dest, clip,\r
- 0, 0, squareSize, squareSize,\r
- 0, 0); \r
- }\r
-}\r
-\r
-/* Animate the movement of a single piece */\r
-\r
-static void \r
-BeginAnimation(anim, piece, startColor, start)\r
- AnimState *anim;\r
- ChessSquare piece;\r
- int startColor;\r
- XPoint * start;\r
-{\r
- Pixmap mask;\r
- \r
- /* The old buffer is initialised with the start square (empty) */\r
- BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);\r
- anim->prevFrame = *start;\r
- \r
- /* The piece will be drawn using its own bitmap as a matte */\r
- SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);\r
- XSetClipMask(xDisplay, anim->pieceGC, mask);\r
-}\r
-\r
-static void\r
-AnimationFrame(anim, frame, piece)\r
- AnimState *anim;\r
- XPoint *frame;\r
- ChessSquare piece;\r
-{\r
- XRectangle updates[4];\r
- XRectangle overlap;\r
- XPoint pt;\r
- int count, i;\r
- \r
- /* Save what we are about to draw into the new buffer */\r
- XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,\r
- frame->x, frame->y, squareSize, squareSize,\r
- 0, 0);\r
- \r
- /* Erase bits of the previous frame */\r
- if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {\r
- /* Where the new frame overlapped the previous,\r
- the contents in newBuf are wrong. */\r
- XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,\r
- overlap.x, overlap.y,\r
- overlap.width, overlap.height,\r
- pt.x, pt.y);\r
- /* Repaint the areas in the old that don't overlap new */\r
- CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);\r
- for (i = 0; i < count; i++)\r
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,\r
- updates[i].x - anim->prevFrame.x,\r
- updates[i].y - anim->prevFrame.y,\r
- updates[i].width, updates[i].height,\r
- updates[i].x, updates[i].y);\r
- } else {\r
- /* Easy when no overlap */\r
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,\r
- 0, 0, squareSize, squareSize,\r
- anim->prevFrame.x, anim->prevFrame.y);\r
- }\r
-\r
- /* Save this frame for next time round */\r
- XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,\r
- 0, 0, squareSize, squareSize,\r
- 0, 0);\r
- anim->prevFrame = *frame;\r
- \r
- /* Draw piece over original screen contents, not current,\r
- and copy entire rect. Wipes out overlapping piece images. */\r
- OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);\r
- XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,\r
- 0, 0, squareSize, squareSize,\r
- frame->x, frame->y);\r
-}\r
-\r
-static void\r
-EndAnimation (anim, finish)\r
- AnimState *anim;\r
- XPoint *finish;\r
-{\r
- XRectangle updates[4];\r
- XRectangle overlap;\r
- XPoint pt;\r
- int count, i;\r
-\r
- /* The main code will redraw the final square, so we\r
- only need to erase the bits that don't overlap. */\r
- if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {\r
- CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);\r
- for (i = 0; i < count; i++)\r
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,\r
- updates[i].x - anim->prevFrame.x,\r
- updates[i].y - anim->prevFrame.y,\r
- updates[i].width, updates[i].height,\r
- updates[i].x, updates[i].y);\r
- } else {\r
- XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,\r
- 0, 0, squareSize, squareSize,\r
- anim->prevFrame.x, anim->prevFrame.y);\r
- }\r
-}\r
-\r
-static void\r
-FrameSequence(anim, piece, startColor, start, finish, frames, nFrames)\r
- AnimState *anim;\r
- ChessSquare piece; int startColor;\r
- XPoint * start; XPoint * finish;\r
- XPoint frames[]; int nFrames;\r
-{\r
- int n;\r
-\r
- BeginAnimation(anim, piece, startColor, start);\r
- for (n = 0; n < nFrames; n++) {\r
- AnimationFrame(anim, &(frames[n]), piece);\r
- FrameDelay(appData.animSpeed);\r
- }\r
- EndAnimation(anim, finish);\r
-}\r
-\r
-/* Main control logic for deciding what to animate and how */\r
-\r
-void\r
-AnimateMove(board, fromX, fromY, toX, toY)\r
- Board board;\r
- int fromX;\r
- int fromY;\r
- int toX;\r
- int toY;\r
-{\r
- ChessSquare piece;\r
- int hop;\r
- XPoint start, finish, mid;\r
- XPoint frames[kFactor * 2 + 1];\r
- int nFrames, startColor, endColor;\r
-\r
- /* Are we animating? */\r
- if (!appData.animate || appData.blindfold)\r
- return;\r
-\r
- if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;\r
- piece = board[fromY][fromX];\r
- if (piece >= EmptySquare) return;\r
-\r
-#if DONT_HOP\r
- hop = FALSE;\r
-#else\r
- hop = (piece == WhiteKnight || piece == BlackKnight);\r
-#endif\r
-\r
- if (appData.debugMode) {\r
- printf("AnimateMove: piece %d %s from %d,%d to %d,%d \n",\r
- piece, hop ? "hops" : "slides", fromX, fromY, toX, toY);\r
- }\r
-\r
- ScreenSquare(fromX, fromY, &start, &startColor);\r
- ScreenSquare(toX, toY, &finish, &endColor);\r
-\r
- if (hop) {\r
- /* Knight: make diagonal movement then straight */\r
- if (abs(toY - fromY) < abs(toX - fromX)) {\r
- mid.x = start.x + (finish.x - start.x) / 2;\r
- mid.y = finish.y;\r
- } else {\r
- mid.x = finish.x;\r
- mid.y = start.y + (finish.y - start.y) / 2;\r
- }\r
- } else {\r
- mid.x = start.x + (finish.x - start.x) / 2;\r
- mid.y = start.y + (finish.y - start.y) / 2;\r
- }\r
- \r
- /* Don't use as many frames for very short moves */\r
- if (abs(toY - fromY) + abs(toX - fromX) <= 2)\r
- Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);\r
- else\r
- Tween(&start, &mid, &finish, kFactor, frames, &nFrames);\r
- FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);\r
- \r
- /* Be sure end square is redrawn */\r
- damage[toY][toX] = True;\r
-}\r
-\r
-static void\r
-DragPieceBegin(x, y)\r
- int x; int y;\r
-{\r
- int boardX, boardY, color;\r
- XPoint corner;\r
-\r
- /* Are we animating? */\r
- if (!appData.animateDragging || appData.blindfold)\r
- return;\r
- \r
- /* Figure out which square we start in and the\r
- mouse position relative to top left corner. */\r
- BoardSquare(x, y, &boardX, &boardY);\r
- player.startBoardX = boardX;\r
- player.startBoardY = boardY;\r
- ScreenSquare(boardX, boardY, &corner, &color);\r
- player.startSquare = corner;\r
- player.startColor = color;\r
-#if 0\r
- /* Start from exactly where the piece is. This can be confusing\r
- if you start dragging far from the center of the square; most\r
- or all of the piece can be over a different square from the one\r
- the mouse pointer is in. */\r
- player.mouseDelta.x = x - corner.x;\r
- player.mouseDelta.y = y - corner.y;\r
-#else\r
- /* As soon as we start dragging, the piece will jump slightly to\r
- be centered over the mouse pointer. */\r
- player.mouseDelta.x = squareSize/2;\r
- player.mouseDelta.y = squareSize/2;\r
-#endif\r
- /* Initialise animation */\r
- player.dragPiece = PieceForSquare(boardX, boardY);\r
- /* Sanity check */\r
- if (player.dragPiece >= 0 && player.dragPiece < EmptySquare) {\r
- player.dragActive = True;\r
- BeginAnimation(&player, player.dragPiece, color, &corner);\r
- /* Mark this square as needing to be redrawn. Note that\r
- we don't remove the piece though, since logically (ie\r
- as seen by opponent) the move hasn't been made yet. */\r
- damage[boardY][boardX] = True;\r
- } else {\r
- player.dragActive = False;\r
- }\r
-}\r
-\r
-static void\r
-DragPieceMove(x, y)\r
- int x; int y;\r
-{\r
- XPoint corner;\r
-\r
- /* Are we animating? */\r
- if (!appData.animateDragging || appData.blindfold)\r
- return;\r
- \r
- /* Sanity check */\r
- if (! player.dragActive)\r
- return;\r
- /* Move piece, maintaining same relative position\r
- of mouse within square */\r
- corner.x = x - player.mouseDelta.x;\r
- corner.y = y - player.mouseDelta.y;\r
- AnimationFrame(&player, &corner, player.dragPiece);\r
-#if HIGHDRAG\r
- if (appData.highlightDragging) {\r
- int boardX, boardY;\r
- BoardSquare(x, y, &boardX, &boardY);\r
- SetHighlights(fromX, fromY, boardX, boardY);\r
- }\r
-#endif\r
-}\r
-\r
-static void\r
-DragPieceEnd(x, y)\r
- int x; int y;\r
-{\r
- int boardX, boardY, color;\r
- XPoint corner;\r
-\r
- /* Are we animating? */\r
- if (!appData.animateDragging || appData.blindfold)\r
- return;\r
- \r
- /* Sanity check */\r
- if (! player.dragActive)\r
- return;\r
- /* Last frame in sequence is square piece is\r
- placed on, which may not match mouse exactly. */\r
- BoardSquare(x, y, &boardX, &boardY);\r
- ScreenSquare(boardX, boardY, &corner, &color);\r
- EndAnimation(&player, &corner);\r
-\r
- /* Be sure end square is redrawn */\r
- damage[boardY][boardX] = True;\r
-\r
- /* This prevents weird things happening with fast successive\r
- clicks which on my Sun at least can cause motion events\r
- without corresponding press/release. */\r
- player.dragActive = False;\r
-}\r
-\r
-/* Handle expose event while piece being dragged */\r
-\r
-static void\r
-DrawDragPiece ()\r
-{\r
- if (!player.dragActive || appData.blindfold)\r
- return;\r
-\r
- /* What we're doing: logically, the move hasn't been made yet,\r
- so the piece is still in it's original square. But visually\r
- it's being dragged around the board. So we erase the square\r
- that the piece is on and draw it at the last known drag point. */\r
- BlankSquare(player.startSquare.x, player.startSquare.y,\r
- player.startColor, EmptySquare, xBoardWindow);\r
- AnimationFrame(&player, &player.prevFrame, player.dragPiece);\r
- damage[player.startBoardY][player.startBoardX] = TRUE;\r
-}\r
-\r
-void\r
-SetProgramStats( FrontEndProgramStats * stats )\r
-{\r
- // [HR] TODO\r
-}\r
+/*
+ * xboard.c -- X front end for XBoard
+ *
+ * Copyright 1991 by Digital Equipment Corporation, Maynard,
+ * Massachusetts.
+ *
+ * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
+ * 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+ *
+ * The following terms apply to Digital Equipment Corporation's copyright
+ * interest in XBoard:
+ * ------------------------------------------------------------------------
+ * All Rights Reserved
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notice appear in all copies and that
+ * both that copyright notice and this permission notice appear in
+ * supporting documentation, and that the name of Digital not be
+ * used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ *
+ * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ * ------------------------------------------------------------------------
+ *
+ * The following terms apply to the enhanced version of XBoard
+ * distributed by the Free Software Foundation:
+ * ------------------------------------------------------------------------
+ *
+ * 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 3 of the License, or (at
+ * your option) any later version.
+ *
+ * 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, see http://www.gnu.org/licenses/. *
+ *
+ *------------------------------------------------------------------------
+ ** See the file ChangeLog for a revision history. */
+
+#define HIGHDRAG 1
+
+#include "config.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pwd.h>
+#include <math.h>
+#include <cairo/cairo.h>
+#include <cairo/cairo-xlib.h>
+
+#if !OMIT_SOCKETS
+# if HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+# include <netinet/in.h>
+# include <netdb.h>
+# else /* not HAVE_SYS_SOCKET_H */
+# if HAVE_LAN_SOCKET_H
+# include <lan/socket.h>
+# include <lan/in.h>
+# include <lan/netdb.h>
+# else /* not HAVE_LAN_SOCKET_H */
+# define OMIT_SOCKETS 1
+# endif /* not HAVE_LAN_SOCKET_H */
+# endif /* not HAVE_SYS_SOCKET_H */
+#endif /* !OMIT_SOCKETS */
+
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <string.h>
+#else /* not STDC_HEADERS */
+extern char *getenv();
+# if HAVE_STRING_H
+# include <string.h>
+# else /* not HAVE_STRING_H */
+# include <strings.h>
+# endif /* not HAVE_STRING_H */
+#endif /* not STDC_HEADERS */
+
+#if HAVE_SYS_FCNTL_H
+# include <sys/fcntl.h>
+#else /* not HAVE_SYS_FCNTL_H */
+# if HAVE_FCNTL_H
+# include <fcntl.h>
+# endif /* HAVE_FCNTL_H */
+#endif /* not HAVE_SYS_FCNTL_H */
+
+#if HAVE_SYS_SYSTEMINFO_H
+# include <sys/systeminfo.h>
+#endif /* HAVE_SYS_SYSTEMINFO_H */
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+# include <sys/time.h>
+# else
+# include <time.h>
+# endif
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+#endif
+
+#if HAVE_DIRENT_H
+# include <dirent.h>
+# define NAMLEN(dirent) strlen((dirent)->d_name)
+# define HAVE_DIR_STRUCT
+#else
+# define dirent direct
+# define NAMLEN(dirent) (dirent)->d_namlen
+# if HAVE_SYS_NDIR_H
+# include <sys/ndir.h>
+# define HAVE_DIR_STRUCT
+# endif
+# if HAVE_SYS_DIR_H
+# include <sys/dir.h>
+# define HAVE_DIR_STRUCT
+# endif
+# if HAVE_NDIR_H
+# include <ndir.h>
+# define HAVE_DIR_STRUCT
+# endif
+#endif
+
+#if ENABLE_NLS
+#include <locale.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/Xaw3d/List.h>
+#include <X11/Xaw3d/Label.h>
+#include <X11/Xaw3d/SimpleMenu.h>
+#include <X11/Xaw3d/SmeBSB.h>
+#include <X11/Xaw3d/SmeLine.h>
+#include <X11/Xaw3d/Box.h>
+#include <X11/Xaw3d/MenuButton.h>
+#include <X11/Xaw3d/Text.h>
+#include <X11/Xaw3d/AsciiText.h>
+#else
+#include <X11/Xaw/Dialog.h>
+#include <X11/Xaw/Form.h>
+#include <X11/Xaw/List.h>
+#include <X11/Xaw/Label.h>
+#include <X11/Xaw/SimpleMenu.h>
+#include <X11/Xaw/SmeBSB.h>
+#include <X11/Xaw/SmeLine.h>
+#include <X11/Xaw/Box.h>
+#include <X11/Xaw/MenuButton.h>
+#include <X11/Xaw/Text.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"
+#define IMAGE_EXT "xpm"
+#else
+#define IMAGE_EXT "xim"
+#include "bitmaps/bitmaps.h"
+#endif
+
+#include "bitmaps/icon_white.bm"
+#include "bitmaps/icon_black.bm"
+#include "bitmaps/checkmark.bm"
+
+#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 "xevalgraph.h"
+#include "xedittags.h"
+#include "menus.h"
+#include "board.h"
+#include "dialogs.h"
+#include "engineoutput.h"
+#include "usystem.h"
+#include "gettext.h"
+
+
+#ifdef __EMX__
+#ifndef HAVE_USLEEP
+#define HAVE_USLEEP
+#endif
+#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
+
+int main P((int argc, char **argv));
+RETSIGTYPE CmailSigHandler P((int sig));
+RETSIGTYPE IntSigHandler P((int sig));
+RETSIGTYPE TermSizeSigHandler P((int sig));
+static void CreateGCs P((int redo));
+static void CreateAnyPieces P((void));
+void CreateXIMPieces P((void));
+void CreateXPMPieces P((void));
+void CreatePNGPieces P((void));
+void CreateXPMBoard P((char *s, int n));
+void CreatePieces P((void));
+Widget CreateMenuBar P((Menu *mb, int boardWidth));
+#if ENABLE_NLS
+char *InsertPxlSize P((char *pattern, int targetPxlSize));
+XFontSet CreateFontSet P((char *base_fnt_lst));
+#else
+char *FindFont P((char *pattern, int targetPxlSize));
+#endif
+void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
+ u_int wreq, u_int hreq));
+void CreateGrid P((void));
+void EventProc P((Widget widget, caddr_t unused, XEvent *event));
+void DelayedDrag P((void));
+static void MoveTypeInProc P((Widget widget, caddr_t unused, XEvent *event));
+void HandlePV P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void DrawPositionProc P((Widget w, XEvent *event,
+ String *prms, Cardinal *nprms));
+void CommentClick P((Widget w, XEvent * event,
+ String * params, Cardinal * nParams));
+void ICSInputBoxPopUp P((void));
+void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
+void KeyBindingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void QuitWrapper P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+static void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+static void UpKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+static void DownKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void TempBackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void TempForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+Boolean TempBackwardActive = False;
+void ManInner P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
+void DisplayMove P((int moveNumber));
+void ICSInitScript P((void));
+void SelectMove P((Widget w, XEvent * event, String * params, Cardinal * nParams));
+void update_ics_width P(());
+int CopyMemoProc P(());
+
+/*
+* XBoard depends on Xt R4 or higher
+*/
+int xtVersion = XtSpecificationRelease;
+
+int xScreen;
+Display *xDisplay;
+Window xBoardWindow;
+Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
+ highlightSquareColor, premoveHighlightColor, dialogColor, buttonColor;
+Pixel lowTimeWarningColor;
+GC lightSquareGC, darkSquareGC, lineGC, wdPieceGC, wlPieceGC,
+ bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
+ prelineGC, countGC;
+Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
+Widget shellWidget, formWidget, boardWidget, titleWidget, dropMenu, menuBarWidget;
+Option *optList; // contains all widgets of main window
+XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
+#if ENABLE_NLS
+XFontSet fontSet, clockFontSet;
+#else
+Font clockFontID;
+XFontStruct *clockFontStruct;
+#endif
+Font coordFontID, countFontID;
+XFontStruct *coordFontStruct, *countFontStruct;
+XtAppContext appContext;
+char *layoutName;
+
+char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
+
+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 smallLayout = 0, tinyLayout = 0,
+ marginW, marginH, // [HGM] for run-time resizing
+ fromX = -1, fromY = -1, toX, toY, commentUp = False,
+ errorExitStatus = -1, defaultLineGap;
+Dimension textHeight;
+Pixel timerForegroundPixel, timerBackgroundPixel;
+Pixel buttonForegroundPixel, buttonBackgroundPixel;
+char *chessDir, *programName, *programVersion;
+Boolean alwaysOnTop = False;
+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
+Boolean cairoAnimate;
+static cairo_surface_t *csBoardWindow, *csBoardBackup;
+static cairo_surface_t *pngPieceBitmaps[2][(int)BlackPawn]; // scaled pieces as used
+static cairo_surface_t *pngPieceBitmaps2[2][(int)BlackPawn+4]; // scaled pieces in store
+static cairo_surface_t *pngBoardBitmap[2];
+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;
+Pixmap xpmBoardBitmap[2];
+int useImages, useImageSqs, useTexture, textureW[2], textureH[2];
+XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
+Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
+Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
+XImage *ximLightSquare, *ximDarkSquare;
+XImage *xim_Cross;
+
+#define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
+#define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
+
+#define White(piece) ((int)(piece) < (int)BlackPawn)
+
+/* Bitmaps for use as masks when drawing XPM pieces.
+ Need one for each black and white piece. */
+static Pixmap xpmMask[BlackKing + 1];
+
+/* This magic number is the number of intermediate frames used
+ in each half of the animation. For short moves it's reduced
+ by 1. The total number of frames will be factor * 2 + 1. */
+#define kFactor 4
+
+SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
+
+typedef struct {
+ char piece;
+ char* widget;
+} DropMenuEnables;
+
+DropMenuEnables dmEnables[] = {
+ { 'P', "Pawn" },
+ { 'N', "Knight" },
+ { 'B', "Bishop" },
+ { 'R', "Rook" },
+ { 'Q', "Queen" }
+};
+
+Arg shellArgs[] = {
+ { XtNwidth, 0 },
+ { XtNheight, 0 },
+ { XtNminWidth, 0 },
+ { XtNminHeight, 0 },
+ { XtNmaxWidth, 0 },
+ { XtNmaxHeight, 0 }
+};
+
+XtResource clientResources[] = {
+ { "flashCount", "flashCount", XtRInt, sizeof(int),
+ XtOffset(AppDataPtr, flashCount), XtRImmediate,
+ (XtPointer) FLASH_COUNT },
+};
+
+XrmOptionDescRec shellOptions[] = {
+ { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
+ { "-flash", "flashCount", XrmoptionNoArg, "3" },
+ { "-xflash", "flashCount", XrmoptionNoArg, "0" },
+};
+
+XtActionsRec boardActions[] = {
+ { "DrawPosition", DrawPositionProc },
+ { "HandlePV", HandlePV },
+ { "SelectPV", SelectPV },
+ { "StopPV", StopPV },
+ { "MenuItem", KeyBindingProc }, // [HGM] generic handler for key bindings
+ { "QuitProc", QuitWrapper },
+ { "ManProc", ManInner },
+ { "TempBackwardProc", TempBackwardProc },
+ { "TempForwardProc", TempForwardProc },
+ { "CommentClick", (XtActionProc) CommentClick },
+ { "GenericPopDown", (XtActionProc) GenericPopDown },
+ { "ErrorPopDown", (XtActionProc) ErrorPopDown },
+ { "CopyMemoProc", (XtActionProc) CopyMemoProc },
+ { "SelectMove", (XtActionProc) SelectMove },
+ { "LoadSelectedProc", LoadSelectedProc },
+ { "SetFilterProc", SetFilterProc },
+ { "TypeInProc", TypeInProc },
+ { "EnterKeyProc", EnterKeyProc },
+ { "UpKeyProc", UpKeyProc },
+ { "DownKeyProc", DownKeyProc },
+ { "WheelProc", WheelProc },
+ { "TabProc", TabProc },
+};
+
+char globalTranslations[] =
+ ":<Key>F9: MenuItem(Actions.Resign) \n \
+ :Ctrl<Key>n: MenuItem(File.NewGame) \n \
+ :Meta<Key>V: MenuItem(File.NewVariant) \n \
+ :Ctrl<Key>o: MenuItem(File.LoadGame) \n \
+ :Meta<Key>Next: MenuItem(LoadNextGameProc) \n \
+ :Meta<Key>Prior: MenuItem(LoadPrevGameProc) \n \
+ :Ctrl<Key>Down: LoadSelectedProc(3) \n \
+ :Ctrl<Key>Up: LoadSelectedProc(-3) \n \
+ :Ctrl<Key>s: MenuItem(File.SaveGame) \n \
+ :Ctrl<Key>c: MenuItem(Edit.CopyGame) \n \
+ :Ctrl<Key>v: MenuItem(Edit.PasteGame) \n \
+ :Ctrl<Key>O: MenuItem(File.LoadPosition) \n \
+ :Shift<Key>Next: MenuItem(LoadNextPositionProc) \n \
+ :Shift<Key>Prior: MenuItem(LoadPrevPositionProc) \n \
+ :Ctrl<Key>S: MenuItem(File.SavePosition) \n \
+ :Ctrl<Key>C: MenuItem(Edit.CopyPosition) \n \
+ :Ctrl<Key>V: MenuItem(Edit.PastePosition) \n \
+ :Ctrl<Key>q: MenuItem(File.Quit) \n \
+ :Ctrl<Key>w: MenuItem(Mode.MachineWhite) \n \
+ :Ctrl<Key>b: MenuItem(Mode.MachineBlack) \n \
+ :Ctrl<Key>t: MenuItem(Mode.TwoMachines) \n \
+ :Ctrl<Key>a: MenuItem(Mode.AnalysisMode) \n \
+ :Ctrl<Key>g: MenuItem(Mode.AnalyzeFile) \n \
+ :Ctrl<Key>e: MenuItem(Mode.EditGame) \n \
+ :Ctrl<Key>E: MenuItem(Mode.EditPosition) \n \
+ :Meta<Key>O: MenuItem(View.EngineOutput) \n \
+ :Meta<Key>E: MenuItem(View.EvaluationGraph) \n \
+ :Meta<Key>G: MenuItem(View.GameList) \n \
+ :Meta<Key>H: MenuItem(View.MoveHistory) \n \
+ :<Key>Pause: MenuItem(Mode.Pause) \n \
+ :<Key>F3: MenuItem(Action.Accept) \n \
+ :<Key>F4: MenuItem(Action.Decline) \n \
+ :<Key>F12: MenuItem(Action.Rematch) \n \
+ :<Key>F5: MenuItem(Action.CallFlag) \n \
+ :<Key>F6: MenuItem(Action.Draw) \n \
+ :<Key>F7: MenuItem(Action.Adjourn) \n \
+ :<Key>F8: MenuItem(Action.Abort) \n \
+ :<Key>F10: MenuItem(Action.StopObserving) \n \
+ :<Key>F11: MenuItem(Action.StopExamining) \n \
+ :Ctrl<Key>d: MenuItem(DebugProc) \n \
+ :Meta Ctrl<Key>F12: MenuItem(DebugProc) \n \
+ :Meta<Key>End: MenuItem(Edit.ForwardtoEnd) \n \
+ :Meta<Key>Right: MenuItem(Edit.Forward) \n \
+ :Meta<Key>Home: MenuItem(Edit.BacktoStart) \n \
+ :Meta<Key>Left: MenuItem(Edit.Backward) \n \
+ :<Key>Left: MenuItem(Edit.Backward) \n \
+ :<Key>Right: MenuItem(Edit.Forward) \n \
+ :<Key>Home: MenuItem(Edit.Revert) \n \
+ :<Key>End: MenuItem(Edit.TruncateGame) \n \
+ :Ctrl<Key>m: MenuItem(Engine.MoveNow) \n \
+ :Ctrl<Key>x: MenuItem(Engine.RetractMove) \n \
+ :Meta<Key>J: MenuItem(Options.Adjudications) \n \
+ :Meta<Key>U: MenuItem(Options.CommonEngine) \n \
+ :Meta<Key>T: MenuItem(Options.TimeControl) \n \
+ :Ctrl<Key>P: MenuItem(PonderNextMove) \n "
+#ifndef OPTIONSDIALOG
+ "\
+ :Ctrl<Key>Q: MenuItem(AlwaysQueenProc) \n \
+ :Ctrl<Key>F: MenuItem(AutoflagProc) \n \
+ :Ctrl<Key>A: MenuItem(AnimateMovingProc) \n \
+ :Ctrl<Key>L: MenuItem(TestLegalityProc) \n \
+ :Ctrl<Key>H: MenuItem(HideThinkingProc) \n "
+#endif
+ "\
+ :<Key>F1: MenuItem(Help.ManXBoard) \n \
+ :<Key>F2: MenuItem(View.FlipView) \n \
+ :<KeyDown>Return: TempBackwardProc() \n \
+ :<KeyUp>Return: TempForwardProc() \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[] = {
+ "*Error*translations: #override\\n <Key>Return: ErrorPopDown()",
+ NULL
+ };
+
+
+/* Max possible square size */
+#define MAXSQSIZE 256
+
+static int xpm_avail[MAXSQSIZE];
+
+#ifdef HAVE_DIR_STRUCT
+
+/* Extract piece size from filename */
+static int
+xpm_getsize (char *name, int len, char *ext)
+{
+ char *p, *d;
+ char buf[10];
+
+ if (len < 4)
+ return 0;
+
+ if ((p=strchr(name, '.')) == NULL ||
+ StrCaseCmp(p+1, ext) != 0)
+ return 0;
+
+ p = name + 3;
+ d = buf;
+
+ while (*p && isdigit(*p))
+ *(d++) = *(p++);
+
+ *d = 0;
+ return atoi(buf);
+}
+
+/* Setup xpm_avail */
+static int
+xpm_getavail (char *dirname, char *ext)
+{
+ DIR *dir;
+ struct dirent *ent;
+ int i;
+
+ for (i=0; i<MAXSQSIZE; ++i)
+ xpm_avail[i] = 0;
+
+ if (appData.debugMode)
+ fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
+
+ dir = opendir(dirname);
+ if (!dir)
+ {
+ fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
+ programName, dirname);
+ exit(1);
+ }
+
+ while ((ent=readdir(dir)) != NULL) {
+ i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
+ if (i > 0 && i < MAXSQSIZE)
+ xpm_avail[i] = 1;
+ }
+
+ closedir(dir);
+
+ return 0;
+}
+
+void
+xpm_print_avail (FILE *fp, char *ext)
+{
+ int i;
+
+ fprintf(fp, _("Available `%s' sizes:\n"), ext);
+ for (i=1; i<MAXSQSIZE; ++i) {
+ if (xpm_avail[i])
+ printf("%d\n", i);
+ }
+}
+
+/* Return XPM piecesize closest to size */
+int
+xpm_closest_to (char *dirname, int size, char *ext)
+{
+ int i;
+ int sm_diff = MAXSQSIZE;
+ int sm_index = 0;
+ int diff;
+
+ xpm_getavail(dirname, ext);
+
+ if (appData.debugMode)
+ xpm_print_avail(stderr, ext);
+
+ for (i=1; i<MAXSQSIZE; ++i) {
+ if (xpm_avail[i]) {
+ diff = size - i;
+ diff = (diff<0) ? -diff : diff;
+ if (diff < sm_diff) {
+ sm_diff = diff;
+ sm_index = i;
+ }
+ }
+ }
+
+ if (!sm_index) {
+ fprintf(stderr, _("Error: No `%s' files!\n"), ext);
+ exit(1);
+ }
+
+ return sm_index;
+}
+#else /* !HAVE_DIR_STRUCT */
+/* If we are on a system without a DIR struct, we can't
+ read the directory, so we can't collect a list of
+ filenames, etc., so we can't do any size-fitting. */
+int
+xpm_closest_to (char *dirname, int size, char *ext)
+{
+ fprintf(stderr, _("\
+Warning: No DIR structure found on this system --\n\
+ Unable to autosize for XPM/XIM pieces.\n\
+ Please report this error to %s.\n\
+ Include system type & operating system in message.\n"), PACKAGE_BUGREPORT););
+ return size;
+}
+#endif /* HAVE_DIR_STRUCT */
+
+
+/* Arrange to catch delete-window events */
+Atom wm_delete_window;
+void
+CatchDeleteWindow (Widget w, String procname)
+{
+ char buf[MSG_SIZ];
+ XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
+ snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
+ XtAugmentTranslations(w, XtParseTranslationTable(buf));
+}
+
+void
+BoardToTop ()
+{
+ Arg args[16];
+ XtSetArg(args[0], XtNiconic, False);
+ XtSetValues(shellWidget, args, 1);
+
+ 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 " "
+
+// 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 fontIsSet[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;
+ }
+ fontIsSet[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)(intptr_t)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)(intptr_t)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)(intptr_t)ad->argLoc])
+ fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)(intptr_t)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)
+}
+
+int frameX, frameY;
+
+void
+GetActualPlacement (Widget wg, WindowPlacement *wp)
+{
+ XWindowAttributes winAt;
+ Window win, dummy;
+ int rx, ry;
+
+ if(!wg) return;
+
+ win = XtWindow(wg);
+ XGetWindowAttributes(xDisplay, win, &winAt); // this works, where XtGetValues on XtNx, XtNy does not!
+ XTranslateCoordinates (xDisplay, win, winAt.root, -winAt.border_width, -winAt.border_width, &rx, &ry, &dummy);
+ wp->x = rx - winAt.x;
+ wp->y = ry - winAt.y;
+ wp->height = winAt.height;
+ wp->width = winAt.width;
+ frameX = winAt.x; frameY = winAt.y; // remember to decide if windows touch
+}
+
+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(shellUp[EngOutDlg]) GetActualPlacement(shells[EngOutDlg], &wpEngineOutput);
+ if(shellUp[HistoryDlg]) GetActualPlacement(shells[HistoryDlg], &wpMoveHistory);
+ if(shellUp[EvalGraphDlg]) GetActualPlacement(shells[EvalGraphDlg], &wpEvalGraph);
+ if(shellUp[GameListDlg]) GetActualPlacement(shells[GameListDlg], &wpGameList);
+ if(shellUp[CommentDlg]) GetActualPlacement(shells[CommentDlg], &wpComment);
+ if(shellUp[TagsDlg]) GetActualPlacement(shells[TagsDlg], &wpTags);
+}
+
+void
+PrintCommPortSettings (FILE *f, char *name)
+{ // This option does not exist in XBoard
+}
+
+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
+SwitchWindow ()
+{
+ extern Option dualOptions[];
+ static Window dual;
+ Window tmp = xBoardWindow;
+ if(!dual) dual = XtWindow(dualOptions[3].handle); // must be first call
+ xBoardWindow = dual; // swap them
+ dual = tmp;
+}
+
+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] == NULLCHAR)
+ && 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;
+}
+
+//--------------------------------------------------------------------------------------------
+
+void
+NewSurfaces ()
+{
+ // delete surfaces after size becomes invalid, so they will be recreated
+ if(csBoardWindow) cairo_surface_destroy(csBoardWindow);
+ if(csBoardBackup) cairo_surface_destroy(csBoardBackup);
+ csBoardWindow = csBoardBackup = NULL;
+}
+
+#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 boardWidth, boardHeight, w, h;
+ int i;
+ static Dimension oldWidth, oldHeight;
+ static VariantClass oldVariant;
+ static int oldMono = -1, oldTwoBoards = 0;
+
+ if(!formWidget) return;
+
+ if(oldTwoBoards && !twoBoards) PopDown(DummyDlg);
+ oldTwoBoards = twoBoards;
+
+ if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+
+ if(boardWidth != oldWidth || boardHeight != oldHeight) { // do resizing stuff only if size actually changed
+
+ oldWidth = boardWidth; oldHeight = boardHeight;
+ CreateGrid();
+ NewSurfaces();
+
+ /*
+ * Inhibit shell resizing.
+ */
+ shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + 1; // [HGM] not sure why the +1 is (sometimes) needed...
+ 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], cairoAnimate ? 2 : 6);
+
+ XSync(xDisplay, False);
+ DelayedDrag();
+ }
+
+ // [HGM] pieces: tailor piece bitmaps to needs of specific variant
+ // (only for xpm)
+
+ if(gameInfo.variant != oldVariant) { // and only if variant changed
+
+ 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(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ xpmPieceBitmap[i][(int)WhiteAngel] = xpmPieceBitmap2[i][(int)WhiteFalcon];
+ xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteAlfil];
+ }
+#if !HAVE_LIBXPM
+ // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
+ for(p=0; p<=(int)WhiteKing; p++)
+ ximMaskPm[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
+ if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ ximMaskPm[(int)WhiteAngel] = ximMaskPm2[(int)WhiteFalcon];
+ ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteAlfil];
+ }
+#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(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
+ pieceBitmap[i][(int)WhiteAngel] = pieceBitmap2[i][(int)WhiteFalcon];
+ pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteAlfil];
+ }
+ }
+ }
+ for(i=0; i<2; i++) {
+ int p;
+printf("Copy pieces\n");
+ for(p=0; p<=(int)WhiteKing; p++)
+ pngPieceBitmaps[i][p] = pngPieceBitmaps2[i][p]; // defaults
+ }
+ oldMono = -10; // kludge to force recreation of animation masks
+ oldVariant = gameInfo.variant;
+ }
+#if HAVE_LIBXPM
+ if(appData.monoMode != oldMono || cairoAnimate)
+ CreateAnimVars();
+#endif
+ oldMono = appData.monoMode;
+}
+
+static int
+MakeOneColor (char *name, Pixel *color)
+{
+ XrmValue vFrom, vTo;
+ if (!appData.monoMode) {
+ vFrom.addr = (caddr_t) name;
+ vFrom.size = strlen(name);
+ XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
+ if (vTo.addr == NULL) {
+ appData.monoMode = True;
+ return True;
+ } else {
+ *color = *(Pixel *) vTo.addr;
+ }
+ }
+ return False;
+}
+
+static int
+MakeColors ()
+{ // [HGM] taken out of main(), so it can be called from BoardOptions dialog
+ int forceMono = False;
+
+ forceMono |= MakeOneColor(appData.lightSquareColor, &lightSquareColor);
+ forceMono |= MakeOneColor(appData.darkSquareColor, &darkSquareColor);
+ forceMono |= MakeOneColor(appData.whitePieceColor, &whitePieceColor);
+ forceMono |= MakeOneColor(appData.blackPieceColor, &blackPieceColor);
+ forceMono |= MakeOneColor(appData.highlightSquareColor, &highlightSquareColor);
+ forceMono |= MakeOneColor(appData.premoveHighlightColor, &premoveHighlightColor);
+ if (appData.lowTimeWarning)
+ forceMono |= MakeOneColor(appData.lowTimeWarningColor, &lowTimeWarningColor);
+ if(appData.dialogColor[0]) MakeOneColor(appData.dialogColor, &dialogColor);
+ if(appData.buttonColor[0]) MakeOneColor(appData.buttonColor, &buttonColor);
+
+ return forceMono;
+}
+
+static void
+CreateAnyPieces ()
+{ // [HGM] taken out of main
+#if HAVE_LIBXPM
+ if (appData.monoMode && // [HGM] no sense to go on to certain doom
+ (appData.bitmapDirectory == NULL || appData.bitmapDirectory[0] == NULLCHAR))
+ appData.bitmapDirectory = strdup(DEF_BITMAP_DIR);
+
+ if (appData.bitmapDirectory[0] != NULLCHAR) {
+ CreatePieces();
+ } else {
+ CreateXPMPieces();
+ CreateXPMBoard(appData.liteBackTextureFile, 1);
+ CreateXPMBoard(appData.darkBackTextureFile, 0);
+ }
+ if (appData.pngDirectory[0] != NULLCHAR) { // for now do in parallel
+ CreatePNGPieces();
+ }
+#else
+ CreateXIMPieces();
+ /* Create regular pieces */
+ if (!useImages) CreatePieces();
+#endif
+}
+
+void
+InitDrawingParams ()
+{
+ MakeColors(); CreateGCs(True);
+ CreateAnyPieces();
+}
+
+void
+InitializeFonts (int clockFontPxlSize, int coordFontPxlSize, int fontPxlSize)
+{ // detervtomine what fonts to use, and create them
+ XrmValue vTo;
+ XrmDatabase xdb;
+
+ if(!fontIsSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
+ appData.clockFont = fontTable[CLOCK_FONT][squareSize];
+ if(!fontIsSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
+ appData.font = fontTable[MESSAGE_FONT][squareSize];
+ if(!fontIsSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
+ appData.coordFont = fontTable[COORD_FONT][squareSize];
+
+#if ENABLE_NLS
+ appData.font = InsertPxlSize(appData.font, fontPxlSize);
+ appData.clockFont = InsertPxlSize(appData.clockFont, clockFontPxlSize);
+ appData.coordFont = InsertPxlSize(appData.coordFont, coordFontPxlSize);
+ fontSet = CreateFontSet(appData.font);
+ clockFontSet = CreateFontSet(appData.clockFont);
+ {
+ /* For the coordFont, use the 0th font of the fontset. */
+ XFontSet coordFontSet = CreateFontSet(appData.coordFont);
+ XFontStruct **font_struct_list;
+ XFontSetExtents *fontSize;
+ char **font_name_list;
+ XFontsOfFontSet(coordFontSet, &font_struct_list, &font_name_list);
+ coordFontID = XLoadFont(xDisplay, font_name_list[0]);
+ coordFontStruct = XQueryFont(xDisplay, coordFontID);
+ fontSize = XExtentsOfFontSet(fontSet); // [HGM] figure out how much vertical space font takes
+ textHeight = fontSize->max_logical_extent.height + 5; // add borderWidth
+ }
+#else
+ appData.font = FindFont(appData.font, fontPxlSize);
+ appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
+ appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
+ clockFontID = XLoadFont(xDisplay, appData.clockFont);
+ clockFontStruct = XQueryFont(xDisplay, clockFontID);
+ coordFontID = XLoadFont(xDisplay, appData.coordFont);
+ coordFontStruct = XQueryFont(xDisplay, coordFontID);
+ // textHeight in !NLS mode!
+#endif
+ countFontID = coordFontID; // [HGM] holdings
+ countFontStruct = coordFontStruct;
+
+ xdb = XtDatabase(xDisplay);
+#if ENABLE_NLS
+ XrmPutLineResource(&xdb, "*international: True");
+ vTo.size = sizeof(XFontSet);
+ vTo.addr = (XtPointer) &fontSet;
+ XrmPutResource(&xdb, "*fontSet", XtRFontSet, &vTo);
+#else
+ XrmPutStringResource(&xdb, "*font", appData.font);
+#endif
+}
+
+char *
+PrintArg (ArgType t)
+{
+ char *p="";
+ switch(t) {
+ case ArgZ:
+ case ArgInt: p = " N"; break;
+ case ArgString: p = " STR"; break;
+ case ArgBoolean: p = " TF"; break;
+ case ArgSettingsFilename:
+ case ArgFilename: p = " FILE"; break;
+ case ArgX: p = " Nx"; break;
+ case ArgY: p = " Ny"; break;
+ case ArgAttribs: p = " TEXTCOL"; break;
+ case ArgColor: p = " COL"; break;
+ case ArgFont: p = " FONT"; break;
+ case ArgBoardSize: p = " SIZE"; break;
+ case ArgFloat: p = " FLOAT"; break;
+ case ArgTrue:
+ case ArgFalse:
+ case ArgTwo:
+ case ArgNone:
+ case ArgCommSettings:
+ break;
+ }
+ return p;
+}
+
+void
+PrintOptions ()
+{
+ char buf[MSG_SIZ];
+ int len=0;
+ ArgDescriptor *q, *p = argDescriptors+5;
+ printf("\nXBoard accepts the following options:\n"
+ "(N = integer, TF = true or false, STR = text string, FILE = filename,\n"
+ " Nx, Ny = relative coordinates, COL = color, FONT = X-font spec,\n"
+ " SIZE = board-size spec(s)\n"
+ " Within parentheses are short forms, or options to set to true or false.\n"
+ " Persistent options (saved in the settings file) are marked with *)\n\n");
+ while(p->argName) {
+ if(p->argType == ArgCommSettings) { p++; continue; } // XBoard has no comm port
+ snprintf(buf+len, MSG_SIZ, "-%s%s", p->argName, PrintArg(p->argType));
+ if(p->save) strcat(buf+len, "*");
+ for(q=p+1; q->argLoc == p->argLoc; q++) {
+ if(q->argName[0] == '-') continue;
+ strcat(buf+len, q == p+1 ? " (" : " ");
+ sprintf(buf+strlen(buf), "-%s%s", q->argName, PrintArg(q->argType));
+ }
+ if(q != p+1) strcat(buf+len, ")");
+ len = strlen(buf);
+ if(len > 39) len = 0, printf("%s\n", buf); else while(len < 39) buf[len++] = ' ';
+ p = q;
+ }
+ if(len) buf[len] = NULLCHAR, printf("%s\n", buf);
+}
+
+int
+main (int argc, char **argv)
+{
+ int i, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
+ XSetWindowAttributes window_attributes;
+ Arg args[16];
+ Dimension boardWidth, boardHeight, w, h;
+ char *p;
+ int forceMono = False;
+
+ srandom(time(0)); // [HGM] book: make random truly random
+
+ setbuf(stdout, NULL);
+ setbuf(stderr, NULL);
+ debugFP = stderr;
+
+ if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
+ printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
+ exit(0);
+ }
+
+ if(argc > 1 && !strcmp(argv[1], "--help" )) {
+ PrintOptions();
+ exit(0);
+ }
+
+ programName = strrchr(argv[0], '/');
+ if (programName == NULL)
+ programName = argv[0];
+ else
+ programName++;
+
+#ifdef ENABLE_NLS
+ XtSetLanguageProc(NULL, NULL, NULL);
+ if (appData.debugMode) {
+ fprintf(debugFP, "locale = %s\n", setlocale(LC_ALL, NULL));
+ }
+
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
+#endif
+
+ 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());
+
+ { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
+ static char buf[MSG_SIZ];
+ EscapeExpand(buf, appData.firstInitString);
+ appData.firstInitString = 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);
+ perror(chessDir);
+ exit(1);
+ }
+ }
+
+ 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 */
+ appData.highlightDragging = FALSE;
+#endif
+ InitBackEnd1();
+
+ gameInfo.variant = StringToVariant(appData.variant);
+ InitPosition(FALSE);
+
+ shellWidget =
+ XtAppInitialize(&appContext, "XBoard", shellOptions,
+ XtNumber(shellOptions),
+ &argc, argv, xboardResources, NULL, 0);
+
+ XtGetApplicationResources(shellWidget, (XtPointer) &appData,
+ clientResources, XtNumber(clientResources),
+ NULL, 0);
+
+ xDisplay = XtDisplay(shellWidget);
+ xScreen = DefaultScreen(xDisplay);
+ wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
+
+ /*
+ * determine size, based on supplied or remembered -size, or screen size
+ */
+ if (isdigit(appData.boardSize[0])) {
+ i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
+ &lineGap, &clockFontPxlSize, &coordFontPxlSize,
+ &fontPxlSize, &smallLayout, &tinyLayout);
+ if (i == 0) {
+ fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
+ programName, appData.boardSize);
+ exit(2);
+ }
+ if (i < 7) {
+ /* Find some defaults; use the nearest known size */
+ SizeDefaults *szd, *nearest;
+ int distance = 99999;
+ nearest = szd = sizeDefaults;
+ while (szd->name != NULL) {
+ if (abs(szd->squareSize - squareSize) < distance) {
+ nearest = szd;
+ distance = abs(szd->squareSize - squareSize);
+ if (distance == 0) break;
+ }
+ szd++;
+ }
+ if (i < 2) lineGap = nearest->lineGap;
+ if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
+ if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
+ if (i < 5) fontPxlSize = nearest->fontPxlSize;
+ if (i < 6) smallLayout = nearest->smallLayout;
+ if (i < 7) tinyLayout = nearest->tinyLayout;
+ }
+ } else {
+ SizeDefaults *szd = sizeDefaults;
+ if (*appData.boardSize == NULLCHAR) {
+ while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
+ DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
+ szd++;
+ }
+ if (szd->name == NULL) szd--;
+ 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"),
+ programName, appData.boardSize);
+ exit(2);
+ }
+ }
+ squareSize = szd->squareSize;
+ lineGap = szd->lineGap;
+ clockFontPxlSize = szd->clockFontPxlSize;
+ coordFontPxlSize = szd->coordFontPxlSize;
+ fontPxlSize = szd->fontPxlSize;
+ smallLayout = szd->smallLayout;
+ tinyLayout = szd->tinyLayout;
+ // [HGM] font: use defaults from settings file if available and not overruled
+ }
+
+ /* Now, using squareSize as a hint, find a good XPM/XIM set size */
+ if (strlen(appData.pixmapDirectory) > 0) {
+ p = ExpandPathName(appData.pixmapDirectory);
+ if (!p) {
+ fprintf(stderr, _("Error expanding path name \"%s\"\n"),
+ appData.pixmapDirectory);
+ exit(1);
+ }
+ if (appData.debugMode) {
+ fprintf(stderr, _("\
+XBoard square size (hint): %d\n\
+%s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
+ }
+ squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
+ if (appData.debugMode) {
+ fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
+ }
+ }
+ defaultLineGap = lineGap;
+ if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
+
+ /* [HR] height treated separately (hacked) */
+ boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+
+ /*
+ * Determine what fonts to use.
+ */
+ InitializeFonts(clockFontPxlSize, coordFontPxlSize, fontPxlSize);
+
+ /*
+ * Detect if there are not enough colors available and adapt.
+ */
+ if (DefaultDepth(xDisplay, xScreen) <= 2) {
+ appData.monoMode = True;
+ }
+
+ forceMono = MakeColors();
+
+ if (forceMono) {
+ fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
+ programName);
+ appData.monoMode = True;
+ }
+
+ if (appData.monoMode && appData.debugMode) {
+ fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
+ (unsigned long) XWhitePixel(xDisplay, xScreen),
+ (unsigned long) XBlackPixel(xDisplay, xScreen));
+ }
+
+ ParseIcsTextColors();
+
+ XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
+
+ /*
+ * widget hierarchy
+ */
+ if (tinyLayout) {
+ layoutName = "tinyLayout";
+ } else if (smallLayout) {
+ layoutName = "smallLayout";
+ } else {
+ layoutName = "normalLayout";
+ }
+
+ optList = BoardPopUp(squareSize, lineGap, (void*)
+#if ENABLE_NLS
+ &clockFontSet);
+#else
+ clockFontStruct);
+#endif
+ boardWidget = optList[W_BOARD].handle;
+ menuBarWidget = optList[W_MENU].handle;
+ dropMenu = optList[W_DROP].handle;
+ titleWidget = optList[optList[W_TITLE].type != -1 ? W_TITLE : W_SMALL].handle;
+ formWidget = XtParent(boardWidget);
+ XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
+ XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
+ XtGetValues(optList[W_WHITE].handle, args, 2);
+ if (appData.showButtonBar) { // can't we use timer pixels for this? (Or better yet, just black & white?)
+ XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
+ XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
+ XtGetValues(optList[W_PAUSE].handle, args, 2);
+ }
+ AppendEnginesToMenu(appData.recentEngineList);
+
+ 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().
+
+ /*
+ * Create X checkmark bitmap and initialize option menu checks.
+ */
+ ReadBitmap(&xMarkPixmap, "checkmark.bm",
+ checkmark_bits, checkmark_width, checkmark_height);
+ InitMenuMarkers();
+
+ /*
+ * Create an icon.
+ */
+ ReadBitmap(&wIconPixmap, "icon_white.bm",
+ icon_white_bits, icon_white_width, icon_white_height);
+ ReadBitmap(&bIconPixmap, "icon_black.bm",
+ icon_black_bits, icon_black_width, icon_black_height);
+ iconPixmap = wIconPixmap;
+ i = 0;
+ XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
+ XtSetValues(shellWidget, args, i);
+
+ /*
+ * Create a cursor for the board widget.
+ */
+ window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
+ XChangeWindowAttributes(xDisplay, xBoardWindow,
+ CWCursor, &window_attributes);
+
+ /*
+ * Inhibit shell resizing.
+ */
+
+ CreateAnyPieces();
+ cairoAnimate = *appData.pngDirectory && useTexture == 3
+ && strstr(appData.liteBackTextureFile, ".png") && strstr(appData.darkBackTextureFile, ".png");
+
+ shellArgs[0].value = (XtArgVal) &w;
+ shellArgs[1].value = (XtArgVal) &h;
+ XtGetValues(shellWidget, shellArgs, 2);
+ shellArgs[4].value = shellArgs[2].value = w;
+ shellArgs[5].value = shellArgs[3].value = h;
+ if(!cairoAnimate) 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(False);
+ CreateGrid();
+
+ if(appData.logoSize)
+ { // locate and read user logo
+ char buf[MSG_SIZ];
+ snprintf(buf, MSG_SIZ, "%s/%s.png", appData.logoDir, UserName());
+ ASSIGN(userLogo, buf);
+ }
+
+ if (appData.animate || appData.animateDragging)
+ CreateAnimVars();
+
+ XtAugmentTranslations(formWidget,
+ XtParseTranslationTable(globalTranslations));
+
+ XtAddEventHandler(formWidget, KeyPressMask, False,
+ (XtEventHandler) MoveTypeInProc, NULL);
+ XtAddEventHandler(shellWidget, StructureNotifyMask, False,
+ (XtEventHandler) EventProc, NULL);
+
+ /* [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
+ sending the logon script (problems with timestamp otherwise) */
+ /*ICSInitScript();*/
+ 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);
+ UpdateLogos(TRUE);
+// XtSetKeyboardFocus(shellWidget, formWidget);
+ XSetInputFocus(xDisplay, XtWindow(formWidget), RevertToPointerRoot, CurrentTime);
+
+ XtAppMainLoop(appContext);
+ if (appData.debugMode) fclose(debugFP); // [DM] debug
+ return 0;
+}
+
+RETSIGTYPE
+TermSizeSigHandler (int sig)
+{
+ update_ics_width();
+}
+
+RETSIGTYPE
+IntSigHandler (int sig)
+{
+ ExitEvent(sig);
+}
+
+RETSIGTYPE
+CmailSigHandler (int sig)
+{
+ int dummy = 0;
+ int error;
+
+ signal(SIGUSR1, SIG_IGN); /* suspend handler */
+
+ /* Activate call-back function CmailSigHandlerCallBack() */
+ OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
+
+ signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
+}
+
+void
+CmailSigHandlerCallBack (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
+{
+ BoardToTop();
+ ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */
+}
+/**** end signal code ****/
+
+
+#define Abs(n) ((n)<0 ? -(n) : (n))
+
+#ifdef ENABLE_NLS
+char *
+InsertPxlSize (char *pattern, int targetPxlSize)
+{
+ char *base_fnt_lst, strInt[12], *p, *q;
+ int alternatives, i, len, strIntLen;
+
+ /*
+ * Replace the "*" (if present) in the pixel-size slot of each
+ * alternative with the targetPxlSize.
+ */
+ p = pattern;
+ alternatives = 1;
+ while ((p = strchr(p, ',')) != NULL) {
+ alternatives++;
+ p++;
+ }
+ snprintf(strInt, sizeof(strInt), "%d", targetPxlSize);
+ strIntLen = strlen(strInt);
+ base_fnt_lst = calloc(1, strlen(pattern) + strIntLen * alternatives + 1);
+
+ p = pattern;
+ q = base_fnt_lst;
+ while (alternatives--) {
+ char *comma = strchr(p, ',');
+ for (i=0; i<14; i++) {
+ char *hyphen = strchr(p, '-');
+ if (!hyphen) break;
+ if (comma && hyphen > comma) break;
+ len = hyphen + 1 - p;
+ if (i == 7 && *p == '*' && len == 2) {
+ p += len;
+ memcpy(q, strInt, strIntLen);
+ q += strIntLen;
+ *q++ = '-';
+ } else {
+ memcpy(q, p, len);
+ p += len;
+ q += len;
+ }
+ }
+ if (!comma) break;
+ len = comma + 1 - p;
+ memcpy(q, p, len);
+ p += len;
+ q += len;
+ }
+ strcpy(q, p);
+
+ return base_fnt_lst;
+}
+
+XFontSet
+CreateFontSet (char *base_fnt_lst)
+{
+ XFontSet fntSet;
+ char **missing_list;
+ int missing_count;
+ char *def_string;
+
+ fntSet = XCreateFontSet(xDisplay, base_fnt_lst,
+ &missing_list, &missing_count, &def_string);
+ if (appData.debugMode) {
+ int i, count;
+ XFontStruct **font_struct_list;
+ char **font_name_list;
+ fprintf(debugFP, "Requested font set for list %s\n", base_fnt_lst);
+ if (fntSet) {
+ fprintf(debugFP, " got list %s, locale %s\n",
+ XBaseFontNameListOfFontSet(fntSet),
+ XLocaleOfFontSet(fntSet));
+ count = XFontsOfFontSet(fntSet, &font_struct_list, &font_name_list);
+ for (i = 0; i < count; i++) {
+ fprintf(debugFP, " got charset %s\n", font_name_list[i]);
+ }
+ }
+ for (i = 0; i < missing_count; i++) {
+ fprintf(debugFP, " missing charset %s\n", missing_list[i]);
+ }
+ }
+ if (fntSet == NULL) {
+ fprintf(stderr, _("Unable to create font set for %s.\n"), base_fnt_lst);
+ exit(2);
+ }
+ return fntSet;
+}
+#else // not ENABLE_NLS
+/*
+ * 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,
+ * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
+ * The return value should be freed with XtFree when no
+ * longer needed.
+ */
+char *
+FindFont (char *pattern, int targetPxlSize)
+{
+ char **fonts, *p, *best, *scalable, *scalableTail;
+ int i, j, nfonts, minerr, err, pxlSize;
+
+ fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
+ if (nfonts < 1) {
+ fprintf(stderr, _("%s: no fonts match pattern %s\n"),
+ programName, pattern);
+ exit(2);
+ }
+
+ best = fonts[0];
+ scalable = NULL;
+ minerr = 999999;
+ for (i=0; i<nfonts; i++) {
+ j = 0;
+ p = fonts[i];
+ if (*p != '-') continue;
+ while (j < 7) {
+ if (*p == NULLCHAR) break;
+ if (*p++ == '-') j++;
+ }
+ if (j < 7) continue;
+ pxlSize = atoi(p);
+ if (pxlSize == 0) {
+ scalable = fonts[i];
+ scalableTail = p;
+ } else {
+ err = pxlSize - targetPxlSize;
+ if (Abs(err) < Abs(minerr) ||
+ (minerr > 0 && err < 0 && -err == minerr)) {
+ best = fonts[i];
+ minerr = err;
+ }
+ }
+ }
+ if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
+ /* If the error is too big and there is a scalable font,
+ use the scalable font. */
+ int headlen = scalableTail - scalable;
+ p = (char *) XtMalloc(strlen(scalable) + 10);
+ while (isdigit(*scalableTail)) scalableTail++;
+ sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
+ } else {
+ 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"),
+ pattern, targetPxlSize, p);
+ }
+ XFreeFontNames(fonts);
+ return p;
+}
+#endif
+
+void
+DeleteGCs ()
+{ // [HGM] deletes GCs that are to be remade, to prevent resource leak;
+ // must be called before all non-first callse to CreateGCs()
+ XtReleaseGC(shellWidget, highlineGC);
+ XtReleaseGC(shellWidget, lightSquareGC);
+ XtReleaseGC(shellWidget, darkSquareGC);
+ XtReleaseGC(shellWidget, lineGC);
+ if (appData.monoMode) {
+ if (DefaultDepth(xDisplay, xScreen) == 1) {
+ XtReleaseGC(shellWidget, wbPieceGC);
+ } else {
+ XtReleaseGC(shellWidget, bwPieceGC);
+ }
+ } else {
+ XtReleaseGC(shellWidget, prelineGC);
+ XtReleaseGC(shellWidget, wdPieceGC);
+ XtReleaseGC(shellWidget, wlPieceGC);
+ XtReleaseGC(shellWidget, bdPieceGC);
+ XtReleaseGC(shellWidget, blPieceGC);
+ }
+}
+
+static GC
+CreateOneGC (XGCValues *gc_values, Pixel foreground, Pixel background)
+{
+ XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
+ | GCBackground | GCFunction | GCPlaneMask;
+ gc_values->foreground = foreground;
+ gc_values->background = background;
+ return XtGetGC(shellWidget, value_mask, gc_values);
+}
+
+static void
+CreateGCs (int redo)
+{
+ XGCValues gc_values;
+ GC copyInvertedGC;
+ Pixel white = XWhitePixel(xDisplay, xScreen);
+ Pixel black = XBlackPixel(xDisplay, xScreen);
+
+ gc_values.plane_mask = AllPlanes;
+ gc_values.line_width = lineGap;
+ gc_values.line_style = LineSolid;
+ gc_values.function = GXcopy;
+
+ if(redo) {
+ DeleteGCs(); // called a second time; clean up old GCs first
+ } else { // [HGM] grid and font GCs created on first call only
+ coordGC = CreateOneGC(&gc_values, black, white);
+ XSetFont(xDisplay, coordGC, coordFontID);
+
+ // [HGM] make font for holdings counts (white on black)
+ countGC = CreateOneGC(&gc_values, white, black);
+ XSetFont(xDisplay, countGC, countFontID);
+ }
+ lineGC = CreateOneGC(&gc_values, black, black);
+
+ if (appData.monoMode) {
+
+ highlineGC = CreateOneGC(&gc_values, white, white);
+ lightSquareGC = wbPieceGC = CreateOneGC(&gc_values, white, black);
+ darkSquareGC = bwPieceGC = CreateOneGC(&gc_values, black, white);
+
+ if (DefaultDepth(xDisplay, xScreen) == 1) {
+ /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
+ gc_values.function = GXcopyInverted;
+ copyInvertedGC = CreateOneGC(&gc_values, black, white);
+ gc_values.function = GXcopy;
+ if (XBlackPixel(xDisplay, xScreen) == 1) {
+ bwPieceGC = darkSquareGC;
+ wbPieceGC = copyInvertedGC;
+ } else {
+ bwPieceGC = copyInvertedGC;
+ wbPieceGC = lightSquareGC;
+ }
+ }
+ } else {
+
+ highlineGC = CreateOneGC(&gc_values, highlightSquareColor, highlightSquareColor);
+ prelineGC = CreateOneGC(&gc_values, premoveHighlightColor, premoveHighlightColor);
+ lightSquareGC = CreateOneGC(&gc_values, lightSquareColor, darkSquareColor);
+ darkSquareGC = CreateOneGC(&gc_values, darkSquareColor, lightSquareColor);
+ wdPieceGC = CreateOneGC(&gc_values, whitePieceColor, darkSquareColor);
+ wlPieceGC = CreateOneGC(&gc_values, whitePieceColor, lightSquareColor);
+ bdPieceGC = CreateOneGC(&gc_values, blackPieceColor, darkSquareColor);
+ blPieceGC = CreateOneGC(&gc_values, blackPieceColor, lightSquareColor);
+ }
+}
+
+void
+loadXIM (XImage *xim, XImage *xmask, char *filename, Pixmap *dest, Pixmap *mask)
+{
+ int x, y, w, h, p;
+ FILE *fp;
+ Pixmap temp;
+ XGCValues values;
+ GC maskGC;
+
+ fp = fopen(filename, "rb");
+ if (!fp) {
+ fprintf(stderr, _("%s: error loading XIM!\n"), programName);
+ exit(1);
+ }
+
+ w = fgetc(fp);
+ h = fgetc(fp);
+
+ for (y=0; y<h; ++y) {
+ for (x=0; x<h; ++x) {
+ p = fgetc(fp);
+
+ switch (p) {
+ case 0:
+ XPutPixel(xim, x, y, blackPieceColor);
+ if (xmask)
+ XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
+ break;
+ case 1:
+ XPutPixel(xim, x, y, darkSquareColor);
+ if (xmask)
+ XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
+ break;
+ case 2:
+ XPutPixel(xim, x, y, whitePieceColor);
+ if (xmask)
+ XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
+ break;
+ case 3:
+ XPutPixel(xim, x, y, lightSquareColor);
+ if (xmask)
+ XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
+ break;
+ }
+ }
+ }
+
+ fclose(fp);
+
+ /* create Pixmap of piece */
+ *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
+ w, h, xim->depth);
+ XPutImage(xDisplay, *dest, lightSquareGC, xim,
+ 0, 0, 0, 0, w, h);
+
+ /* create Pixmap of clipmask
+ Note: We assume the white/black pieces have the same
+ outline, so we make only 6 masks. This is okay
+ since the XPM clipmask routines do the same. */
+ if (xmask) {
+ temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
+ w, h, xim->depth);
+ XPutImage(xDisplay, temp, lightSquareGC, xmask,
+ 0, 0, 0, 0, w, h);
+
+ /* now create the 1-bit version */
+ *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
+ w, h, 1);
+
+ values.foreground = 1;
+ values.background = 0;
+
+ /* Don't use XtGetGC, not read only */
+ maskGC = XCreateGC(xDisplay, *mask,
+ GCForeground | GCBackground, &values);
+ XCopyPlane(xDisplay, temp, *mask, maskGC,
+ 0, 0, squareSize, squareSize, 0, 0, 1);
+ XFreePixmap(xDisplay, temp);
+ }
+}
+
+
+char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
+
+void
+CreateXIMPieces ()
+{
+ int piece, kind;
+ char buf[MSG_SIZ];
+ u_int ss;
+ static char *ximkind[] = { "ll", "ld", "dl", "dd" };
+ XImage *ximtemp;
+
+ ss = squareSize;
+
+ /* The XSynchronize calls were copied from CreatePieces.
+ Not sure if needed, but can't hurt */
+ XSynchronize(xDisplay, True); /* Work-around for xlib/xt
+ buffering bug */
+
+ /* temp needed by loadXIM() */
+ ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
+ 0, 0, ss, ss, AllPlanes, XYPixmap);
+
+ if (strlen(appData.pixmapDirectory) == 0) {
+ useImages = 0;
+ } else {
+ useImages = 1;
+ if (appData.monoMode) {
+ DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
+ 0, 2);
+ ExitEvent(2);
+ }
+ fprintf(stderr, _("\nLoading XIMs...\n"));
+ /* Load pieces */
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ fprintf(stderr, "%d", piece+1);
+ for (kind=0; kind<4; kind++) {
+ fprintf(stderr, ".");
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
+ ExpandPathName(appData.pixmapDirectory),
+ piece <= (int) WhiteKing ? "" : "w",
+ pieceBitmapNames[piece],
+ ximkind[kind], ss);
+ ximPieceBitmap[kind][piece] =
+ XGetImage(xDisplay, DefaultRootWindow(xDisplay),
+ 0, 0, ss, ss, AllPlanes, XYPixmap);
+ if (appData.debugMode)
+ fprintf(stderr, _("(File:%s:) "), buf);
+ loadXIM(ximPieceBitmap[kind][piece],
+ ximtemp, buf,
+ &(xpmPieceBitmap2[kind][piece]),
+ &(ximMaskPm2[piece]));
+ if(piece <= (int)WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
+ fprintf(stderr," ");
+ }
+ /* Load light and dark squares */
+ /* If the LSQ and DSQ pieces don't exist, we will
+ draw them with solid squares. */
+ snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
+ if (access(buf, 0) != 0) {
+ useImageSqs = 0;
+ } else {
+ useImageSqs = 1;
+ fprintf(stderr, _("light square "));
+ ximLightSquare=
+ XGetImage(xDisplay, DefaultRootWindow(xDisplay),
+ 0, 0, ss, ss, AllPlanes, XYPixmap);
+ if (appData.debugMode)
+ fprintf(stderr, _("(File:%s:) "), buf);
+
+ loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
+ fprintf(stderr, _("dark square "));
+ snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
+ ExpandPathName(appData.pixmapDirectory), ss);
+ if (appData.debugMode)
+ fprintf(stderr, _("(File:%s:) "), buf);
+ ximDarkSquare=
+ XGetImage(xDisplay, DefaultRootWindow(xDisplay),
+ 0, 0, ss, ss, AllPlanes, XYPixmap);
+ loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
+ xpmJailSquare = xpmLightSquare;
+ }
+ fprintf(stderr, _("Done.\n"));
+ }
+ XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
+}
+
+static VariantClass oldVariant = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
+
+#if HAVE_LIBXPM
+void
+CreateXPMBoard (char *s, int kind)
+{
+ XpmAttributes attr;
+ attr.valuemask = 0;
+ if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
+ if(strstr(s, ".png")) {
+ cairo_surface_t *img = cairo_image_surface_create_from_png (s);
+ if(img) {
+ useTexture |= kind + 1; pngBoardBitmap[kind] = img;
+ textureW[kind] = cairo_image_surface_get_width (img);
+ textureH[kind] = cairo_image_surface_get_height (img);
+ }
+ } else
+ if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
+ useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
+ }
+}
+
+void
+FreeXPMPieces ()
+{ // [HGM] to prevent resoucre leak on calling CreaeXPMPieces() a second time,
+ // thisroutine has to be called t free the old piece pixmaps
+ int piece, kind;
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++)
+ for (kind=0; kind<4; kind++) XFreePixmap(xDisplay, xpmPieceBitmap2[kind][piece]);
+ if(useImageSqs) {
+ XFreePixmap(xDisplay, xpmLightSquare);
+ XFreePixmap(xDisplay, xpmDarkSquare);
+ }
+}
+
+void
+CreateXPMPieces ()
+{
+ int piece, kind, r;
+ char buf[MSG_SIZ];
+ u_int ss = squareSize;
+ XpmAttributes attr;
+ static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
+ XpmColorSymbol symbols[4];
+ static int redo = False;
+
+ if(redo) FreeXPMPieces(); else redo = 1;
+
+ /* The XSynchronize calls were copied from CreatePieces.
+ Not sure if needed, but can't hurt */
+ XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
+
+ /* Setup translations so piece colors match square colors */
+ symbols[0].name = "light_piece";
+ symbols[0].value = appData.whitePieceColor;
+ symbols[1].name = "dark_piece";
+ symbols[1].value = appData.blackPieceColor;
+ symbols[2].name = "light_square";
+ symbols[2].value = appData.lightSquareColor;
+ symbols[3].name = "dark_square";
+ symbols[3].value = appData.darkSquareColor;
+
+ attr.valuemask = XpmColorSymbols;
+ attr.colorsymbols = symbols;
+ attr.numsymbols = 4;
+
+ if (appData.monoMode) {
+ DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
+ 0, 2);
+ ExitEvent(2);
+ }
+ if (strlen(appData.pixmapDirectory) == 0) {
+ XpmPieces* pieces = builtInXpms;
+ useImages = 1;
+ /* Load pieces */
+ while (pieces->size != squareSize && pieces->size) pieces++;
+ if (!pieces->size) {
+ fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
+ exit(1);
+ }
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ for (kind=0; kind<4; kind++) {
+
+ if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
+ pieces->xpm[piece][kind],
+ &(xpmPieceBitmap2[kind][piece]),
+ NULL, &attr)) != 0) {
+ fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
+ r, buf);
+ exit(1);
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
+ }
+ useImageSqs = 0;
+ xpmJailSquare = xpmLightSquare;
+ } else {
+ useImages = 1;
+
+ fprintf(stderr, _("\nLoading XPMs...\n"));
+
+ /* Load pieces */
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ fprintf(stderr, "%d ", piece+1);
+ for (kind=0; kind<4; kind++) {
+ snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
+ ExpandPathName(appData.pixmapDirectory),
+ piece > (int) WhiteKing ? "w" : "",
+ pieceBitmapNames[piece],
+ xpmkind[kind], ss);
+ if (appData.debugMode) {
+ fprintf(stderr, _("(File:%s:) "), buf);
+ }
+ if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &(xpmPieceBitmap2[kind][piece]),
+ NULL, &attr)) != 0) {
+ if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
+ // [HGM] missing: read of unorthodox piece failed; substitute King.
+ snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
+ ExpandPathName(appData.pixmapDirectory),
+ xpmkind[kind], ss);
+ if (appData.debugMode) {
+ fprintf(stderr, _("(Replace by File:%s:) "), buf);
+ }
+ r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &(xpmPieceBitmap2[kind][piece]),
+ NULL, &attr);
+ }
+ if (r != 0) {
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
+ r, buf);
+ exit(1);
+ }
+ }
+ if(piece <= (int) WhiteKing)
+ xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
+ }
+ }
+ /* Load light and dark squares */
+ /* If the LSQ and DSQ pieces don't exist, we will
+ draw them with solid squares. */
+ fprintf(stderr, _("light square "));
+ snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
+ if (access(buf, 0) != 0) {
+ useImageSqs = 0;
+ } else {
+ useImageSqs = 1;
+ if (appData.debugMode)
+ fprintf(stderr, _("(File:%s:) "), buf);
+
+ if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &xpmLightSquare, NULL, &attr)) != 0) {
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
+ exit(1);
+ }
+ fprintf(stderr, _("dark square "));
+ snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
+ ExpandPathName(appData.pixmapDirectory), ss);
+ if (appData.debugMode) {
+ fprintf(stderr, _("(File:%s:) "), buf);
+ }
+ if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
+ &xpmDarkSquare, NULL, &attr)) != 0) {
+ fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
+ exit(1);
+ }
+ }
+ xpmJailSquare = xpmLightSquare;
+ fprintf(stderr, _("Done.\n"));
+ }
+ oldVariant = -1; // kludge to force re-makig of animation masks
+ XSynchronize(xDisplay, False); /* Work-around for xlib/xt
+ buffering bug */
+}
+#endif /* HAVE_LIBXPM */
+
+char *pngPieceNames[] = // must be in same order as internal piece encoding
+{ "Pawn", "Knight", "Bishop", "Rook", "Queen", "Advisor", "Elephant", "Archbishop", "Marshall", "Gold", "Commoner",
+ "Canon", "Nightrider", "CrownedBishop", "CrownedRook", "Princess", "Chancellor", "Hawk", "Lance", "Cobra", "Unicorn", "King",
+ "GoldKnight", "GoldLance", "GoldPawn", "GoldSilver", NULL
+};
+
+void
+ScaleOnePiece (char *name, int color, int piece)
+{
+ int w, h;
+ char buf[MSG_SIZ];
+ cairo_surface_t *img, *cs;
+ cairo_t *cr;
+ static cairo_surface_t *pngPieceImages[2][(int)BlackPawn+4]; // png 256 x 256 images
+
+ if((img = pngPieceImages[color][piece]) == NULL) { // if PNG file for this piece was not yet read, read it now and store it
+ snprintf(buf, MSG_SIZ, "%s/%s%s.png", appData.pngDirectory, color ? "Black" : "White", pngPieceNames[piece]);
+ pngPieceImages[color][piece] = img = cairo_image_surface_create_from_png (buf);
+ w = cairo_image_surface_get_width (img);
+ h = cairo_image_surface_get_height (img);
+ if(w != 64 || h != 64) { printf("Bad png size %dx%d in %s\n", w, h, buf); exit(1); }
+ }
+ // create new bitmap to hold scaled piece image (and remove any old)
+ if(pngPieceBitmaps2[color][piece]) cairo_surface_destroy (pngPieceBitmaps2[color][piece]);
+ pngPieceBitmaps2[color][piece] = cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ if(piece <= WhiteKing) pngPieceBitmaps[color][piece] = cs;
+ // scaled copying of the raw png image
+ cr = cairo_create(cs);
+ cairo_scale(cr, squareSize/64., squareSize/64.);
+ cairo_set_source_surface (cr, img, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+}
+
+void
+CreatePNGPieces ()
+{
+ int p;
+
+ for(p=0; pngPieceNames[p]; p++) {
+ ScaleOnePiece(pngPieceNames[p], 0, p);
+ ScaleOnePiece(pngPieceNames[p], 1, p);
+ }
+}
+
+#if HAVE_LIBXPM
+/* No built-in bitmaps */
+void CreatePieces()
+{
+ int piece, kind;
+ char buf[MSG_SIZ];
+ u_int ss = squareSize;
+
+ XSynchronize(xDisplay, True); /* Work-around for xlib/xt
+ buffering bug */
+
+ for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ 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 */
+}
+#else
+/* With built-in bitmaps */
+void
+CreatePieces ()
+{
+ BuiltInBits* bib = builtInBits;
+ int piece, kind;
+ char buf[MSG_SIZ];
+ u_int ss = squareSize;
+
+ XSynchronize(xDisplay, True); /* Work-around for xlib/xt
+ buffering bug */
+
+ while (bib->squareSize != ss && bib->squareSize != 0) bib++;
+
+ for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
+ for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
+ 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 */
+}
+#endif
+
+void
+ReadBitmap (Pixmap *pm, String name, unsigned char bits[], u_int wreq, u_int hreq)
+{
+ int x_hot, y_hot;
+ u_int w, h;
+ int errcode;
+ char msg[MSG_SIZ], fullname[MSG_SIZ];
+
+ if (*appData.bitmapDirectory != NULLCHAR) {
+ 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:
+ snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
+ break;
+ case BitmapFileInvalid:
+ snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
+ break;
+ case BitmapNoMemory:
+ snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
+ fullname);
+ break;
+ default:
+ snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
+ errcode, fullname);
+ break;
+ }
+ fprintf(stderr, _("%s: %s...using built-in\n"),
+ programName, msg);
+ } else if (w != wreq || h != hreq) {
+ fprintf(stderr,
+ _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
+ programName, fullname, w, h, wreq, hreq);
+ } else {
+ return;
+ }
+ }
+ if (bits != NULL) {
+ *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
+ wreq, hreq);
+ }
+}
+
+void
+CreateGrid ()
+{
+ int i, j;
+
+ if (lineGap == 0) return;
+
+ /* [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));
+ }
+}
+
+void
+MarkMenuItem (char *menuRef, int state)
+{
+ MenuItem *item = MenuNameToItem(menuRef);
+
+ if(item) {
+ Arg args[2];
+ XtSetArg(args[0], XtNleftBitmap, state ? xMarkPixmap : None);
+ XtSetValues(item->handle, args, 1);
+ }
+}
+
+void
+EnableNamedMenuItem (char *menuRef, int state)
+{
+ MenuItem *item = MenuNameToItem(menuRef);
+
+ if(item) XtSetSensitive(item->handle, state);
+}
+
+void
+EnableButtonBar (int state)
+{
+ XtSetSensitive(optList[W_BUTTON].handle, state);
+}
+
+
+void
+SetMenuEnables (Enables *enab)
+{
+ while (enab->name != NULL) {
+ EnableNamedMenuItem(enab->name, enab->value);
+ enab++;
+ }
+}
+
+void
+KeyBindingProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{ // [HGM] new method of key binding: specify MenuItem(FlipView) in stead of FlipViewProc in translation string
+ MenuItem *item;
+ if(*nprms == 0) return;
+ item = MenuNameToItem(prms[0]);
+ if(item) ((MenuProc *) item->proc) ();
+}
+
+static void
+MenuEngineSelect (Widget w, caddr_t addr, caddr_t index)
+{
+ RecentEngineEvent((int) (intptr_t) addr);
+}
+
+void
+AppendMenuItem (char *msg, int n)
+{
+ CreateMenuItem((Widget) optList[W_ENGIN].textValue, msg, (XtCallbackProc) MenuEngineSelect, n);
+}
+
+void
+SetupDropMenu ()
+{
+ int i, j, count;
+ char label[32];
+ Arg args[16];
+ Widget entry;
+ char* p;
+
+ for (i=0; i<sizeof(dmEnables)/sizeof(DropMenuEnables); i++) {
+ entry = XtNameToWidget(dropMenu, dmEnables[i].widget);
+ p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,
+ dmEnables[i].piece);
+ XtSetSensitive(entry, p != NULL || !appData.testLegality
+ /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse
+ && !appData.icsActive));
+ count = 0;
+ while (p && *p++ == dmEnables[i].piece) count++;
+ snprintf(label, sizeof(label), "%s %d", dmEnables[i].widget, count);
+ j = 0;
+ XtSetArg(args[j], XtNlabel, label); j++;
+ XtSetValues(entry, args, j);
+ }
+}
+
+
+static void
+do_flash_delay (unsigned long msec)
+{
+ TimeDelay(msec);
+}
+
+void
+DoDrawBorder (cairo_surface_t *cs, int x, int y, int type)
+{
+ cairo_t *cr;
+ DrawSeekOpen();
+
+ cr = cairo_create(cs);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle(cr, x, y, squareSize+lineGap, squareSize+lineGap);
+ SetPen(cr, lineGap, type == 1 ? appData.highlightSquareColor : appData.premoveHighlightColor, 0);
+ cairo_stroke(cr);
+}
+
+void
+DrawBorder (int x, int y, int type)
+{
+ DoDrawBorder(csBoardWindow, x, y, type);
+ DoDrawBorder(csBoardBackup, x, y, type);
+}
+
+static int
+CutOutSquare (int x, int y, int *x0, int *y0, int kind)
+{
+ int W = BOARD_WIDTH, H = BOARD_HEIGHT;
+ int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
+ *x0 = 0; *y0 = 0;
+ if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
+ if(textureW[kind] < W*squareSize)
+ *x0 = (textureW[kind] - squareSize) * nx/(W-1);
+ else
+ *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
+ if(textureH[kind] < H*squareSize)
+ *y0 = (textureH[kind] - squareSize) * ny/(H-1);
+ else
+ *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
+ return 1;
+}
+
+void
+DrawLogo (void *handle, void *logo)
+{
+ cairo_surface_t *img, *cs;
+ cairo_t *cr;
+ int w, h;
+
+ if(!logo || !handle) return;
+ cs = cairo_xlib_surface_create(xDisplay, XtWindow(handle), DefaultVisual(xDisplay, 0), appData.logoSize, appData.logoSize/2);
+ img = cairo_image_surface_create_from_png (logo);
+ w = cairo_image_surface_get_width (img);
+ h = cairo_image_surface_get_height (img);
+ cr = cairo_create(cs);
+ cairo_scale(cr, (float)appData.logoSize/w, appData.logoSize/(2.*h));
+ cairo_set_source_surface (cr, img, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+ cairo_surface_destroy (img);
+ cairo_surface_destroy (cs);
+}
+
+static void
+BlankSquare (int x, int y, int color, ChessSquare piece, Drawable dest, int fac)
+{ // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
+ int x0, y0;
+ if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
+ if(pngBoardBitmap[color]) {
+ cairo_t *cr;
+ if(!fac && !cairoAnimate) return;
+ DrawSeekOpen();
+ cr = cairo_create (fac ? csBoardWindow : (cairo_surface_t *) dest);
+ cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ if(fac) {
+ cr = cairo_create (csBoardBackup);
+ cairo_set_source_surface (cr, pngBoardBitmap[color], x*fac - x0, y*fac - y0);
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle (cr, x*fac, y*fac, squareSize, squareSize);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ }
+ } else
+ XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
+ squareSize, squareSize, x*fac, y*fac);
+ } else
+ if (useImages && useImageSqs) {
+ Pixmap pm;
+ switch (color) {
+ case 1: /* light */
+ pm = xpmLightSquare;
+ break;
+ case 0: /* dark */
+ pm = xpmDarkSquare;
+ break;
+ case 2: /* neutral */
+ default:
+ pm = xpmJailSquare; // [HGM] this is wrong, but apparently never used?
+ break;
+ }
+ XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
+ squareSize, squareSize, x*fac, y*fac);
+ } else {
+ GC gc;
+ switch (color) {
+ case 1: /* light */
+ gc = lightSquareGC;
+ break;
+ case 0: /* dark */
+ gc = darkSquareGC;
+ break;
+ case 2: /* neutral */
+ default:
+ gc = lineGC;
+ break;
+ }
+ XFillRectangle(xDisplay, dest, gc, x*fac, y*fac, squareSize, squareSize);
+ }
+}
+
+/*
+ I split out the routines to draw a piece so that I could
+ make a generic flash routine.
+*/
+static void
+monoDrawPiece_1bit (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
+ switch (square_color) {
+ case 1: /* light */
+ case 2: /* neutral */
+ default:
+ XCopyArea(xDisplay, (int) piece < (int) BlackPawn
+ ? *pieceToOutline(piece)
+ : *pieceToSolid(piece),
+ dest, bwPieceGC, 0, 0,
+ squareSize, squareSize, x, y);
+ break;
+ case 0: /* dark */
+ XCopyArea(xDisplay, (int) piece < (int) BlackPawn
+ ? *pieceToSolid(piece)
+ : *pieceToOutline(piece),
+ dest, wbPieceGC, 0, 0,
+ squareSize, squareSize, x, y);
+ break;
+ }
+}
+
+static void
+monoDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ switch (square_color) {
+ case 1: /* light */
+ case 2: /* neutral */
+ default:
+ XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
+ ? *pieceToOutline(piece)
+ : *pieceToSolid(piece),
+ dest, bwPieceGC, 0, 0,
+ squareSize, squareSize, x, y, 1);
+ break;
+ case 0: /* dark */
+ XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
+ ? *pieceToSolid(piece)
+ : *pieceToOutline(piece),
+ dest, wbPieceGC, 0, 0,
+ squareSize, squareSize, x, y, 1);
+ break;
+ }
+}
+
+static void
+colorDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
+ switch (square_color) {
+ case 1: /* light */
+ XCopyPlane(xDisplay, *pieceToSolid(piece),
+ dest, (int) piece < (int) BlackPawn
+ ? wlPieceGC : blPieceGC, 0, 0,
+ squareSize, squareSize, x, y, 1);
+ break;
+ case 0: /* dark */
+ XCopyPlane(xDisplay, *pieceToSolid(piece),
+ dest, (int) piece < (int) BlackPawn
+ ? wdPieceGC : bdPieceGC, 0, 0,
+ squareSize, squareSize, x, y, 1);
+ break;
+ case 2: /* neutral */
+ default:
+ break; // should never contain pieces
+ }
+}
+
+static void
+colorDrawPieceImage (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ int kind, p = piece;
+
+ switch (square_color) {
+ case 1: /* light */
+ case 2: /* neutral */
+ default:
+ if ((int)piece < (int) BlackPawn) {
+ kind = 0;
+ } else {
+ kind = 2;
+ piece -= BlackPawn;
+ }
+ break;
+ case 0: /* dark */
+ if ((int)piece < (int) BlackPawn) {
+ kind = 1;
+ } else {
+ kind = 3;
+ piece -= BlackPawn;
+ }
+ break;
+ }
+ if(appData.upsideDown && flipView) { kind ^= 2; p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
+ if(useTexture & square_color+1) {
+ BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+ XSetClipMask(xDisplay, wlPieceGC, xpmMask[p]);
+ XSetClipOrigin(xDisplay, wlPieceGC, x, y);
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece], dest, wlPieceGC, 0, 0, squareSize, squareSize, x, y);
+ XSetClipMask(xDisplay, wlPieceGC, None);
+ XSetClipOrigin(xDisplay, wlPieceGC, 0, 0);
+ } else
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
+ dest, wlPieceGC, 0, 0,
+ squareSize, squareSize, x, y);
+}
+
+static void
+pngDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
+{
+ int kind, p = piece;
+ cairo_t *cr;
+
+ if ((int)piece < (int) BlackPawn) {
+ kind = 0;
+ } else {
+ kind = 1;
+ piece -= BlackPawn;
+ }
+ if(appData.upsideDown && flipView) { p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
+ BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
+ DrawSeekOpen();
+ cr = cairo_create (csBoardWindow);
+ cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+ cairo_paint(cr);
+ cairo_destroy (cr);
+ cr = cairo_create (csBoardBackup);
+ cairo_set_source_surface (cr, pngPieceBitmaps[kind][piece], x, y);
+ cairo_paint(cr);
+ cairo_destroy (cr);
+}
+
+typedef void (*DrawFunc)();
+
+DrawFunc
+ChooseDrawFunc ()
+{
+ if (appData.monoMode) {
+ if (DefaultDepth(xDisplay, xScreen) == 1) {
+ return monoDrawPiece_1bit;
+ } else {
+ return monoDrawPiece;
+ }
+ } else if(appData.pngDirectory[0]) {
+ return pngDrawPiece;
+ } else {
+ if (useImages)
+ return colorDrawPieceImage;
+ else
+ return colorDrawPiece;
+ }
+}
+
+void
+DoDrawDot (int marker, int x, int y, int r, cairo_surface_t *cs)
+{
+ cairo_t *cr;
+ DrawSeekOpen();
+ cr = cairo_create(cs);
+ cairo_arc(cr, x+r/2, y+r/2, r/2, 0.0, 2*M_PI);
+ if(appData.monoMode) {
+ SetPen(cr, 2, marker == 2 ? "#000000" : "#FFFFFF", 0);
+ cairo_stroke_preserve(cr);
+ SetPen(cr, 2, marker == 2 ? "#FFFFFF" : "#000000", 0);
+ } else {
+ SetPen(cr, 2, marker == 2 ? "#FF0000" : "#FFFF00", 0);
+ }
+ cairo_fill(cr);
+ cairo_stroke(cr);
+
+ cairo_destroy(cr);
+}
+
+void
+DrawDot (int marker, int x, int y, int r)
+{
+ DoDrawDot(marker, x, y, r, csBoardWindow);
+ DoDrawDot(marker, x, y, r, csBoardBackup);
+}
+
+void
+DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, char *string, int align)
+{ // basic front-end board-draw function: takes care of everything that can be in square:
+ // piece, background, coordinate/count, marker dot
+ int direction, font_ascent, font_descent;
+ XCharStruct overall;
+ DrawFunc drawfunc;
+
+ if (piece == EmptySquare) {
+ BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
+ } else {
+ drawfunc = ChooseDrawFunc();
+ drawfunc(piece, square_color, x, y, xBoardWindow);
+ }
+
+ if(align) { // square carries inscription (coord or piece count)
+ int xx = x, yy = y;
+ GC hGC = align < 3 ? coordGC : countGC;
+ // first calculate where it goes
+ XTextExtents(countFontStruct, string, 1, &direction,
+ &font_ascent, &font_descent, &overall);
+ if (align == 1) {
+ xx += squareSize - overall.width - 2;
+ yy += squareSize - font_descent - 1;
+ } else if (align == 2) {
+ xx += 2, yy += font_ascent + 1;
+ } else if (align == 3) {
+ xx += squareSize - overall.width - 2;
+ yy += font_ascent + 1;
+ } else if (align == 4) {
+ xx += 2, yy += font_ascent + 1;
+ }
+ // then draw it
+ if (appData.monoMode) {
+ XDrawImageString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
+ } else {
+ XDrawString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
+ }
+ }
+
+ if(marker) { // print fat marker dot, if requested
+ DrawDot(marker, x + squareSize/4, y+squareSize/4, squareSize/2);
+ }
+}
+
+void
+FlashDelay (int flash_delay)
+{
+ XSync(xDisplay, False);
+ if(flash_delay) do_flash_delay(flash_delay);
+}
+
+double
+Fraction (int x, int start, int stop)
+{
+ double f = ((double) x - start)/(stop - start);
+ if(f > 1.) f = 1.; else if(f < 0.) f = 0.;
+ return f;
+}
+
+static WindowPlacement wpNew;
+
+void
+CoDrag (Widget sh, WindowPlacement *wp)
+{
+ Arg args[16];
+ int j=0, touch=0, fudge = 2;
+ GetActualPlacement(sh, wp);
+ if(abs(wpMain.x + wpMain.width + 2*frameX - wp->x) < fudge) touch = 1; else // right touch
+ if(abs(wp->x + wp->width + 2*frameX - wpMain.x) < fudge) touch = 2; else // left touch
+ if(abs(wpMain.y + wpMain.height + frameX + frameY - wp->y) < fudge) touch = 3; else // bottom touch
+ if(abs(wp->y + wp->height + frameX + frameY - wpMain.y) < fudge) touch = 4; // top touch
+ if(!touch ) return; // only windows that touch co-move
+ if(touch < 3 && wpNew.height != wpMain.height) { // left or right and height changed
+ int heightInc = wpNew.height - wpMain.height;
+ double fracTop = Fraction(wp->y, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
+ double fracBot = Fraction(wp->y + wp->height + frameX + frameY + 1, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
+ wp->y += fracTop * heightInc;
+ heightInc = (int) (fracBot * heightInc) - (int) (fracTop * heightInc);
+ if(heightInc) XtSetArg(args[j], XtNheight, wp->height + heightInc), j++;
+ } else if(touch > 2 && wpNew.width != wpMain.width) { // top or bottom and width changed
+ int widthInc = wpNew.width - wpMain.width;
+ double fracLeft = Fraction(wp->x, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
+ double fracRght = Fraction(wp->x + wp->width + 2*frameX + 1, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
+ wp->y += fracLeft * widthInc;
+ widthInc = (int) (fracRght * widthInc) - (int) (fracLeft * widthInc);
+ if(widthInc) XtSetArg(args[j], XtNwidth, wp->width + widthInc), j++;
+ }
+ wp->x += wpNew.x - wpMain.x;
+ wp->y += wpNew.y - wpMain.y;
+ if(touch == 1) wp->x += wpNew.width - wpMain.width; else
+ if(touch == 3) wp->y += wpNew.height - wpMain.height;
+ XtSetArg(args[j], XtNx, wp->x); j++;
+ XtSetArg(args[j], XtNy, wp->y); j++;
+ XtSetValues(sh, args, j);
+}
+
+void
+ReSize (WindowPlacement *wp)
+{
+ int sqx, sqy;
+ if(wp->width == wpMain.width && wp->height == wpMain.height) return; // not sized
+ sqx = (wp->width - lineGap - marginW) / BOARD_WIDTH - lineGap;
+ sqy = (wp->height - lineGap - marginH) / BOARD_HEIGHT - lineGap;
+ if(sqy < sqx) sqx = sqy;
+ if(sqx != squareSize) {
+ squareSize = sqx; // adopt new square size
+ NewSurfaces();
+ CreatePNGPieces(); // make newly scaled pieces
+ InitDrawingSizes(0, 0); // creates grid etc.
+ }
+}
+
+static XtIntervalId delayedDragID = 0;
+
+void
+DragProc ()
+{
+ static int busy;
+ if(busy) return;
+
+ busy = 1;
+ GetActualPlacement(shellWidget, &wpNew);
+ if(wpNew.x == wpMain.x && wpNew.y == wpMain.y && // not moved
+ wpNew.width == wpMain.width && wpNew.height == wpMain.height) { // not sized
+ busy = 0; return; // false alarm
+ }
+ ReSize(&wpNew);
+ if(shellUp[EngOutDlg]) CoDrag(shells[EngOutDlg], &wpEngineOutput);
+ if(shellUp[HistoryDlg]) CoDrag(shells[HistoryDlg], &wpMoveHistory);
+ if(shellUp[EvalGraphDlg]) CoDrag(shells[EvalGraphDlg], &wpEvalGraph);
+ if(shellUp[GameListDlg]) CoDrag(shells[GameListDlg], &wpGameList);
+ wpMain = wpNew;
+ DrawPosition(True, NULL);
+ delayedDragID = 0; // now drag executed, make sure next DelayedDrag will not cancel timer event (which could now be used by other)
+ busy = 0;
+}
+
+
+void
+DelayedDrag ()
+{
+ if(delayedDragID) XtRemoveTimeOut(delayedDragID); // cancel pending
+ delayedDragID =
+ XtAppAddTimeOut(appContext, 100, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
+}
+
+void
+EventProc (Widget widget, caddr_t unused, XEvent *event)
+{
+ if(XtIsRealized(widget) && event->type == ConfigureNotify || appData.useStickyWindows)
+ DelayedDrag(); // as long as events keep coming in faster than 50 msec, they destroy each other
+}
+
+// [HGM] seekgraph: some low-level drawing routines (by JC, mostly)
+
+float
+Color (char *col, int n)
+{
+ int c;
+ sscanf(col, "#%x", &c);
+ c = c >> 4*n & 255;
+ return c/255.;
+}
+
+void
+SetPen (cairo_t *cr, float w, char *col, int dash)
+{
+ static const double dotted[] = {4.0, 4.0};
+ static int len = sizeof(dotted) / sizeof(dotted[0]);
+ cairo_set_line_width (cr, w);
+ cairo_set_source_rgba (cr, Color(col, 4), Color(col, 2), Color(col, 0), 1.0);
+ if(dash) cairo_set_dash (cr, dotted, len, 0.0);
+}
+
+void DrawSeekAxis( int x, int y, int xTo, int yTo )
+{
+ cairo_t *cr;
+
+ /* get a cairo_t */
+ cr = cairo_create (csBoardWindow);
+
+ cairo_move_to (cr, x, y);
+ cairo_line_to(cr, xTo, yTo );
+
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void DrawSeekBackground( int left, int top, int right, int bottom )
+{
+ cairo_t *cr = cairo_create (csBoardWindow);
+
+ cairo_rectangle (cr, left, top, right-left, bottom-top);
+
+ cairo_set_source_rgba(cr, 0.8, 0.8, 0.4,1.0);
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void DrawSeekText(char *buf, int x, int y)
+{
+ cairo_t *cr = cairo_create (csBoardWindow);
+
+ cairo_select_font_face (cr, "Sans",
+ CAIRO_FONT_SLANT_NORMAL,
+ CAIRO_FONT_WEIGHT_NORMAL);
+
+ cairo_set_font_size (cr, 12.0);
+
+ cairo_move_to (cr, x, y+4);
+ cairo_show_text( cr, buf);
+
+ cairo_set_source_rgba(cr, 0, 0, 0,1.0);
+ cairo_stroke(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void DrawSeekDot(int x, int y, int colorNr)
+{
+ cairo_t *cr = cairo_create (csBoardWindow);
+ int square = colorNr & 0x80;
+ colorNr &= 0x7F;
+
+ if(square)
+ cairo_rectangle (cr, x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
+ else
+ cairo_arc(cr, x, y, squareSize/8, 0.0, 2*M_PI);
+
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke_preserve(cr);
+ switch (colorNr) {
+ case 0: cairo_set_source_rgba(cr, 1.0, 0, 0,1.0); break;
+ case 1: cairo_set_source_rgba (cr, 0.0, 0.7, 0.2, 1.0); break;
+ default: cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 1.0); break;
+ }
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+}
+
+void
+DrawSeekOpen ()
+{
+ int boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ int boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ if(!csBoardWindow) {
+ csBoardWindow = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), boardWidth, boardHeight);
+ csBoardBackup = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, boardWidth, boardHeight);
+ }
+}
+
+void
+DrawSeekClose ()
+{
+}
+
+void
+DoDrawGrid(cairo_surface_t *cs)
+{
+ /* draws a grid starting around Nx, Ny squares starting at x,y */
+ int i;
+ cairo_t *cr;
+
+ DrawSeekOpen();
+ /* get a cairo_t */
+ cr = cairo_create (cs);
+
+ cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);
+ SetPen(cr, lineGap, "#000000", 0);
+
+ /* lines in X */
+ for (i = 0; i < BOARD_WIDTH + BOARD_HEIGHT + 2; i++)
+ {
+ cairo_move_to (cr, gridSegments[i].x1, gridSegments[i].y1);
+ cairo_line_to (cr, gridSegments[i].x2, gridSegments[i].y2);
+ cairo_stroke (cr);
+ }
+
+ /* free memory */
+ cairo_destroy (cr);
+
+ return;
+}
+
+void
+DrawGrid()
+{
+ DoDrawGrid(csBoardWindow);
+ DoDrawGrid(csBoardBackup);
+}
+
+/*
+ * event handler for redrawing the board
+ */
+void
+DrawPositionProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ DrawPosition(True, NULL);
+}
+
+
+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));
+}
+
+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 (int index, char *title, char *text)
+{
+ savedIndex = index;
+ if (text == NULL) text = "";
+ NewCommentPopup(title, text, index);
+}
+
+void
+CommentPopUp (char *title, char *text)
+{
+ savedIndex = currentMove; // [HGM] vari
+ NewCommentPopup(title, text, currentMove);
+}
+
+void
+CommentPopDown ()
+{
+ PopDown(CommentDlg);
+}
+
+
+/* Disable all user input other than deleting the window */
+static int frozen = 0;
+
+void
+FreezeUI ()
+{
+ if (frozen) return;
+ /* Grab by a widget that doesn't accept input */
+ XtAddGrab(optList[W_MESSG].handle, TRUE, FALSE);
+ frozen = 1;
+}
+
+/* Undo a FreezeUI */
+void
+ThawUI ()
+{
+ if (!frozen) return;
+ XtRemoveGrab(optList[W_MESSG].handle);
+ frozen = 0;
+}
+
+void
+ModeHighlight ()
+{
+ Arg args[16];
+ static int oldPausing = FALSE;
+ static GameMode oldmode = (GameMode) -1;
+ char *wname;
+
+ if (!boardWidget || !XtIsRealized(boardWidget)) return;
+
+ if (pausing != oldPausing) {
+ oldPausing = pausing;
+ MarkMenuItem("Mode.Pause", pausing);
+
+ if (appData.showButtonBar) {
+ /* Always toggle, don't set. Previous code messes up when
+ invoked while the button is pressed, as releasing it
+ toggles the state again. */
+ {
+ Pixel oldbg, oldfg;
+ XtSetArg(args[0], XtNbackground, &oldbg);
+ XtSetArg(args[1], XtNforeground, &oldfg);
+ XtGetValues(optList[W_PAUSE].handle,
+ args, 2);
+ XtSetArg(args[0], XtNbackground, oldfg);
+ XtSetArg(args[1], XtNforeground, oldbg);
+ }
+ XtSetValues(optList[W_PAUSE].handle, args, 2);
+ }
+ }
+
+ wname = ModeToWidgetName(oldmode);
+ if (wname != NULL) {
+ MarkMenuItem(wname, False);
+ }
+ wname = ModeToWidgetName(gameMode);
+ if (wname != NULL) {
+ MarkMenuItem(wname, True);
+ }
+ oldmode = gameMode;
+ MarkMenuItem("Mode.MachineMatch", matchMode && matchGame < appData.matchGames);
+
+ /* Maybe all the enables should be handled here, not just this one */
+ EnableNamedMenuItem("Mode.Training", gameMode == Training || gameMode == PlayFromGameFile);
+
+ DisplayLogos(optList[W_WHITE-1].handle, optList[W_BLACK+1].handle);
+}
+
+
+/*
+ * Button/menu procedures
+ */
+
+/* this variable is shared between CopyPositionProc and SendPositionSelection */
+char *selected_fen_position=NULL;
+
+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 || *target == XA_UTF8_STRING(xDisplay)){
+ if (!selected_fen_position) { // since it never happens, we use it for indicating a game is being sent
+ FILE* f = fopen(gameCopyFilename, "r"); // This code, taken from SendGameSelection, now merges the two
+ long len;
+ size_t count;
+ if (f == NULL) return False;
+ fseek(f, 0, 2);
+ len = ftell(f);
+ rewind(f);
+ selection_tmp = XtMalloc(len + 1);
+ count = fread(selection_tmp, 1, len, f);
+ fclose(f);
+ if (len != count) {
+ XtFree(selection_tmp);
+ return False;
+ }
+ selection_tmp[len] = NULLCHAR;
+ } else {
+ /* 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);
+ safeStrCpy(selection_tmp, selected_fen_position, strlen(selected_fen_position)+16 );
+ }
+
+ *value_return=selection_tmp;
+ *length_return=strlen(selection_tmp);
+ *type_return=*target;
+ *format_return = 8; /* bits per byte */
+ return True;
+ } else if (*target == XA_TARGETS(xDisplay)) {
+ Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
+ targets_tmp[0] = XA_UTF8_STRING(xDisplay);
+ targets_tmp[1] = XA_STRING;
+ *value_return = targets_tmp;
+ *type_return = XA_ATOM;
+ *length_return = 2;
+#if 0
+ // This code leads to a read of value_return out of bounds on 64-bit systems.
+ // Other code which I have seen always sets *format_return to 32 independent of
+ // sizeof(Atom) without adjusting *length_return. For instance see TextConvertSelection()
+ // at http://cgit.freedesktop.org/xorg/lib/libXaw/tree/src/Text.c -- BJ
+ *format_return = 8 * sizeof(Atom);
+ if (*format_return > 32) {
+ *length_return *= *format_return / 32;
+ *format_return = 32;
+ }
+#else
+ *format_return = 32;
+#endif
+ return True;
+ } else {
+ return False;
+ }
+}
+
+/* note: when called from menu all parameters are NULL, so no clue what the
+ * Widget which was clicked on was, or what the click event was
+ */
+void
+CopySomething (char *src)
+{
+ selected_fen_position = src;
+ /*
+ * 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
+ */
+ 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 */
+static void
+PastePositionCB (Widget w, XtPointer client_data, Atom *selection,
+ Atom *type, XtPointer value, unsigned long *len, int *format)
+{
+ char *fenstr=value;
+ if (value==NULL || *len==0) return; /* nothing had been selected to copy */
+ fenstr[*len]='\0'; /* normally this string is terminated, but be safe */
+ EditPositionPasteFEN(fenstr);
+ XtFree(value);
+}
+
+/* called when Paste Position button is pressed,
+ * all parameters will be NULL */
+void
+PastePositionProc ()
+{
+ XtGetSelectionValue(menuBarWidget,
+ appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+ /* (XtSelectionCallbackProc) */ PastePositionCB,
+ NULL, /* client_data passed to PastePositionCB */
+
+ /* better to use the time field from the event that triggered the
+ * call to this function, but that isn't trivial to get
+ */
+ CurrentTime
+ );
+ return;
+}
+
+/* note: when called from menu all parameters are NULL, so no clue what the
+ * Widget which was clicked on was, or what the click event was
+ */
+/* function called when the data to Paste is ready */
+static void
+PasteGameCB (Widget w, XtPointer client_data, Atom *selection,
+ Atom *type, XtPointer value, unsigned long *len, int *format)
+{
+ FILE* f;
+ if (value == NULL || *len == 0) {
+ return; /* nothing had been selected to copy */
+ }
+ f = fopen(gamePasteFilename, "w");
+ if (f == NULL) {
+ DisplayError(_("Can't open temp file"), errno);
+ return;
+ }
+ fwrite(value, 1, *len, f);
+ fclose(f);
+ XtFree(value);
+ LoadGameFromFile(gamePasteFilename, 0, gamePasteFilename, TRUE);
+}
+
+/* called when Paste Game button is pressed,
+ * all parameters will be NULL */
+void
+PasteGameProc ()
+{
+ XtGetSelectionValue(menuBarWidget,
+ appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
+ /* (XtSelectionCallbackProc) */ PasteGameCB,
+ NULL, /* client_data passed to PasteGameCB */
+
+ /* better to use the time field from the event that triggered the
+ * call to this function, but that isn't trivial to get
+ */
+ CurrentTime
+ );
+ return;
+}
+
+
+void
+QuitWrapper (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ QuitProc();
+}
+
+int
+ShiftKeys ()
+{ // bassic primitive for determining if modifier keys are pressed
+ long int codes[] = { XK_Meta_L, XK_Meta_R, XK_Control_L, XK_Control_R, XK_Shift_L, XK_Shift_R };
+ char keys[32];
+ int i,j, k=0;
+ XQueryKeymap(xDisplay,keys);
+ for(i=0; i<6; i++) {
+ k <<= 1;
+ j = XKeysymToKeycode(xDisplay, codes[i]);
+ k += ( (keys[j>>3]&1<<(j&7)) != 0 );
+ }
+ return k;
+}
+
+static void
+MoveTypeInProc (Widget widget, caddr_t unused, XEvent *event)
+{
+ char buf[10];
+ KeySym sym;
+ int n = XLookupString(&(event->xkey), buf, 10, &sym, NULL);
+ if ( n == 1 && *buf >= 32 // printable
+ && !(ShiftKeys() & 0x3C) // no Alt, Ctrl
+ ) BoxAutoPopUp (buf);
+}
+
+static void
+UpKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{ // [HGM] input: let up-arrow recall previous line from history
+ IcsKey(1);
+}
+
+static void
+DownKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{ // [HGM] input: let down-arrow recall next line from history
+ IcsKey(-1);
+}
+
+static void
+EnterKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ IcsKey(0);
+}
+
+void
+TempBackwardProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ if (!TempBackwardActive) {
+ TempBackwardActive = True;
+ BackwardEvent();
+ }
+}
+
+void
+TempForwardProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{
+ /* Check to see if triggered by a key release event for a repeating key.
+ * If so the next queued event will be a key press of the same key at the same time */
+ if (XEventsQueued(xDisplay, QueuedAfterReading)) {
+ XEvent next;
+ XPeekEvent(xDisplay, &next);
+ if (next.type == KeyPress && next.xkey.time == event->xkey.time &&
+ next.xkey.keycode == event->xkey.keycode)
+ return;
+ }
+ ForwardEvent();
+ TempBackwardActive = False;
+}
+
+void
+ManInner (Widget w, XEvent *event, String *prms, Cardinal *nprms)
+{ // called as key binding
+ char buf[MSG_SIZ];
+ String name;
+ if (nprms && *nprms > 0)
+ name = prms[0];
+ else
+ name = "xboard";
+ snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
+ system(buf);
+}
+
+void
+ManProc ()
+{ // called from menu
+ ManInner(NULL, NULL, NULL, NULL);
+}
+
+void
+SetWindowTitle (char *text, char *title, char *icon)
+{
+ Arg args[16];
+ int i;
+ if (appData.titleInWindow) {
+ i = 0;
+ XtSetArg(args[i], XtNlabel, text); i++;
+ XtSetValues(titleWidget, args, i);
+ }
+ i = 0;
+ XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
+ XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;
+ XtSetValues(shellWidget, args, i);
+ XSync(xDisplay, False);
+}
+
+
+static int
+NullXErrorCheck (Display *dpy, XErrorEvent *error_event)
+{
+ return 0;
+}
+
+void
+DisplayIcsInteractionTitle (String message)
+{
+ if (oldICSInteractionTitle == NULL) {
+ /* Magic to find the old window title, adapted from vim */
+ char *wina = getenv("WINDOWID");
+ if (wina != NULL) {
+ Window win = (Window) atoi(wina);
+ Window root, parent, *children;
+ unsigned int nchildren;
+ int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
+ for (;;) {
+ if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
+ if (!XQueryTree(xDisplay, win, &root, &parent,
+ &children, &nchildren)) break;
+ if (children) XFree((void *)children);
+ if (parent == root || parent == 0) break;
+ win = parent;
+ }
+ XSetErrorHandler(oldHandler);
+ }
+ if (oldICSInteractionTitle == NULL) {
+ oldICSInteractionTitle = "xterm";
+ }
+ }
+ printf("\033]0;%s\007", message);
+ fflush(stdout);
+}
+
+
+XtIntervalId delayedEventTimerXID = 0;
+DelayedEventCallback delayedEventCallback = 0;
+
+void
+FireDelayedEvent ()
+{
+ delayedEventTimerXID = 0;
+ delayedEventCallback();
+}
+
+void
+ScheduleDelayedEvent (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,
+ (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
+}
+
+DelayedEventCallback
+GetDelayedEvent ()
+{
+ if (delayedEventTimerXID) {
+ return delayedEventCallback;
+ } else {
+ return NULL;
+ }
+}
+
+void
+CancelDelayedEvent ()
+{
+ if (delayedEventTimerXID) {
+ XtRemoveTimeOut(delayedEventTimerXID);
+ delayedEventTimerXID = 0;
+ }
+}
+
+XtIntervalId loadGameTimerXID = 0;
+
+int
+LoadGameTimerRunning ()
+{
+ return loadGameTimerXID != 0;
+}
+
+int
+StopLoadGameTimer ()
+{
+ if (loadGameTimerXID != 0) {
+ XtRemoveTimeOut(loadGameTimerXID);
+ loadGameTimerXID = 0;
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+void
+LoadGameTimerCallback (XtPointer arg, XtIntervalId *id)
+{
+ loadGameTimerXID = 0;
+ AutoPlayGameLoop();
+}
+
+void
+StartLoadGameTimer (long millisec)
+{
+ loadGameTimerXID =
+ XtAppAddTimeOut(appContext, millisec,
+ (XtTimerCallbackProc) LoadGameTimerCallback,
+ (XtPointer) 0);
+}
+
+XtIntervalId analysisClockXID = 0;
+
+void
+AnalysisClockCallback (XtPointer arg, XtIntervalId *id)
+{
+ if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
+ || appData.icsEngineAnalyze) { // [DM]
+ AnalysisPeriodicEvent(0);
+ StartAnalysisClock();
+ }
+}
+
+void
+StartAnalysisClock ()
+{
+ analysisClockXID =
+ XtAppAddTimeOut(appContext, 2000,
+ (XtTimerCallbackProc) AnalysisClockCallback,
+ (XtPointer) 0);
+}
+
+XtIntervalId clockTimerXID = 0;
+
+int
+ClockTimerRunning ()
+{
+ return clockTimerXID != 0;
+}
+
+int
+StopClockTimer ()
+{
+ if (clockTimerXID != 0) {
+ XtRemoveTimeOut(clockTimerXID);
+ clockTimerXID = 0;
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+void
+ClockTimerCallback (XtPointer arg, XtIntervalId *id)
+{
+ clockTimerXID = 0;
+ DecrementClocks();
+}
+
+void
+StartClockTimer (long millisec)
+{
+ clockTimerXID =
+ XtAppAddTimeOut(appContext, millisec,
+ (XtTimerCallbackProc) ClockTimerCallback,
+ (XtPointer) 0);
+}
+
+void
+DisplayTimerLabel (Option *opt, char *color, long timer, int highlight)
+{
+ char buf[MSG_SIZ];
+ Arg args[16];
+ Widget w = (Widget) opt->handle;
+
+ /* check for low time warning */
+ Pixel foregroundOrWarningColor = timerForegroundPixel;
+
+ if (timer > 0 &&
+ appData.lowTimeWarning &&
+ (timer / 1000) < appData.icsAlarmTime)
+ foregroundOrWarningColor = lowTimeWarningColor;
+
+ if (appData.clockMode) {
+ snprintf(buf, MSG_SIZ, "%s:%s%s", color, appData.logoSize && !partnerUp ? "\n" : " ", TimeString(timer));
+ XtSetArg(args[0], XtNlabel, buf);
+ } else {
+ snprintf(buf, MSG_SIZ, "%s ", color);
+ XtSetArg(args[0], XtNlabel, buf);
+ }
+
+ if (highlight) {
+
+ XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
+ XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
+ } else {
+ XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
+ XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
+ }
+
+ XtSetValues(w, args, 3);
+}
+
+static Pixmap *clockIcons[] = { &wIconPixmap, &bIconPixmap };
+
+void
+SetClockIcon (int color)
+{
+ Arg args[16];
+ Pixmap pm = *clockIcons[color];
+ if (iconPixmap != pm) {
+ iconPixmap = pm;
+ XtSetArg(args[0], XtNiconPixmap, iconPixmap);
+ XtSetValues(shellWidget, args, 1);
+ }
+}
+
+void
+DoInputCallback (caddr_t closure, int *source, XtInputId *xid)
+{
+ InputSource *is = (InputSource *) closure;
+ int count;
+ int error;
+ char *p, *q;
+
+ if (is->lineByLine) {
+ count = read(is->fd, is->unused,
+ INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
+ if (count <= 0) {
+ (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
+ return;
+ }
+ is->unused += count;
+ p = is->buf;
+ while (p < is->unused) {
+ q = memchr(p, '\n', is->unused - p);
+ if (q == NULL) break;
+ q++;
+ (is->func)(is, is->closure, p, q - p, 0);
+ p = q;
+ }
+ q = is->buf;
+ while (p < is->unused) {
+ *q++ = *p++;
+ }
+ is->unused = q;
+ } else {
+ count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
+ if (count == -1)
+ error = errno;
+ else
+ error = 0;
+ (is->func)(is, is->closure, is->buf, count, error);
+ }
+}
+
+InputSourceRef
+AddInputSource (ProcRef pr, int lineByLine, InputCallback func, VOIDSTAR closure)
+{
+ InputSource *is;
+ ChildProc *cp = (ChildProc *) pr;
+
+ is = (InputSource *) calloc(1, sizeof(InputSource));
+ is->lineByLine = lineByLine;
+ is->func = func;
+ if (pr == NoProc) {
+ is->kind = CPReal;
+ is->fd = fileno(stdin);
+ } else {
+ is->kind = cp->kind;
+ is->fd = cp->fdFrom;
+ }
+ if (lineByLine) {
+ is->unused = is->buf;
+ }
+
+ is->xid = XtAppAddInput(appContext, is->fd,
+ (XtPointer) (XtInputReadMask),
+ (XtInputCallbackProc) DoInputCallback,
+ (XtPointer) is);
+ is->closure = closure;
+ return (InputSourceRef) is;
+}
+
+void
+RemoveInputSource (InputSourceRef isr)
+{
+ InputSource *is = (InputSource *) isr;
+
+ if (is->xid == 0) return;
+ XtRemoveInput(is->xid);
+ is->xid = 0;
+}
+
+/**** Animation code by Hugh Fisher, DCS, ANU. ****/
+
+/* Masks for XPM pieces. Black and white pieces can have
+ different shapes, but in the interest of retaining my
+ sanity pieces must have the same outline on both light
+ and dark squares, and all pieces must use the same
+ background square colors/images. */
+
+static int xpmDone = 0;
+static Pixmap animBufs[3*NrOfAnims]; // newBuf, saveBuf
+static GC animGCs[3*NrOfAnims]; // blitGC, pieceGC, outlineGC;
+static cairo_surface_t *c_animBufs[3*NrOfAnims]; // newBuf, saveBuf
+
+static void
+CreateAnimMasks (int pieceDepth)
+{
+ ChessSquare piece;
+ Pixmap buf;
+ GC bufGC, maskGC;
+ int kind, n;
+ unsigned long plane;
+ XGCValues values;
+
+ /* Need a bitmap just to get a GC with right depth */
+ buf = XCreatePixmap(xDisplay, xBoardWindow,
+ 8, 8, 1);
+ values.foreground = 1;
+ values.background = 0;
+ /* Don't use XtGetGC, not read only */
+ maskGC = XCreateGC(xDisplay, buf,
+ GCForeground | GCBackground, &values);
+ XFreePixmap(xDisplay, buf);
+
+ buf = XCreatePixmap(xDisplay, xBoardWindow,
+ squareSize, squareSize, pieceDepth);
+ values.foreground = XBlackPixel(xDisplay, xScreen);
+ values.background = XWhitePixel(xDisplay, xScreen);
+ bufGC = XCreateGC(xDisplay, buf,
+ GCForeground | GCBackground, &values);
+
+ 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) % (int)BlackPawn],
+ buf, bufGC,
+ 0, 0, squareSize, squareSize, 0, 0);
+
+ /* XOR the background (light) over the piece */
+ XSetFunction(xDisplay, bufGC, GXxor);
+ if (useImageSqs)
+ XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
+ 0, 0, squareSize, squareSize, 0, 0);
+ else {
+ XSetForeground(xDisplay, bufGC, lightSquareColor);
+ XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
+ }
+
+ /* We now have an inverted piece image with the background
+ erased. Construct mask by just selecting all the non-zero
+ pixels - no need to reconstruct the original image. */
+ XSetFunction(xDisplay, maskGC, GXor);
+ plane = 1;
+ /* Might be quicker to download an XImage and create bitmap
+ data from it rather than this N copies per piece, but it
+ only takes a fraction of a second and there is a much
+ longer delay for loading the pieces. */
+ for (n = 0; n < pieceDepth; n ++) {
+ XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
+ 0, 0, squareSize, squareSize,
+ 0, 0, plane);
+ plane = plane << 1;
+ }
+ }
+ /* Clean up */
+ XFreePixmap(xDisplay, buf);
+ XFreeGC(xDisplay, bufGC);
+ XFreeGC(xDisplay, maskGC);
+}
+
+static void
+InitAnimState (AnimNr anr, XWindowAttributes *info)
+{
+ XtGCMask mask;
+ XGCValues values;
+
+ if(cairoAnimate) {
+ DrawSeekOpen(); // set cs to board widget
+ if(c_animBufs[anr]) cairo_surface_destroy (c_animBufs[anr]);
+ if(c_animBufs[anr+2]) cairo_surface_destroy (c_animBufs[anr+2]);
+ c_animBufs[anr+4] = csBoardWindow;
+ c_animBufs[anr+2] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ c_animBufs[anr] = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, squareSize, squareSize);
+ }
+
+ /* Each buffer is square size, same depth as window */
+ animBufs[anr+4] = xBoardWindow;
+ animBufs[anr+2] = XCreatePixmap(xDisplay, xBoardWindow,
+ squareSize, squareSize, info->depth);
+ animBufs[anr] = XCreatePixmap(xDisplay, xBoardWindow,
+ squareSize, squareSize, info->depth);
+
+ /* Create a plain GC for blitting */
+ mask = GCForeground | GCBackground | GCFunction |
+ GCPlaneMask | GCGraphicsExposures;
+ values.foreground = XBlackPixel(xDisplay, xScreen);
+ values.background = XWhitePixel(xDisplay, xScreen);
+ values.function = GXcopy;
+ values.plane_mask = AllPlanes;
+ values.graphics_exposures = False;
+ animGCs[anr] = XCreateGC(xDisplay, xBoardWindow, mask, &values);
+
+ /* Piece will be copied from an existing context at
+ the start of each new animation/drag. */
+ animGCs[anr+2] = XCreateGC(xDisplay, xBoardWindow, 0, &values);
+
+ /* Outline will be a read-only copy of an existing */
+ animGCs[anr+4] = None;
+}
+
+void
+CreateAnimVars ()
+{
+ XWindowAttributes info;
+
+ if (!cairoAnimate && xpmDone && gameInfo.variant == oldVariant) return;
+ if(xpmDone) oldVariant = 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 & !xpmDone)
+ CreateAnimMasks(info.depth), xpmDone = 1;
+}
+
+#ifndef HAVE_USLEEP
+
+static Boolean frameWaiting;
+
+static RETSIGTYPE
+FrameAlarm (int sig)
+{
+ frameWaiting = False;
+ /* In case System-V style signals. Needed?? */
+ signal(SIGALRM, FrameAlarm);
+}
+
+void
+FrameDelay (int time)
+{
+ struct itimerval delay;
+
+ XSync(xDisplay, False);
+
+ if (time > 0) {
+ frameWaiting = True;
+ signal(SIGALRM, FrameAlarm);
+ delay.it_interval.tv_sec =
+ delay.it_value.tv_sec = time / 1000;
+ delay.it_interval.tv_usec =
+ delay.it_value.tv_usec = (time % 1000) * 1000;
+ setitimer(ITIMER_REAL, &delay, NULL);
+ while (frameWaiting) pause();
+ 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);
+ }
+}
+
+#else
+
+void
+FrameDelay (int time)
+{
+ XSync(xDisplay, False);
+ if (time > 0)
+ usleep(time * 1000);
+}
+
+#endif
+
+static void
+SelectGCMask (ChessSquare piece, GC *clip, GC *outline, Pixmap *mask)
+{
+ GC source;
+
+ /* Bitmap for piece being moved. */
+ if (appData.monoMode) {
+ *mask = *pieceToSolid(piece);
+ } else if (useImages) {
+#if HAVE_LIBXPM
+ *mask = xpmMask[piece];
+#else
+ *mask = ximMaskPm[piece];
+#endif
+ } else {
+ *mask = *pieceToSolid(piece);
+ }
+
+ /* GC for piece being moved. Square color doesn't matter, but
+ since it gets modified we make a copy of the original. */
+ if (White(piece)) {
+ if (appData.monoMode)
+ source = bwPieceGC;
+ else
+ source = wlPieceGC;
+ } else {
+ if (appData.monoMode)
+ source = wbPieceGC;
+ else
+ source = blPieceGC;
+ }
+ XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
+
+ /* Outline only used in mono mode and is not modified */
+ if (White(piece))
+ *outline = bwPieceGC;
+ else
+ *outline = wbPieceGC;
+}
+
+static void
+OverlayPiece (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,
+ 0, 0, squareSize, squareSize);
+ if (appData.monoMode)
+ /* Also draw outline in contrasting color for black
+ on black / white on white cases */
+ XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
+ 0, 0, squareSize, squareSize, 0, 0, 1);
+ } else {
+ /* Copy the piece */
+ if (White(piece))
+ kind = 0;
+ else
+ kind = 2;
+ if(appData.upsideDown && flipView) kind ^= 2;
+ XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
+ dest, clip,
+ 0, 0, squareSize, squareSize,
+ 0, 0);
+ }
+}
+
+static void
+CairoOverlayPiece (ChessSquare piece, cairo_surface_t *dest)
+{
+ static ChessSquare oldPiece = -1;
+ static int oldSize;
+ static cairo_t *pieceSource;
+ if(piece != oldPiece || squareSize != oldSize) { // try make it faster by only changing cr if we need other piece
+ if(pieceSource) cairo_destroy (pieceSource);
+ pieceSource = cairo_create (dest);
+ cairo_set_source_surface (pieceSource, pngPieceBitmaps[!White(piece)][piece % BlackPawn], 0, 0);
+ oldPiece = piece; oldSize = squareSize;
+ }
+ cairo_paint(pieceSource);
+}
+
+void
+InsertPiece (AnimNr anr, ChessSquare piece)
+{
+ if(cairoAnimate) {
+ CairoOverlayPiece(piece, c_animBufs[anr]);
+ } else
+ OverlayPiece(piece, animGCs[anr+2], animGCs[anr+4], animBufs[anr]);
+}
+
+void
+DrawBlank (AnimNr anr, int x, int y, int startColor)
+{
+ if(cairoAnimate)
+ BlankSquare(x, y, startColor, EmptySquare, (Drawable) c_animBufs[anr+2], 0);
+ else
+ BlankSquare(x, y, startColor, EmptySquare, animBufs[anr+2], 0);
+}
+
+void CopyRectangle (AnimNr anr, int srcBuf, int destBuf,
+ int srcX, int srcY, int width, int height, int destX, int destY)
+{
+ if(cairoAnimate) {
+ cairo_t *cr;// = cairo_create (c_animBufs[anr+destBuf]);
+ cr = cairo_create (c_animBufs[anr+destBuf]);
+ if(c_animBufs[anr+srcBuf] == csBoardWindow)
+ cairo_set_source_surface (cr, csBoardBackup, destX - srcX, destY - srcY);
+ else
+ cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+ cairo_rectangle (cr, destX, destY, width, height);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ if(c_animBufs[anr+destBuf] == csBoardWindow) {
+ cr = cairo_create (csBoardBackup); // also draw to backup
+ cairo_set_source_surface (cr, c_animBufs[anr+srcBuf], destX - srcX, destY - srcY);
+ cairo_rectangle (cr, destX, destY, width, height);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+ }
+ } else
+ XCopyArea(xDisplay, animBufs[anr+srcBuf], animBufs[anr+destBuf], animGCs[anr],
+ srcX, srcY, width, height, destX, destY);
+}
+
+void
+SetDragPiece (AnimNr anr, ChessSquare piece)
+{
+ Pixmap mask;
+ if(cairoAnimate) return;
+ /* The piece will be drawn using its own bitmap as a matte */
+ SelectGCMask(piece, &animGCs[anr+2], &animGCs[anr+4], &mask);
+ XSetClipMask(xDisplay, animGCs[anr+2], mask);
+}
+
+/* [AS] Arrow highlighting support */
+
+void DrawPolygon(Pnt arrow[], int nr)
+{ // for now on own surface; eventually this should become a global that is only destroyed on resize
+ cairo_surface_t *boardSurface;
+ cairo_t *cr;
+ int i;
+ int w = lineGap + BOARD_WIDTH * (squareSize + lineGap);
+ int h = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
+ boardSurface = cairo_xlib_surface_create(xDisplay, xBoardWindow, DefaultVisual(xDisplay, 0), w, h);
+ cr = cairo_create (boardSurface);
+ cairo_move_to (cr, arrow[nr-1].x, arrow[nr-1].y);
+ for (i=0;i<nr;i++) {
+ cairo_line_to(cr, arrow[i].x, arrow[i].y);
+ }
+ if(appData.monoMode) { // should we always outline arrow?
+ cairo_line_to(cr, arrow[0].x, arrow[0].y);
+ SetPen(cr, 2, "#000000", 0);
+ cairo_stroke_preserve(cr);
+ }
+ SetPen(cr, 2, appData.highlightSquareColor, 0);
+ cairo_fill(cr);
+
+ /* free memory */
+ cairo_destroy (cr);
+ cairo_surface_destroy (boardSurface);
+}
+
+static void
+LoadLogo (ChessProgramState *cps, int n, Boolean ics)
+{
+ char buf[MSG_SIZ], *logoName = buf;
+ if(appData.logo[n][0]) {
+ logoName = appData.logo[n];
+ } else if(appData.autoLogo) {
+ if(ics) { // [HGM] logo: in ICS mode second can be used for ICS
+ sprintf(buf, "%s/%s.png", appData.logoDir, appData.icsHost);
+ } else if(appData.directory[n] && appData.directory[n][0]) {
+ sprintf(buf, "%s/%s.png", appData.logoDir, cps->tidy);
+ }
+ }
+ if(logoName[0])
+ { ASSIGN(cps->programLogo, logoName); }
+}
+
+void
+UpdateLogos (int displ)
+{
+ if(optList[W_WHITE-1].handle == NULL) return;
+ LoadLogo(&first, 0, 0);
+ LoadLogo(&second, 1, appData.icsActive);
+ if(displ) DisplayLogos(optList[W_WHITE-1].handle, optList[W_BLACK+1].handle);
+ return;
+}
+