2 * xboard.c -- X front end for XBoard
4 * Copyright 1991 by Digital Equipment Corporation, Maynard,
7 * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
8 * 2007, 2008, 2009 Free Software Foundation, Inc.
10 * The following terms apply to Digital Equipment Corporation's copyright
12 * ------------------------------------------------------------------------
15 * Permission to use, copy, modify, and distribute this software and its
16 * documentation for any purpose and without fee is hereby granted,
17 * provided that the above copyright notice appear in all copies and that
18 * both that copyright notice and this permission notice appear in
19 * supporting documentation, and that the name of Digital not be
20 * used in advertising or publicity pertaining to distribution of the
21 * software without specific, written prior permission.
23 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
30 * ------------------------------------------------------------------------
32 * The following terms apply to the enhanced version of XBoard
33 * distributed by the Free Software Foundation:
34 * ------------------------------------------------------------------------
36 * GNU XBoard is free software: you can redistribute it and/or modify
37 * it under the terms of the GNU General Public License as published by
38 * the Free Software Foundation, either version 3 of the License, or (at
39 * your option) any later version.
41 * GNU XBoard is distributed in the hope that it will be useful, but
42 * WITHOUT ANY WARRANTY; without even the implied warranty of
43 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44 * General Public License for more details.
46 * You should have received a copy of the GNU General Public License
47 * along with this program. If not, see http://www.gnu.org/licenses/. *
49 *------------------------------------------------------------------------
50 ** See the file ChangeLog for a revision history. */
58 #include <sys/types.h>
63 # if HAVE_SYS_SOCKET_H
64 # include <sys/socket.h>
65 # include <netinet/in.h>
67 # else /* not HAVE_SYS_SOCKET_H */
68 # if HAVE_LAN_SOCKET_H
69 # include <lan/socket.h>
71 # include <lan/netdb.h>
72 # else /* not HAVE_LAN_SOCKET_H */
73 # define OMIT_SOCKETS 1
74 # endif /* not HAVE_LAN_SOCKET_H */
75 # endif /* not HAVE_SYS_SOCKET_H */
76 #endif /* !OMIT_SOCKETS */
81 #else /* not STDC_HEADERS */
82 extern char *getenv();
85 # else /* not HAVE_STRING_H */
87 # endif /* not HAVE_STRING_H */
88 #endif /* not STDC_HEADERS */
91 # include <sys/fcntl.h>
92 #else /* not HAVE_SYS_FCNTL_H */
95 # endif /* HAVE_FCNTL_H */
96 #endif /* not HAVE_SYS_FCNTL_H */
98 #if HAVE_SYS_SYSTEMINFO_H
99 # include <sys/systeminfo.h>
100 #endif /* HAVE_SYS_SYSTEMINFO_H */
102 #if TIME_WITH_SYS_TIME
103 # include <sys/time.h>
107 # include <sys/time.h>
118 # include <sys/wait.h>
123 # define NAMLEN(dirent) strlen((dirent)->d_name)
124 # define HAVE_DIR_STRUCT
126 # define dirent direct
127 # define NAMLEN(dirent) (dirent)->d_namlen
129 # include <sys/ndir.h>
130 # define HAVE_DIR_STRUCT
133 # include <sys/dir.h>
134 # define HAVE_DIR_STRUCT
138 # define HAVE_DIR_STRUCT
142 #include <X11/Intrinsic.h>
143 #include <X11/StringDefs.h>
144 #include <X11/Shell.h>
145 #include <X11/cursorfont.h>
146 #include <X11/Xatom.h>
147 #include <X11/Xmu/Atoms.h>
149 #include <X11/Xaw3d/Dialog.h>
150 #include <X11/Xaw3d/Form.h>
151 #include <X11/Xaw3d/List.h>
152 #include <X11/Xaw3d/Label.h>
153 #include <X11/Xaw3d/SimpleMenu.h>
154 #include <X11/Xaw3d/SmeBSB.h>
155 #include <X11/Xaw3d/SmeLine.h>
156 #include <X11/Xaw3d/Box.h>
157 #include <X11/Xaw3d/MenuButton.h>
158 #include <X11/Xaw3d/Text.h>
159 #include <X11/Xaw3d/AsciiText.h>
161 #include <X11/Xaw/Dialog.h>
162 #include <X11/Xaw/Form.h>
163 #include <X11/Xaw/List.h>
164 #include <X11/Xaw/Label.h>
165 #include <X11/Xaw/SimpleMenu.h>
166 #include <X11/Xaw/SmeBSB.h>
167 #include <X11/Xaw/SmeLine.h>
168 #include <X11/Xaw/Box.h>
169 #include <X11/Xaw/MenuButton.h>
170 #include <X11/Xaw/Text.h>
171 #include <X11/Xaw/AsciiText.h>
174 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
179 #include "pixmaps/pixmaps.h"
180 #define IMAGE_EXT "xpm"
182 #define IMAGE_EXT "xim"
183 #include "bitmaps/bitmaps.h"
186 #include "bitmaps/icon_white.bm"
187 #include "bitmaps/icon_black.bm"
188 #include "bitmaps/checkmark.bm"
190 #include "frontend.h"
195 #include "xgamelist.h"
196 #include "xhistory.h"
197 #include "xedittags.h"
200 // must be moved to xengineoutput.h
202 void EngineOutputProc P((Widget w, XEvent *event,
203 String *prms, Cardinal *nprms));
205 void EngineOutputPopDown();
212 #define usleep(t) _sleep2(((t)+500)/1000)
216 # define _(s) gettext (s)
217 # define N_(s) gettext_noop (s)
233 int main P((int argc, char **argv));
234 RETSIGTYPE CmailSigHandler P((int sig));
235 RETSIGTYPE IntSigHandler P((int sig));
236 RETSIGTYPE TermSizeSigHandler P((int sig));
237 void CreateGCs P((void));
238 void CreateXIMPieces P((void));
239 void CreateXPMPieces P((void));
240 void CreatePieces P((void));
241 void CreatePieceMenus P((void));
242 Widget CreateMenuBar P((Menu *mb));
243 Widget CreateButtonBar P ((MenuItem *mi));
244 char *FindFont P((char *pattern, int targetPxlSize));
245 void PieceMenuPopup P((Widget w, XEvent *event,
246 String *params, Cardinal *num_params));
247 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
248 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
249 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
250 u_int wreq, u_int hreq));
251 void CreateGrid P((void));
252 int EventToSquare P((int x, int limit));
253 void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
254 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
255 void HandleUserMove P((Widget w, XEvent *event,
256 String *prms, Cardinal *nprms));
257 void AnimateUserMove P((Widget w, XEvent * event,
258 String * params, Cardinal * nParams));
259 void WhiteClock P((Widget w, XEvent *event,
260 String *prms, Cardinal *nprms));
261 void BlackClock P((Widget w, XEvent *event,
262 String *prms, Cardinal *nprms));
263 void DrawPositionProc P((Widget w, XEvent *event,
264 String *prms, Cardinal *nprms));
265 void XDrawPosition P((Widget w, /*Boolean*/int repaint,
267 void CommentPopUp P((char *title, char *label));
268 void CommentPopDown P((void));
269 void CommentCallback P((Widget w, XtPointer client_data,
270 XtPointer call_data));
271 void ICSInputBoxPopUp P((void));
272 void ICSInputBoxPopDown P((void));
273 void FileNamePopUp P((char *label, char *def,
274 FileProc proc, char *openMode));
275 void FileNamePopDown P((void));
276 void FileNameCallback P((Widget w, XtPointer client_data,
277 XtPointer call_data));
278 void FileNameAction P((Widget w, XEvent *event,
279 String *prms, Cardinal *nprms));
280 void AskQuestionReplyAction P((Widget w, XEvent *event,
281 String *prms, Cardinal *nprms));
282 void AskQuestionProc P((Widget w, XEvent *event,
283 String *prms, Cardinal *nprms));
284 void AskQuestionPopDown P((void));
285 void PromotionPopDown P((void));
286 void PromotionCallback P((Widget w, XtPointer client_data,
287 XtPointer call_data));
288 void EditCommentPopDown P((void));
289 void EditCommentCallback P((Widget w, XtPointer client_data,
290 XtPointer call_data));
291 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
292 void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
293 void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
294 void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
296 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
298 void ReloadGameProc P((Widget w, XEvent *event, String *prms,
300 void LoadPositionProc P((Widget w, XEvent *event,
301 String *prms, Cardinal *nprms));
302 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
304 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
306 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
308 void CopyPositionProc P((Widget w, XEvent *event, String *prms,
310 void PastePositionProc P((Widget w, XEvent *event, String *prms,
312 void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
313 void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
314 void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
315 void SavePositionProc P((Widget w, XEvent *event,
316 String *prms, Cardinal *nprms));
317 void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
318 void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
320 void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
321 void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
322 void MachineBlackProc P((Widget w, XEvent *event, String *prms,
324 void MachineWhiteProc P((Widget w, XEvent *event,
325 String *prms, Cardinal *nprms));
326 void AnalyzeModeProc P((Widget w, XEvent *event,
327 String *prms, Cardinal *nprms));
328 void AnalyzeFileProc P((Widget w, XEvent *event,
329 String *prms, Cardinal *nprms));
330 void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
332 void IcsClientProc P((Widget w, XEvent *event, String *prms,
334 void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
335 void EditPositionProc P((Widget w, XEvent *event,
336 String *prms, Cardinal *nprms));
337 void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
338 void EditCommentProc P((Widget w, XEvent *event,
339 String *prms, Cardinal *nprms));
340 void IcsInputBoxProc P((Widget w, XEvent *event,
341 String *prms, Cardinal *nprms));
342 void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
343 void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
344 void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
345 void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
346 void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
347 void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
348 void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
349 void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
350 void AdjuWhiteProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
351 void AdjuBlackProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
352 void AdjuDrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
353 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
354 void StopObservingProc P((Widget w, XEvent *event, String *prms,
356 void StopExaminingProc P((Widget w, XEvent *event, String *prms,
358 void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
359 void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
360 void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
361 void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
362 void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
363 void TruncateGameProc P((Widget w, XEvent *event, String *prms,
365 void RetractMoveProc P((Widget w, XEvent *event, String *prms,
367 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
368 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
370 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
372 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
374 void AutocommProc P((Widget w, XEvent *event, String *prms,
376 void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
377 void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
378 void AutobsProc P((Widget w, XEvent *event, String *prms,
380 void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
381 void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
382 void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
383 void FlashMovesProc P((Widget w, XEvent *event, String *prms,
385 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
386 void GetMoveListProc P((Widget w, XEvent *event, String *prms,
388 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
390 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
392 void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
393 void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
394 void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
396 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
398 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
400 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
402 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
404 void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
405 void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
406 void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
408 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
410 void HideThinkingProc P((Widget w, XEvent *event, String *prms,
412 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
414 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
415 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
416 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
417 void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
418 void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
419 void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
420 void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
421 void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
422 void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
423 void DisplayMove P((int moveNumber));
424 void DisplayTitle P((char *title));
425 void ICSInitScript P((void));
426 int LoadGamePopUp P((FILE *f, int gameNumber, char *title));
427 void ErrorPopUp P((char *title, char *text, int modal));
428 void ErrorPopDown P((void));
429 static char *ExpandPathName P((char *path));
430 static void CreateAnimVars P((void));
431 static void DragPieceMove P((int x, int y));
432 static void DrawDragPiece P((void));
433 char *ModeToWidgetName P((GameMode mode));
434 void EngineOutputUpdate( FrontEndProgramStats * stats );
435 void ShuffleMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
436 void EngineMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
437 void UciMenuProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
438 void TimeControlProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
439 void NewVariantProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
440 void FirstSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
441 void SecondSettingsProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
442 void ShufflePopDown P(());
443 void EnginePopDown P(());
444 void UciPopDown P(());
445 void TimeControlPopDown P(());
446 void NewVariantPopDown P(());
447 void SettingsPopDown P(());
448 void update_ics_width P(());
449 int get_term_width P(());
451 * XBoard depends on Xt R4 or higher
453 int xtVersion = XtSpecificationRelease;
458 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
459 jailSquareColor, highlightSquareColor, premoveHighlightColor;
460 Pixel lowTimeWarningColor;
461 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
462 bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
463 wjPieceGC, bjPieceGC, prelineGC, countGC;
464 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
465 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
466 whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
467 commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
468 menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
469 ICSInputShell, fileNameShell, askQuestionShell;
470 XSegment gridSegments[(BOARD_SIZE + 1) * 2];
471 XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
472 Font clockFontID, coordFontID, countFontID;
473 XFontStruct *clockFontStruct, *coordFontStruct, *countFontStruct;
474 XtAppContext appContext;
476 char *oldICSInteractionTitle;
480 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
482 Position commentX = -1, commentY = -1;
483 Dimension commentW, commentH;
485 int squareSize, smallLayout = 0, tinyLayout = 0,
486 marginW, marginH, // [HGM] for run-time resizing
487 fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
488 ICSInputBoxUp = False, askQuestionUp = False,
489 filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
490 editUp = False, errorUp = False, errorExitStatus = -1, lineGap;
491 Pixel timerForegroundPixel, timerBackgroundPixel;
492 Pixel buttonForegroundPixel, buttonBackgroundPixel;
493 char *chessDir, *programName, *programVersion,
494 *gameCopyFilename, *gamePasteFilename;
498 Pixmap pieceBitmap[2][(int)BlackPawn];
499 Pixmap pieceBitmap2[2][(int)BlackPawn+4]; /* [HGM] pieces */
500 Pixmap xpmPieceBitmap[4][(int)BlackPawn]; /* LL, LD, DL, DD actually used*/
501 Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4]; /* LL, LD, DL, DD set to select from */
502 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
503 int useImages, useImageSqs;
504 XImage *ximPieceBitmap[4][(int)BlackPawn+4]; /* LL, LD, DL, DD */
505 Pixmap ximMaskPm[(int)BlackPawn]; /* clipmasks, used for XIM pieces */
506 Pixmap ximMaskPm2[(int)BlackPawn+4]; /* clipmasks, used for XIM pieces */
507 XImage *ximLightSquare, *ximDarkSquare;
510 #define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
511 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
513 #define White(piece) ((int)(piece) < (int)BlackPawn)
515 /* Variables for doing smooth animation. This whole thing
516 would be much easier if the board was double-buffered,
517 but that would require a fairly major rewrite. */
522 GC blitGC, pieceGC, outlineGC;
523 XPoint startSquare, prevFrame, mouseDelta;
527 int startBoardX, startBoardY;
530 /* There can be two pieces being animated at once: a player
531 can begin dragging a piece before the remote opponent has moved. */
533 static AnimState game, player;
535 /* Bitmaps for use as masks when drawing XPM pieces.
536 Need one for each black and white piece. */
537 static Pixmap xpmMask[BlackKing + 1];
539 /* This magic number is the number of intermediate frames used
540 in each half of the animation. For short moves it's reduced
541 by 1. The total number of frames will be factor * 2 + 1. */
544 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
546 MenuItem fileMenu[] = {
547 {N_("New Game"), ResetProc},
548 {N_("New Shuffle Game ..."), ShuffleMenuProc},
549 {N_("New Variant ..."), NewVariantProc}, // [HGM] variant: not functional yet
550 {"----", NothingProc},
551 {N_("Load Game"), LoadGameProc},
552 {N_("Load Next Game"), LoadNextGameProc},
553 {N_("Load Previous Game"), LoadPrevGameProc},
554 {N_("Reload Same Game"), ReloadGameProc},
555 {N_("Save Game"), SaveGameProc},
556 {"----", NothingProc},
557 {N_("Copy Game"), CopyGameProc},
558 {N_("Paste Game"), PasteGameProc},
559 {"----", NothingProc},
560 {N_("Load Position"), LoadPositionProc},
561 {N_("Load Next Position"), LoadNextPositionProc},
562 {N_("Load Previous Position"), LoadPrevPositionProc},
563 {N_("Reload Same Position"), ReloadPositionProc},
564 {N_("Save Position"), SavePositionProc},
565 {"----", NothingProc},
566 {N_("Copy Position"), CopyPositionProc},
567 {N_("Paste Position"), PastePositionProc},
568 {"----", NothingProc},
569 {N_("Mail Move"), MailMoveProc},
570 {N_("Reload CMail Message"), ReloadCmailMsgProc},
571 {"----", NothingProc},
572 {N_("Exit"), QuitProc},
576 MenuItem modeMenu[] = {
577 {N_("Machine White"), MachineWhiteProc},
578 {N_("Machine Black"), MachineBlackProc},
579 {N_("Two Machines"), TwoMachinesProc},
580 {N_("Analysis Mode"), AnalyzeModeProc},
581 {N_("Analyze File"), AnalyzeFileProc },
582 {N_("ICS Client"), IcsClientProc},
583 {N_("Edit Game"), EditGameProc},
584 {N_("Edit Position"), EditPositionProc},
585 {N_("Training"), TrainingProc},
586 {"----", NothingProc},
587 {N_("Show Engine Output"), EngineOutputProc},
588 {N_("Show Evaluation Graph"), NothingProc}, // [HGM] evalgr: not functional yet
589 {N_("Show Game List"), ShowGameListProc},
590 {"Show Move History", HistoryShowProc}, // [HGM] hist: activate 4.2.7 code
591 {"----", NothingProc},
592 {N_("Edit Tags"), EditTagsProc},
593 {N_("Edit Comment"), EditCommentProc},
594 {N_("ICS Input Box"), IcsInputBoxProc},
595 {N_("Pause"), PauseProc},
599 MenuItem actionMenu[] = {
600 {N_("Accept"), AcceptProc},
601 {N_("Decline"), DeclineProc},
602 {N_("Rematch"), RematchProc},
603 {"----", NothingProc},
604 {N_("Call Flag"), CallFlagProc},
605 {N_("Draw"), DrawProc},
606 {N_("Adjourn"), AdjournProc},
607 {N_("Abort"), AbortProc},
608 {N_("Resign"), ResignProc},
609 {"----", NothingProc},
610 {N_("Stop Observing"), StopObservingProc},
611 {N_("Stop Examining"), StopExaminingProc},
612 {"----", NothingProc},
613 {N_("Adjudicate to White"), AdjuWhiteProc},
614 {N_("Adjudicate to Black"), AdjuBlackProc},
615 {N_("Adjudicate Draw"), AdjuDrawProc},
619 MenuItem stepMenu[] = {
620 {N_("Backward"), BackwardProc},
621 {N_("Forward"), ForwardProc},
622 {N_("Back to Start"), ToStartProc},
623 {N_("Forward to End"), ToEndProc},
624 {N_("Revert"), RevertProc},
625 {N_("Truncate Game"), TruncateGameProc},
626 {"----", NothingProc},
627 {N_("Move Now"), MoveNowProc},
628 {N_("Retract Move"), RetractMoveProc},
632 MenuItem optionsMenu[] = {
633 {N_("Flip View"), FlipViewProc},
634 {"----", NothingProc},
635 {N_("Adjudications ..."), EngineMenuProc},
636 {N_("General Settings ..."), UciMenuProc},
637 {N_("Engine #1 Settings ..."), FirstSettingsProc},
638 {N_("Engine #2 Settings ..."), SecondSettingsProc},
639 {N_("Time Control ..."), TimeControlProc},
640 {"----", NothingProc},
641 {N_("Always Queen"), AlwaysQueenProc},
642 {N_("Animate Dragging"), AnimateDraggingProc},
643 {N_("Animate Moving"), AnimateMovingProc},
644 {N_("Auto Comment"), AutocommProc},
645 {N_("Auto Flag"), AutoflagProc},
646 {N_("Auto Flip View"), AutoflipProc},
647 {N_("Auto Observe"), AutobsProc},
648 {N_("Auto Raise Board"), AutoraiseProc},
649 {N_("Auto Save"), AutosaveProc},
650 {N_("Blindfold"), BlindfoldProc},
651 {N_("Flash Moves"), FlashMovesProc},
652 {N_("Get Move List"), GetMoveListProc},
654 {N_("Highlight Dragging"), HighlightDraggingProc},
656 {N_("Highlight Last Move"), HighlightLastMoveProc},
657 {N_("Move Sound"), MoveSoundProc},
658 {N_("ICS Alarm"), IcsAlarmProc},
659 {N_("Old Save Style"), OldSaveStyleProc},
660 {N_("Periodic Updates"), PeriodicUpdatesProc},
661 {N_("Ponder Next Move"), PonderNextMoveProc},
662 {N_("Popup Exit Message"), PopupExitMessageProc},
663 {N_("Popup Move Errors"), PopupMoveErrorsProc},
664 {N_("Premove"), PremoveProc},
665 {N_("Quiet Play"), QuietPlayProc},
666 {N_("Show Coords"), ShowCoordsProc},
667 {N_("Hide Thinking"), HideThinkingProc},
668 {N_("Test Legality"), TestLegalityProc},
672 MenuItem helpMenu[] = {
673 {N_("Info XBoard"), InfoProc},
674 {N_("Man XBoard"), ManProc},
675 {"----", NothingProc},
676 {N_("Hint"), HintProc},
677 {N_("Book"), BookProc},
678 {"----", NothingProc},
679 {N_("About XBoard"), AboutProc},
684 {N_("File"), fileMenu},
685 {N_("Mode"), modeMenu},
686 {N_("Action"), actionMenu},
687 {N_("Step"), stepMenu},
688 {N_("Options"), optionsMenu},
689 {N_("Help"), helpMenu},
693 #define PAUSE_BUTTON N_("P")
694 MenuItem buttonBar[] = {
697 {PAUSE_BUTTON, PauseProc},
703 #define PIECE_MENU_SIZE 18
704 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
705 { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
706 N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
707 N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
708 N_("Empty square"), N_("Clear board") },
709 { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
710 N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
711 N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
712 N_("Empty square"), N_("Clear board") }
714 /* must be in same order as PieceMenuStrings! */
715 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
716 { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
717 WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
718 WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
719 PromotePiece, DemotePiece, EmptySquare, ClearBoard },
720 { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
721 BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
722 BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
723 PromotePiece, DemotePiece, EmptySquare, ClearBoard },
726 #define DROP_MENU_SIZE 6
727 String dropMenuStrings[DROP_MENU_SIZE] = {
728 "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
730 /* must be in same order as PieceMenuStrings! */
731 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
732 (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
733 WhiteRook, WhiteQueen
741 DropMenuEnables dmEnables[] = {
759 { XtNborderWidth, 0 },
760 { XtNdefaultDistance, 0 },
764 { XtNborderWidth, 0 },
765 { XtNresizable, (XtArgVal) True },
769 { XtNborderWidth, 0 },
775 { XtNjustify, (XtArgVal) XtJustifyRight },
776 { XtNlabel, (XtArgVal) "..." },
777 { XtNresizable, (XtArgVal) True },
778 { XtNresize, (XtArgVal) False }
781 Arg messageArgs[] = {
782 { XtNjustify, (XtArgVal) XtJustifyLeft },
783 { XtNlabel, (XtArgVal) "..." },
784 { XtNresizable, (XtArgVal) True },
785 { XtNresize, (XtArgVal) False }
789 { XtNborderWidth, 0 },
790 { XtNjustify, (XtArgVal) XtJustifyLeft }
793 XtResource clientResources[] = {
794 { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
795 XtOffset(AppDataPtr, whitePieceColor), XtRString,
797 { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
798 XtOffset(AppDataPtr, blackPieceColor), XtRString,
800 { "lightSquareColor", "lightSquareColor", XtRString,
801 sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
802 XtRString, LIGHT_SQUARE_COLOR },
803 { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
804 XtOffset(AppDataPtr, darkSquareColor), XtRString,
806 { "highlightSquareColor", "highlightSquareColor", XtRString,
807 sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
808 XtRString, HIGHLIGHT_SQUARE_COLOR },
809 { "premoveHighlightColor", "premoveHighlightColor", XtRString,
810 sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
811 XtRString, PREMOVE_HIGHLIGHT_COLOR },
812 { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
813 XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
814 (XtPointer) MOVES_PER_SESSION },
815 { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
816 XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
817 (XtPointer) TIME_INCREMENT },
818 { "initString", "initString", XtRString, sizeof(String),
819 XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
820 { "secondInitString", "secondInitString", XtRString, sizeof(String),
821 XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
822 { "firstComputerString", "firstComputerString", XtRString,
823 sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
825 { "secondComputerString", "secondComputerString", XtRString,
826 sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
828 { "firstChessProgram", "firstChessProgram", XtRString,
829 sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
830 XtRString, FIRST_CHESS_PROGRAM },
831 { "secondChessProgram", "secondChessProgram", XtRString,
832 sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
833 XtRString, SECOND_CHESS_PROGRAM },
834 { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
835 sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
836 XtRImmediate, (XtPointer) False },
837 { "noChessProgram", "noChessProgram", XtRBoolean,
838 sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
839 XtRImmediate, (XtPointer) False },
840 { "firstHost", "firstHost", XtRString, sizeof(String),
841 XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
842 { "secondHost", "secondHost", XtRString, sizeof(String),
843 XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
844 { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
845 XtOffset(AppDataPtr, firstDirectory), XtRString, "." },
846 { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
847 XtOffset(AppDataPtr, secondDirectory), XtRString, "." },
848 { "bitmapDirectory", "bitmapDirectory", XtRString,
849 sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
851 { "remoteShell", "remoteShell", XtRString, sizeof(String),
852 XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
853 { "remoteUser", "remoteUser", XtRString, sizeof(String),
854 XtOffset(AppDataPtr, remoteUser), XtRString, "" },
855 { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
856 XtOffset(AppDataPtr, timeDelay), XtRString,
857 (XtPointer) TIME_DELAY_QUOTE },
858 { "timeControl", "timeControl", XtRString, sizeof(String),
859 XtOffset(AppDataPtr, timeControl), XtRString,
860 (XtPointer) TIME_CONTROL },
861 { "internetChessServerMode", "internetChessServerMode",
862 XtRBoolean, sizeof(Boolean),
863 XtOffset(AppDataPtr, icsActive), XtRImmediate,
865 { "internetChessServerHost", "internetChessServerHost",
866 XtRString, sizeof(String),
867 XtOffset(AppDataPtr, icsHost),
868 XtRString, (XtPointer) ICS_HOST },
869 { "internetChessServerPort", "internetChessServerPort",
870 XtRString, sizeof(String),
871 XtOffset(AppDataPtr, icsPort), XtRString,
872 (XtPointer) ICS_PORT },
873 { "internetChessServerCommPort", "internetChessServerCommPort",
874 XtRString, sizeof(String),
875 XtOffset(AppDataPtr, icsCommPort), XtRString,
877 { "internetChessServerLogonScript", "internetChessServerLogonScript",
878 XtRString, sizeof(String),
879 XtOffset(AppDataPtr, icsLogon), XtRString,
881 { "internetChessServerHelper", "internetChessServerHelper",
882 XtRString, sizeof(String),
883 XtOffset(AppDataPtr, icsHelper), XtRString, "" },
884 { "internetChessServerInputBox", "internetChessServerInputBox",
885 XtRBoolean, sizeof(Boolean),
886 XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
888 { "icsAlarm", "icsAlarm",
889 XtRBoolean, sizeof(Boolean),
890 XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
892 { "icsAlarmTime", "icsAlarmTime",
894 XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
896 { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
897 XtOffset(AppDataPtr, useTelnet), XtRImmediate,
899 { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
900 XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
901 { "gateway", "gateway", XtRString, sizeof(String),
902 XtOffset(AppDataPtr, gateway), XtRString, "" },
903 { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
904 XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
905 { "loadGameIndex", "loadGameIndex",
907 XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
909 { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
910 XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
911 { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
912 sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
913 XtRImmediate, (XtPointer) True },
914 { "autoSaveGames", "autoSaveGames", XtRBoolean,
915 sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
916 XtRImmediate, (XtPointer) False },
917 { "blindfold", "blindfold", XtRBoolean,
918 sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
919 XtRImmediate, (XtPointer) False },
920 { "loadPositionFile", "loadPositionFile", XtRString,
921 sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
923 { "loadPositionIndex", "loadPositionIndex",
925 XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
927 { "savePositionFile", "savePositionFile", XtRString,
928 sizeof(String), XtOffset(AppDataPtr, savePositionFile),
930 { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
931 XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
932 { "matchGames", "matchGames", XtRInt, sizeof(int),
933 XtOffset(AppDataPtr, matchGames), XtRImmediate,
935 { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
936 XtOffset(AppDataPtr, monoMode), XtRImmediate,
938 { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
939 XtOffset(AppDataPtr, debugMode), XtRImmediate,
941 { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
942 XtOffset(AppDataPtr, clockMode), XtRImmediate,
944 { "boardSize", "boardSize", XtRString, sizeof(String),
945 XtOffset(AppDataPtr, boardSize), XtRString, "" },
946 { "searchTime", "searchTime", XtRString, sizeof(String),
947 XtOffset(AppDataPtr, searchTime), XtRString,
949 { "searchDepth", "searchDepth", XtRInt, sizeof(int),
950 XtOffset(AppDataPtr, searchDepth), XtRImmediate,
952 { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
953 XtOffset(AppDataPtr, showCoords), XtRImmediate,
955 { "showJail", "showJail", XtRInt, sizeof(int),
956 XtOffset(AppDataPtr, showJail), XtRImmediate,
958 { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
959 XtOffset(AppDataPtr, showThinking), XtRImmediate,
961 { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
962 XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
964 { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
965 XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
967 { "clockFont", "clockFont", XtRString, sizeof(String),
968 XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
969 { "coordFont", "coordFont", XtRString, sizeof(String),
970 XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
971 { "font", "font", XtRString, sizeof(String),
972 XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
973 { "ringBellAfterMoves", "ringBellAfterMoves",
974 XtRBoolean, sizeof(Boolean),
975 XtOffset(AppDataPtr, ringBellAfterMoves),
976 XtRImmediate, (XtPointer) False },
977 { "autoCallFlag", "autoCallFlag", XtRBoolean,
978 sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
979 XtRImmediate, (XtPointer) False },
980 { "autoFlipView", "autoFlipView", XtRBoolean,
981 sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
982 XtRImmediate, (XtPointer) True },
983 { "autoObserve", "autoObserve", XtRBoolean,
984 sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
985 XtRImmediate, (XtPointer) False },
986 { "autoComment", "autoComment", XtRBoolean,
987 sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
988 XtRImmediate, (XtPointer) False },
989 { "getMoveList", "getMoveList", XtRBoolean,
990 sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
991 XtRImmediate, (XtPointer) True },
993 { "highlightDragging", "highlightDragging", XtRBoolean,
994 sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
995 XtRImmediate, (XtPointer) False },
997 { "highlightLastMove", "highlightLastMove", XtRBoolean,
998 sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
999 XtRImmediate, (XtPointer) False },
1000 { "premove", "premove", XtRBoolean,
1001 sizeof(Boolean), XtOffset(AppDataPtr, premove),
1002 XtRImmediate, (XtPointer) True },
1003 { "testLegality", "testLegality", XtRBoolean,
1004 sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
1005 XtRImmediate, (XtPointer) True },
1006 { "flipView", "flipView", XtRBoolean,
1007 sizeof(Boolean), XtOffset(AppDataPtr, flipView),
1008 XtRImmediate, (XtPointer) False },
1009 { "cmail", "cmailGameName", XtRString, sizeof(String),
1010 XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
1011 { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
1012 sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
1013 XtRImmediate, (XtPointer) False },
1014 { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
1015 sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
1016 XtRImmediate, (XtPointer) False },
1017 { "quietPlay", "quietPlay", XtRBoolean,
1018 sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
1019 XtRImmediate, (XtPointer) False },
1020 { "titleInWindow", "titleInWindow", XtRBoolean,
1021 sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
1022 XtRImmediate, (XtPointer) False },
1023 { "localLineEditing", "localLineEditing", XtRBoolean,
1024 sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
1025 XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
1027 { "zippyTalk", "zippyTalk", XtRBoolean,
1028 sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
1029 XtRImmediate, (XtPointer) ZIPPY_TALK },
1030 { "zippyPlay", "zippyPlay", XtRBoolean,
1031 sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
1032 XtRImmediate, (XtPointer) ZIPPY_PLAY },
1033 { "zippyLines", "zippyLines", XtRString, sizeof(String),
1034 XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
1035 { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
1036 XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
1037 { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
1038 XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
1039 { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
1040 XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
1041 { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
1042 XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
1043 ZIPPY_WRONG_PASSWORD },
1044 { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
1045 XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
1046 { "zippyUseI", "zippyUseI", XtRBoolean,
1047 sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
1048 XtRImmediate, (XtPointer) ZIPPY_USE_I },
1049 { "zippyBughouse", "zippyBughouse", XtRInt,
1050 sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
1051 XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
1052 { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
1053 sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
1054 XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
1055 { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
1056 XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
1057 { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
1058 XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
1059 { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
1060 sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
1061 XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
1062 { "zippyAbort", "zippyAbort", XtRBoolean,
1063 sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
1064 XtRImmediate, (XtPointer) ZIPPY_ABORT },
1065 { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
1066 XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
1067 { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
1068 XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
1069 (XtPointer) ZIPPY_MAX_GAMES },
1070 { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
1071 XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
1072 (XtPointer) ZIPPY_REPLAY_TIMEOUT },
1073 { "zippyShortGame", "zippyShortGame", XtRInt, sizeof(int),
1074 XtOffset(AppDataPtr, zippyShortGame), XtRImmediate,
1077 { "flashCount", "flashCount", XtRInt, sizeof(int),
1078 XtOffset(AppDataPtr, flashCount), XtRImmediate,
1079 (XtPointer) FLASH_COUNT },
1080 { "flashRate", "flashRate", XtRInt, sizeof(int),
1081 XtOffset(AppDataPtr, flashRate), XtRImmediate,
1082 (XtPointer) FLASH_RATE },
1083 { "pixmapDirectory", "pixmapDirectory", XtRString,
1084 sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
1086 { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
1087 XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
1088 (XtPointer) MS_LOGIN_DELAY },
1089 { "colorizeMessages", "colorizeMessages", XtRBoolean,
1090 sizeof(Boolean), XtOffset(AppDataPtr, colorize),
1091 XtRImmediate, (XtPointer) False },
1092 { "colorShout", "colorShout", XtRString,
1093 sizeof(String), XtOffset(AppDataPtr, colorShout),
1094 XtRString, COLOR_SHOUT },
1095 { "colorSShout", "colorSShout", XtRString,
1096 sizeof(String), XtOffset(AppDataPtr, colorSShout),
1097 XtRString, COLOR_SSHOUT },
1098 { "colorChannel1", "colorChannel1", XtRString,
1099 sizeof(String), XtOffset(AppDataPtr, colorChannel1),
1100 XtRString, COLOR_CHANNEL1 },
1101 { "colorChannel", "colorChannel", XtRString,
1102 sizeof(String), XtOffset(AppDataPtr, colorChannel),
1103 XtRString, COLOR_CHANNEL },
1104 { "colorKibitz", "colorKibitz", XtRString,
1105 sizeof(String), XtOffset(AppDataPtr, colorKibitz),
1106 XtRString, COLOR_KIBITZ },
1107 { "colorTell", "colorTell", XtRString,
1108 sizeof(String), XtOffset(AppDataPtr, colorTell),
1109 XtRString, COLOR_TELL },
1110 { "colorChallenge", "colorChallenge", XtRString,
1111 sizeof(String), XtOffset(AppDataPtr, colorChallenge),
1112 XtRString, COLOR_CHALLENGE },
1113 { "colorRequest", "colorRequest", XtRString,
1114 sizeof(String), XtOffset(AppDataPtr, colorRequest),
1115 XtRString, COLOR_REQUEST },
1116 { "colorSeek", "colorSeek", XtRString,
1117 sizeof(String), XtOffset(AppDataPtr, colorSeek),
1118 XtRString, COLOR_SEEK },
1119 { "colorNormal", "colorNormal", XtRString,
1120 sizeof(String), XtOffset(AppDataPtr, colorNormal),
1121 XtRString, COLOR_NORMAL },
1122 { "soundProgram", "soundProgram", XtRString,
1123 sizeof(String), XtOffset(AppDataPtr, soundProgram),
1124 XtRString, "play" },
1125 { "soundShout", "soundShout", XtRString,
1126 sizeof(String), XtOffset(AppDataPtr, soundShout),
1128 { "soundSShout", "soundSShout", XtRString,
1129 sizeof(String), XtOffset(AppDataPtr, soundSShout),
1131 { "soundChannel1", "soundChannel1", XtRString,
1132 sizeof(String), XtOffset(AppDataPtr, soundChannel1),
1134 { "soundChannel", "soundChannel", XtRString,
1135 sizeof(String), XtOffset(AppDataPtr, soundChannel),
1137 { "soundKibitz", "soundKibitz", XtRString,
1138 sizeof(String), XtOffset(AppDataPtr, soundKibitz),
1140 { "soundTell", "soundTell", XtRString,
1141 sizeof(String), XtOffset(AppDataPtr, soundTell),
1143 { "soundChallenge", "soundChallenge", XtRString,
1144 sizeof(String), XtOffset(AppDataPtr, soundChallenge),
1146 { "soundRequest", "soundRequest", XtRString,
1147 sizeof(String), XtOffset(AppDataPtr, soundRequest),
1149 { "soundSeek", "soundSeek", XtRString,
1150 sizeof(String), XtOffset(AppDataPtr, soundSeek),
1152 { "soundMove", "soundMove", XtRString,
1153 sizeof(String), XtOffset(AppDataPtr, soundMove),
1155 { "soundIcsWin", "soundIcsWin", XtRString,
1156 sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
1158 { "soundIcsLoss", "soundIcsLoss", XtRString,
1159 sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
1161 { "soundIcsDraw", "soundIcsDraw", XtRString,
1162 sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
1164 { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
1165 sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
1167 { "soundIcsAlarm", "soundIcsAlarm", XtRString,
1168 sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
1170 { "reuseFirst", "reuseFirst", XtRBoolean,
1171 sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
1172 XtRImmediate, (XtPointer) True },
1173 { "reuseSecond", "reuseSecond", XtRBoolean,
1174 sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
1175 XtRImmediate, (XtPointer) True },
1176 { "animateDragging", "animateDragging", XtRBoolean,
1177 sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
1178 XtRImmediate, (XtPointer) True },
1179 { "animateMoving", "animateMoving", XtRBoolean,
1180 sizeof(Boolean), XtOffset(AppDataPtr, animate),
1181 XtRImmediate, (XtPointer) True },
1182 { "animateSpeed", "animateSpeed", XtRInt,
1183 sizeof(int), XtOffset(AppDataPtr, animSpeed),
1184 XtRImmediate, (XtPointer)10 },
1185 { "popupExitMessage", "popupExitMessage", XtRBoolean,
1186 sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
1187 XtRImmediate, (XtPointer) True },
1188 { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
1189 sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
1190 XtRImmediate, (XtPointer) False },
1191 { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
1192 sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
1193 XtRImmediate, (XtPointer)4 },
1194 { "initialMode", "initialMode", XtRString,
1195 sizeof(String), XtOffset(AppDataPtr, initialMode),
1196 XtRImmediate, (XtPointer) "" },
1197 { "variant", "variant", XtRString,
1198 sizeof(String), XtOffset(AppDataPtr, variant),
1199 XtRImmediate, (XtPointer) "normal" },
1200 { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
1201 sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
1202 XtRImmediate, (XtPointer)PROTOVER },
1203 { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
1204 sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
1205 XtRImmediate, (XtPointer)PROTOVER },
1206 { "showButtonBar", "showButtonBar", XtRBoolean,
1207 sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
1208 XtRImmediate, (XtPointer) True },
1209 { "lowTimeWarningColor", "lowTimeWarningColor", XtRString,
1210 sizeof(String), XtOffset(AppDataPtr, lowTimeWarningColor),
1211 XtRString, COLOR_LOWTIMEWARNING },
1212 { "lowTimeWarning", "lowTimeWarning", XtRBoolean,
1213 sizeof(Boolean), XtOffset(AppDataPtr, lowTimeWarning),
1214 XtRImmediate, (XtPointer) False },
1215 {"icsEngineAnalyze", "icsEngineAnalyze", XtRBoolean, /* [DM] icsEngineAnalyze */
1216 sizeof(Boolean), XtOffset(AppDataPtr, icsEngineAnalyze),
1217 XtRImmediate, (XtPointer) False },
1218 { "firstScoreAbs", "firstScoreAbs", XtRBoolean,
1219 sizeof(Boolean), XtOffset(AppDataPtr, firstScoreIsAbsolute),
1220 XtRImmediate, (XtPointer) False },
1221 { "secondScoreAbs", "secondScoreAbs", XtRBoolean,
1222 sizeof(Boolean), XtOffset(AppDataPtr, secondScoreIsAbsolute),
1223 XtRImmediate, (XtPointer) False },
1224 { "pgnExtendedInfo", "pgnExtendedInfo", XtRBoolean,
1225 sizeof(Boolean), XtOffset(AppDataPtr, saveExtendedInfoInPGN),
1226 XtRImmediate, (XtPointer) False },
1227 { "hideThinkingFromHuman", "hideThinkingFromHuman", XtRBoolean,
1228 sizeof(Boolean), XtOffset(AppDataPtr, hideThinkingFromHuman),
1229 XtRImmediate, (XtPointer) True },
1230 { "adjudicateLossThreshold", "adjudicateLossThreshold", XtRInt,
1231 sizeof(int), XtOffset(AppDataPtr, adjudicateLossThreshold),
1232 XtRImmediate, (XtPointer) 0},
1233 { "adjudicateDrawMoves", "adjudicateDrawMoves", XtRInt,
1234 sizeof(int), XtOffset(AppDataPtr, adjudicateDrawMoves),
1235 XtRImmediate, (XtPointer) 0},
1236 { "pgnEventHeader", "pgnEventHeader", XtRString,
1237 sizeof(String), XtOffset(AppDataPtr, pgnEventHeader),
1238 XtRImmediate, (XtPointer) "Computer Chess Game" },
1239 { "defaultFrcPosition", "defaultFrcPositon", XtRInt,
1240 sizeof(int), XtOffset(AppDataPtr, defaultFrcPosition),
1241 XtRImmediate, (XtPointer) -1},
1242 { "gameListTags", "gameListTags", XtRString,
1243 sizeof(String), XtOffset(AppDataPtr, gameListTags),
1244 XtRImmediate, (XtPointer) GLT_DEFAULT_TAGS },
1246 // [HGM] 4.3.xx options
1247 { "boardWidth", "boardWidth", XtRInt,
1248 sizeof(int), XtOffset(AppDataPtr, NrFiles),
1249 XtRImmediate, (XtPointer) -1},
1250 { "boardHeight", "boardHeight", XtRInt,
1251 sizeof(int), XtOffset(AppDataPtr, NrRanks),
1252 XtRImmediate, (XtPointer) -1},
1253 { "matchPause", "matchPause", XtRInt,
1254 sizeof(int), XtOffset(AppDataPtr, matchPause),
1255 XtRImmediate, (XtPointer) 10000},
1256 { "holdingsSize", "holdingsSize", XtRInt,
1257 sizeof(int), XtOffset(AppDataPtr, holdingsSize),
1258 XtRImmediate, (XtPointer) -1},
1259 { "flipBlack", "flipBlack", XtRBoolean,
1260 sizeof(Boolean), XtOffset(AppDataPtr, upsideDown),
1261 XtRImmediate, (XtPointer) False},
1262 { "allWhite", "allWhite", XtRBoolean,
1263 sizeof(Boolean), XtOffset(AppDataPtr, allWhite),
1264 XtRImmediate, (XtPointer) False},
1265 { "pieceToCharTable", "pieceToCharTable", XtRString,
1266 sizeof(String), XtOffset(AppDataPtr, pieceToCharTable),
1267 XtRImmediate, (XtPointer) 0},
1268 { "alphaRank", "alphaRank", XtRBoolean,
1269 sizeof(Boolean), XtOffset(AppDataPtr, alphaRank),
1270 XtRImmediate, (XtPointer) False},
1271 { "testClaims", "testClaims", XtRBoolean,
1272 sizeof(Boolean), XtOffset(AppDataPtr, testClaims),
1273 XtRImmediate, (XtPointer) True},
1274 { "checkMates", "checkMates", XtRBoolean,
1275 sizeof(Boolean), XtOffset(AppDataPtr, checkMates),
1276 XtRImmediate, (XtPointer) True},
1277 { "materialDraws", "materialDraws", XtRBoolean,
1278 sizeof(Boolean), XtOffset(AppDataPtr, materialDraws),
1279 XtRImmediate, (XtPointer) True},
1280 { "trivialDraws", "trivialDraws", XtRBoolean,
1281 sizeof(Boolean), XtOffset(AppDataPtr, trivialDraws),
1282 XtRImmediate, (XtPointer) False},
1283 { "ruleMoves", "ruleMoves", XtRInt,
1284 sizeof(int), XtOffset(AppDataPtr, ruleMoves),
1285 XtRImmediate, (XtPointer) 51},
1286 { "repeatsToDraw", "repeatsToDraw", XtRInt,
1287 sizeof(int), XtOffset(AppDataPtr, drawRepeats),
1288 XtRImmediate, (XtPointer) 6},
1289 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1290 sizeof(int), XtOffset(AppDataPtr, engineComments),
1291 XtRImmediate, (XtPointer) 1},
1292 { "userName", "userName", XtRString,
1293 sizeof(int), XtOffset(AppDataPtr, userName),
1294 XtRImmediate, (XtPointer) 0},
1295 { "autoKibitz", "autoKibitz", XtRBoolean,
1296 sizeof(Boolean), XtOffset(AppDataPtr, autoKibitz),
1297 XtRImmediate, (XtPointer) False},
1298 { "firstTimeOdds", "firstTimeOdds", XtRInt,
1299 sizeof(int), XtOffset(AppDataPtr, firstTimeOdds),
1300 XtRImmediate, (XtPointer) 1},
1301 { "secondTimeOdds", "secondTimeOdds", XtRInt,
1302 sizeof(int), XtOffset(AppDataPtr, secondTimeOdds),
1303 XtRImmediate, (XtPointer) 1},
1304 { "timeOddsMode", "timeOddsMode", XtRInt,
1305 sizeof(int), XtOffset(AppDataPtr, timeOddsMode),
1306 XtRImmediate, (XtPointer) 0},
1307 { "firstAccumulateTC", "firstAccumulateTC", XtRInt,
1308 sizeof(int), XtOffset(AppDataPtr, firstAccumulateTC),
1309 XtRImmediate, (XtPointer) 1},
1310 { "secondAccumulateTC", "secondAccumulateTC", XtRInt,
1311 sizeof(int), XtOffset(AppDataPtr, secondAccumulateTC),
1312 XtRImmediate, (XtPointer) 1},
1313 { "firstNPS", "firstNPS", XtRInt,
1314 sizeof(int), XtOffset(AppDataPtr, firstNPS),
1315 XtRImmediate, (XtPointer) -1},
1316 { "secondNPS", "secondNPS", XtRInt,
1317 sizeof(int), XtOffset(AppDataPtr, secondNPS),
1318 XtRImmediate, (XtPointer) -1},
1319 { "serverMoves", "serverMoves", XtRString,
1320 sizeof(String), XtOffset(AppDataPtr, serverMovesName),
1321 XtRImmediate, (XtPointer) 0},
1322 { "serverPause", "serverPause", XtRInt,
1323 sizeof(int), XtOffset(AppDataPtr, serverPause),
1324 XtRImmediate, (XtPointer) 0},
1325 { "suppressLoadMoves", "suppressLoadMoves", XtRBoolean,
1326 sizeof(Boolean), XtOffset(AppDataPtr, suppressLoadMoves),
1327 XtRImmediate, (XtPointer) False},
1328 { "userName", "userName", XtRString,
1329 sizeof(String), XtOffset(AppDataPtr, userName),
1330 XtRImmediate, (XtPointer) 0},
1331 { "egtFormats", "egtFormats", XtRString,
1332 sizeof(String), XtOffset(AppDataPtr, egtFormats),
1333 XtRImmediate, (XtPointer) 0},
1334 { "rewindIndex", "rewindIndex", XtRInt,
1335 sizeof(int), XtOffset(AppDataPtr, rewindIndex),
1336 XtRImmediate, (XtPointer) 0},
1337 { "sameColorGames", "sameColorGames", XtRInt,
1338 sizeof(int), XtOffset(AppDataPtr, sameColorGames),
1339 XtRImmediate, (XtPointer) 0},
1340 { "smpCores", "smpCores", XtRInt,
1341 sizeof(int), XtOffset(AppDataPtr, smpCores),
1342 XtRImmediate, (XtPointer) 1},
1343 { "niceEngines", "niceEngines", XtRInt,
1344 sizeof(int), XtOffset(AppDataPtr, niceEngines),
1345 XtRImmediate, (XtPointer) 0},
1346 { "nameOfDebugFile", "nameOfDebugFile", XtRString,
1347 sizeof(String), XtOffset(AppDataPtr, nameOfDebugFile),
1348 XtRImmediate, (XtPointer) "xboard.debug"},
1349 { "engineDebugOutput", "engineDebugOutput", XtRInt,
1350 sizeof(int), XtOffset(AppDataPtr, engineComments),
1351 XtRImmediate, (XtPointer) 1},
1352 { "noGUI", "noGUI", XtRBoolean,
1353 sizeof(Boolean), XtOffset(AppDataPtr, noGUI),
1354 XtRImmediate, (XtPointer) 0},
1355 { "firstOptions", "firstOptions", XtRString,
1356 sizeof(String), XtOffset(AppDataPtr, firstOptions),
1357 XtRImmediate, (XtPointer) "" },
1358 { "secondOptions", "secondOptions", XtRString,
1359 sizeof(String), XtOffset(AppDataPtr, secondOptions),
1360 XtRImmediate, (XtPointer) "" },
1361 { "firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XtRString,
1362 sizeof(String), XtOffset(AppDataPtr, fenOverride1),
1363 XtRImmediate, (XtPointer) 0 },
1364 { "secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XtRString,
1365 sizeof(String), XtOffset(AppDataPtr, fenOverride2),
1366 XtRImmediate, (XtPointer) 0 },
1368 // [HGM] Winboard_x UCI options
1369 { "firstIsUCI", "firstIsUCI", XtRBoolean,
1370 sizeof(Boolean), XtOffset(AppDataPtr, firstIsUCI),
1371 XtRImmediate, (XtPointer) False},
1372 { "secondIsUCI", "secondIsUCI", XtRBoolean,
1373 sizeof(Boolean), XtOffset(AppDataPtr, secondIsUCI),
1374 XtRImmediate, (XtPointer) False},
1375 { "firstHasOwnBookUCI", "firstHasOwnBookUCI", XtRBoolean,
1376 sizeof(Boolean), XtOffset(AppDataPtr, firstHasOwnBookUCI),
1377 XtRImmediate, (XtPointer) True},
1378 { "secondHasOwnBookUCI", "secondHasOwnBookUCI", XtRBoolean,
1379 sizeof(Boolean), XtOffset(AppDataPtr, secondHasOwnBookUCI),
1380 XtRImmediate, (XtPointer) True},
1381 { "usePolyglotBook", "usePolyglotBook", XtRBoolean,
1382 sizeof(Boolean), XtOffset(AppDataPtr, usePolyglotBook),
1383 XtRImmediate, (XtPointer) False},
1384 { "defaultHashSize", "defaultHashSize", XtRInt,
1385 sizeof(int), XtOffset(AppDataPtr, defaultHashSize),
1386 XtRImmediate, (XtPointer) 64},
1387 { "defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XtRInt,
1388 sizeof(int), XtOffset(AppDataPtr, defaultCacheSizeEGTB),
1389 XtRImmediate, (XtPointer) 4},
1390 { "polyglotDir", "polyglotDir", XtRString,
1391 sizeof(String), XtOffset(AppDataPtr, polyglotDir),
1392 XtRImmediate, (XtPointer) "." },
1393 { "polyglotBook", "polyglotBook", XtRString,
1394 sizeof(String), XtOffset(AppDataPtr, polyglotBook),
1395 XtRImmediate, (XtPointer) "" },
1396 { "defaultPathEGTB", "defaultPathEGTB", XtRString,
1397 sizeof(String), XtOffset(AppDataPtr, defaultPathEGTB),
1398 XtRImmediate, (XtPointer) "/usr/local/share/egtb"},
1399 { "delayBeforeQuit", "delayBeforeQuit", XtRInt,
1400 sizeof(int), XtOffset(AppDataPtr, delayBeforeQuit),
1401 XtRImmediate, (XtPointer) 0},
1402 { "delayAfterQuit", "delayAfterQuit", XtRInt,
1403 sizeof(int), XtOffset(AppDataPtr, delayAfterQuit),
1404 XtRImmediate, (XtPointer) 0},
1405 { "keepAlive", "keepAlive", XtRInt,
1406 sizeof(int), XtOffset(AppDataPtr, keepAlive),
1407 XtRImmediate, (XtPointer) 0},
1408 { "forceIllegalMoves", "forceIllegalMoves", XtRBoolean,
1409 sizeof(Boolean), XtOffset(AppDataPtr, forceIllegal),
1410 XtRImmediate, (XtPointer) False},
1411 { "keepLineBreaksICS", "keepLineBreaksICS", XtRBoolean,
1412 sizeof(Boolean), XtOffset(AppDataPtr, noJoin),
1413 XtRImmediate, (XtPointer) False},
1414 { "wrapContinuationSequence", "wrapContinuationSequence", XtRString,
1415 sizeof(String), XtOffset(AppDataPtr, wrapContSeq),
1417 { "useInternalWrap", "useInternalWrap", XtRBoolean,
1418 sizeof(Boolean), XtOffset(AppDataPtr, useInternalWrap),
1419 XtRImmediate, (XtPointer) True},
1420 { "autoDisplayTags", "autoDisplayTags", XtRBoolean,
1421 sizeof(Boolean), XtOffset(AppDataPtr, autoDisplayTags),
1422 XtRImmediate, (XtPointer) True},
1423 { "autoDisplayComment", "autoDisplayComment", XtRBoolean,
1424 sizeof(Boolean), XtOffset(AppDataPtr, autoDisplayComment),
1425 XtRImmediate, (XtPointer) True},
1426 { "pasteSelection", "pasteSelection", XtRBoolean,
1427 sizeof(Boolean), XtOffset(AppDataPtr, pasteSelection),
1428 XtRImmediate, (XtPointer) False},
1431 XrmOptionDescRec shellOptions[] = {
1432 { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
1433 { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
1434 { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
1435 { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
1436 { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
1437 { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
1438 { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
1439 { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
1440 { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
1441 { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
1442 { "-initString", "initString", XrmoptionSepArg, NULL },
1443 { "-firstInitString", "initString", XrmoptionSepArg, NULL },
1444 { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
1445 { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
1446 { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
1447 { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
1448 { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
1449 { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
1450 { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
1451 { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
1452 { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
1453 { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
1454 { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
1455 { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
1456 { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
1457 { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
1458 { "-fh", "firstHost", XrmoptionSepArg, NULL },
1459 { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
1460 { "-sh", "secondHost", XrmoptionSepArg, NULL },
1461 { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
1462 { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
1463 { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
1464 { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
1465 { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
1466 { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
1467 { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
1468 { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
1469 { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
1470 { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
1471 { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
1472 { "-td", "timeDelay", XrmoptionSepArg, NULL },
1473 { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
1474 { "-tc", "timeControl", XrmoptionSepArg, NULL },
1475 { "-internetChessServerMode", "internetChessServerMode",
1476 XrmoptionSepArg, NULL },
1477 { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
1478 { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
1479 { "-internetChessServerHost", "internetChessServerHost",
1480 XrmoptionSepArg, NULL },
1481 { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
1482 { "-internetChessServerPort", "internetChessServerPort",
1483 XrmoptionSepArg, NULL },
1484 { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
1485 { "-internetChessServerCommPort", "internetChessServerCommPort",
1486 XrmoptionSepArg, NULL },
1487 { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
1488 { "-internetChessServerLogonScript", "internetChessServerLogonScript",
1489 XrmoptionSepArg, NULL },
1490 { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
1491 { "-internetChessServerHelper", "internetChessServerHelper",
1492 XrmoptionSepArg, NULL },
1493 { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
1494 { "-internetChessServerInputBox", "internetChessServerInputBox",
1495 XrmoptionSepArg, NULL },
1496 { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
1497 { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
1498 { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
1499 { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
1500 { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
1501 { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
1502 { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
1503 { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
1504 { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
1505 { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
1506 { "-gateway", "gateway", XrmoptionSepArg, NULL },
1507 { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
1508 { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
1509 { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
1510 { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
1511 { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
1512 { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
1513 { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
1514 { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
1515 { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
1516 { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
1517 { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
1518 { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
1519 { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
1520 { "-blind", "blindfold", XrmoptionNoArg, "True" },
1521 { "-xblind", "blindfold", XrmoptionNoArg, "False" },
1522 { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
1523 { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
1524 { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
1525 { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
1526 { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
1527 { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
1528 { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
1529 { "-mm", "matchMode", XrmoptionNoArg, "True" },
1530 { "-xmm", "matchMode", XrmoptionNoArg, "False" },
1531 { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
1532 { "-mg", "matchGames", XrmoptionSepArg, NULL },
1533 { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
1534 { "-mono", "monoMode", XrmoptionNoArg, "True" },
1535 { "-xmono", "monoMode", XrmoptionNoArg, "False" },
1536 { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
1537 { "-debug", "debugMode", XrmoptionNoArg, "True" },
1538 { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
1539 { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
1540 { "-clock", "clockMode", XrmoptionNoArg, "True" },
1541 { "-xclock", "clockMode", XrmoptionNoArg, "False" },
1542 { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
1543 { "-size", "boardSize", XrmoptionSepArg, NULL },
1544 { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
1545 { "-st", "searchTime", XrmoptionSepArg, NULL },
1546 { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
1547 { "-depth", "searchDepth", XrmoptionSepArg, NULL },
1548 { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
1549 { "-coords", "showCoords", XrmoptionNoArg, "True" },
1550 { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
1552 { "-showJail", "showJail", XrmoptionSepArg, NULL },
1553 { "-jail", "showJail", XrmoptionNoArg, "1" },
1554 { "-sidejail", "showJail", XrmoptionNoArg, "2" },
1555 { "-xjail", "showJail", XrmoptionNoArg, "0" },
1557 { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
1558 { "-thinking", "showThinking", XrmoptionNoArg, "True" },
1559 { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
1560 { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
1561 { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
1562 { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
1563 { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
1564 { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
1565 { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
1566 { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
1567 { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
1568 { "-font", "font", XrmoptionSepArg, NULL },
1569 { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
1570 { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1571 { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1572 { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1573 { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1574 { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
1575 { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
1576 { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
1577 { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
1578 { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
1579 { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
1580 { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
1581 { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
1582 { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
1583 { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
1584 { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
1585 { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
1586 { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
1587 { "-moves", "getMoveList", XrmoptionNoArg, "True" },
1588 { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
1590 { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
1591 { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
1592 { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
1594 { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
1595 { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
1596 { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
1597 { "-premove", "premove", XrmoptionSepArg, NULL },
1598 { "-pre", "premove", XrmoptionNoArg, "True" },
1599 { "-xpre", "premove", XrmoptionNoArg, "False" },
1600 { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
1601 { "-legal", "testLegality", XrmoptionNoArg, "True" },
1602 { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
1603 { "-flipView", "flipView", XrmoptionSepArg, NULL },
1604 { "-flip", "flipView", XrmoptionNoArg, "True" },
1605 { "-xflip", "flipView", XrmoptionNoArg, "False" },
1606 { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
1607 { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
1608 XrmoptionSepArg, NULL },
1609 { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
1610 { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
1611 { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
1612 { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
1613 { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
1614 { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
1615 { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
1616 { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
1617 { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
1618 { "-title", "titleInWindow", XrmoptionNoArg, "True" },
1619 { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
1621 { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
1622 { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
1623 { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
1624 { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
1625 { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
1626 { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
1627 { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
1628 { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
1629 { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
1630 { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
1631 { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
1632 { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
1633 { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
1634 { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
1635 { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
1636 { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
1637 { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
1638 { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
1639 { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
1640 { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
1641 { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
1642 { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
1643 { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
1644 { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
1645 { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
1646 { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
1647 { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
1648 { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
1649 { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
1650 { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
1651 { "-zippyShortGame", "zippyShortGame", XrmoptionSepArg, NULL },
1653 { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
1654 { "-flash", "flashCount", XrmoptionNoArg, "3" },
1655 { "-xflash", "flashCount", XrmoptionNoArg, "0" },
1656 { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
1657 { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
1658 { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
1659 { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
1660 { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
1661 { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
1662 { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
1663 { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
1664 { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
1665 { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1666 { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
1667 { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
1668 { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
1669 { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
1670 { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
1671 { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
1672 { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
1673 { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
1674 { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
1675 { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
1676 { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
1677 { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1678 { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
1679 { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
1680 { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
1681 { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
1682 { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
1683 { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
1684 { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
1685 { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
1686 { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
1687 { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
1688 { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
1689 { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
1690 { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
1691 { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
1692 { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
1693 { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
1694 { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
1695 { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
1696 { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
1697 { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
1698 { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
1699 { "-animate", "animateMoving", XrmoptionNoArg, "True" },
1700 { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
1701 { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
1702 { "-drag", "animateDragging", XrmoptionNoArg, "True" },
1703 { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
1704 { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
1705 { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
1706 { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
1707 { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
1708 { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
1709 { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
1710 { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
1711 { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
1712 { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
1713 { "-mode", "initialMode", XrmoptionSepArg, NULL },
1714 { "-variant", "variant", XrmoptionSepArg, NULL },
1715 { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
1716 { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
1717 { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
1718 { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
1719 { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
1720 { "-lowTimeWarningColor", "lowTimeWarningColor", XrmoptionSepArg, NULL },
1721 { "-lowTimeWarning", "lowTimeWarning", XrmoptionSepArg, NULL },
1722 /* [AS,HR] New features */
1723 { "-firstScoreAbs", "firstScoreAbs", XrmoptionSepArg, NULL },
1724 { "-secondScoreAbs", "secondScoreAbs", XrmoptionSepArg, NULL },
1725 { "-pgnExtendedInfo", "pgnExtendedInfo", XrmoptionSepArg, NULL },
1726 { "-hideThinkingFromHuman", "hideThinkingFromHuman", XrmoptionSepArg, NULL },
1727 { "-adjudicateLossThreshold", "adjudicateLossThreshold", XrmoptionSepArg, NULL },
1728 { "-adjudicateDrawMoves", "adjudicateDrawMoves", XrmoptionSepArg, NULL },
1729 { "-pgnEventHeader", "pgnEventHeader", XrmoptionSepArg, NULL },
1730 { "-firstIsUCI", "firstIsUCI", XrmoptionSepArg, NULL },
1731 { "-secondIsUCI", "secondIsUCI", XrmoptionSepArg, NULL },
1732 { "-fUCI", "firstIsUCI", XrmoptionNoArg, "True" },
1733 { "-sUCI", "secondIsUCI", XrmoptionNoArg, "True" },
1734 { "-firstHasOwnBookUCI", "firstHasOwnBookUCI", XrmoptionSepArg, NULL },
1735 { "-secondHasOwnBookUCI", "secondHasOwnBookUCI", XrmoptionSepArg, NULL },
1736 { "-fNoOwnBookUCI", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1737 { "-sNoOwnBookUCI", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1738 { "-firstXBook", "firstHasOwnBookUCI", XrmoptionNoArg, "False" },
1739 { "-secondXBook", "secondHasOwnBookUCI", XrmoptionNoArg, "False" },
1740 { "-polyglotDir", "polyglotDir", XrmoptionSepArg, NULL },
1741 { "-usePolyglotBook", "usePolyglotBook", XrmoptionSepArg, NULL },
1742 { "-polyglotBook", "polyglotBook", XrmoptionSepArg, NULL },
1743 { "-defaultHashSize", "defaultHashSize", XrmoptionSepArg, NULL },
1744 { "-defaultCacheSizeEGTB", "defaultCacheSizeEGTB", XrmoptionSepArg, NULL },
1745 { "-defaultPathEGTB", "defaultPathEGTB", XrmoptionSepArg, NULL },
1746 { "-defaultFrcPosition", "defaultFrcPosition", XrmoptionSepArg, NULL },
1747 { "-gameListTags", "gameListTags", XrmoptionSepArg, NULL },
1748 // [HGM] I am sure AS added many more options, but we have to fish them out, from the list in winboard.c
1750 /* [HGM,HR] User-selectable board size */
1751 { "-boardWidth", "boardWidth", XrmoptionSepArg, NULL },
1752 { "-boardHeight", "boardHeight", XrmoptionSepArg, NULL },
1753 { "-matchPause", "matchPause", XrmoptionSepArg, NULL },
1755 /* [HGM] new arguments of 4.3.xx. All except first three are back-end options, which should work immediately */
1756 { "-holdingsSize", "holdingsSize", XrmoptionSepArg, NULL }, // requires extensive front-end changes to work
1757 { "-flipBlack", "flipBlack", XrmoptionSepArg, NULL }, // requires front-end changes to work
1758 { "-allWhite", "allWhite", XrmoptionSepArg, NULL }, // requires front-end changes to work
1759 { "-pieceToCharTable", "pieceToCharTable", XrmoptionSepArg, NULL },
1760 { "-alphaRank", "alphaRank", XrmoptionSepArg, NULL },
1761 { "-testClaims", "testClaims", XrmoptionSepArg, NULL },
1762 { "-checkMates", "checkMates", XrmoptionSepArg, NULL },
1763 { "-materialDraws", "materialDraws", XrmoptionSepArg, NULL },
1764 { "-trivialDraws", "trivialDraws", XrmoptionSepArg, NULL },
1765 { "-ruleMoves", "ruleMoves", XrmoptionSepArg, NULL },
1766 { "-repeatsToDraw", "repeatsToDraw", XrmoptionSepArg, NULL },
1767 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1768 { "-userName", "userName", XrmoptionSepArg, NULL },
1769 { "-autoKibitz", "autoKibitz", XrmoptionNoArg, "True" },
1770 { "-firstTimeOdds", "firstTimeOdds", XrmoptionSepArg, NULL },
1771 { "-secondTimeOdds", "secondTimeOdds", XrmoptionSepArg, NULL },
1772 { "-timeOddsMode", "timeOddsMode", XrmoptionSepArg, NULL },
1773 { "-firstAccumulateTC", "firstAccumulateTC", XrmoptionSepArg, NULL },
1774 { "-secondAccumulateTC", "secondAccumulateTC", XrmoptionSepArg, NULL },
1775 { "-firstNPS", "firstNPS", XrmoptionSepArg, NULL },
1776 { "-secondNPS", "secondNPS", XrmoptionSepArg, NULL },
1777 { "-serverMoves", "serverMoves", XrmoptionSepArg, NULL },
1778 { "-serverPause", "serverPause", XrmoptionSepArg, NULL },
1779 { "-suppressLoadMoves", "suppressLoadMoves", XrmoptionSepArg, NULL },
1780 { "-egtFormats", "egtFormats", XrmoptionSepArg, NULL },
1781 { "-userName", "userName", XrmoptionSepArg, NULL },
1782 { "-smpCores", "smpCores", XrmoptionSepArg, NULL },
1783 { "-sameColorGames", "sameColorGames", XrmoptionSepArg, NULL },
1784 { "-rewindIndex", "rewindIndex", XrmoptionSepArg, NULL },
1785 { "-niceEngines", "niceEngines", XrmoptionSepArg, NULL },
1786 { "-delayBeforeQuit", "delayBeforeQuit", XrmoptionSepArg, NULL },
1787 { "-delayAfterQuit", "delayAfterQuit", XrmoptionSepArg, NULL },
1788 { "-nameOfDebugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1789 { "-debugFile", "nameOfDebugFile", XrmoptionSepArg, NULL },
1790 { "-engineDebugOutput", "engineDebugOutput", XrmoptionSepArg, NULL },
1791 { "-noGUI", "noGUI", XrmoptionNoArg, "True" },
1792 { "-firstOptions", "firstOptions", XrmoptionSepArg, NULL },
1793 { "-secondOptions", "secondOptions", XrmoptionSepArg, NULL },
1794 { "-firstNeedsNoncompliantFEN", "firstNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1795 { "-secondNeedsNoncompliantFEN", "secondNeedsNoncompliantFEN", XrmoptionSepArg, NULL },
1796 { "-keepAlive", "keepAlive", XrmoptionSepArg, NULL },
1797 { "-forceIllegalMoves", "forceIllegalMoves", XrmoptionNoArg, "True" },
1798 { "-keepLineBreaksICS", "keepLineBreaksICS", XrmoptionSepArg, NULL },
1799 { "-wrapContinuationSequence", "wrapContinuationSequence", XrmoptionSepArg, NULL },
1800 { "-useInternalWrap", "useInternalWrap", XrmoptionSepArg, NULL },
1801 { "-autoDisplayTags", "autoDisplayTags", XrmoptionSepArg, NULL },
1802 { "-autoDisplayComment", "autoDisplayComment", XrmoptionSepArg, NULL },
1803 { "-pasteSelection", "pasteSelection", XrmoptionSepArg, NULL },
1806 XtActionsRec boardActions[] = {
1807 { "DrawPosition", DrawPositionProc },
1808 { "HandleUserMove", HandleUserMove },
1809 { "AnimateUserMove", AnimateUserMove },
1810 { "FileNameAction", FileNameAction },
1811 { "AskQuestionProc", AskQuestionProc },
1812 { "AskQuestionReplyAction", AskQuestionReplyAction },
1813 { "PieceMenuPopup", PieceMenuPopup },
1814 { "WhiteClock", WhiteClock },
1815 { "BlackClock", BlackClock },
1816 { "Iconify", Iconify },
1817 { "ResetProc", ResetProc },
1818 { "LoadGameProc", LoadGameProc },
1819 { "LoadNextGameProc", LoadNextGameProc },
1820 { "LoadPrevGameProc", LoadPrevGameProc },
1821 { "LoadSelectedProc", LoadSelectedProc },
1822 { "ReloadGameProc", ReloadGameProc },
1823 { "LoadPositionProc", LoadPositionProc },
1824 { "LoadNextPositionProc", LoadNextPositionProc },
1825 { "LoadPrevPositionProc", LoadPrevPositionProc },
1826 { "ReloadPositionProc", ReloadPositionProc },
1827 { "CopyPositionProc", CopyPositionProc },
1828 { "PastePositionProc", PastePositionProc },
1829 { "CopyGameProc", CopyGameProc },
1830 { "PasteGameProc", PasteGameProc },
1831 { "SaveGameProc", SaveGameProc },
1832 { "SavePositionProc", SavePositionProc },
1833 { "MailMoveProc", MailMoveProc },
1834 { "ReloadCmailMsgProc", ReloadCmailMsgProc },
1835 { "QuitProc", QuitProc },
1836 { "MachineWhiteProc", MachineWhiteProc },
1837 { "MachineBlackProc", MachineBlackProc },
1838 { "AnalysisModeProc", AnalyzeModeProc },
1839 { "AnalyzeFileProc", AnalyzeFileProc },
1840 { "TwoMachinesProc", TwoMachinesProc },
1841 { "IcsClientProc", IcsClientProc },
1842 { "EditGameProc", EditGameProc },
1843 { "EditPositionProc", EditPositionProc },
1844 { "TrainingProc", EditPositionProc },
1845 { "EngineOutputProc", EngineOutputProc}, // [HGM] Winboard_x engine-output window
1846 { "ShowGameListProc", ShowGameListProc },
1847 { "ShowMoveListProc", HistoryShowProc},
1848 { "EditTagsProc", EditCommentProc },
1849 { "EditCommentProc", EditCommentProc },
1850 { "IcsAlarmProc", IcsAlarmProc },
1851 { "IcsInputBoxProc", IcsInputBoxProc },
1852 { "PauseProc", PauseProc },
1853 { "AcceptProc", AcceptProc },
1854 { "DeclineProc", DeclineProc },
1855 { "RematchProc", RematchProc },
1856 { "CallFlagProc", CallFlagProc },
1857 { "DrawProc", DrawProc },
1858 { "AdjournProc", AdjournProc },
1859 { "AbortProc", AbortProc },
1860 { "ResignProc", ResignProc },
1861 { "AdjuWhiteProc", AdjuWhiteProc },
1862 { "AdjuBlackProc", AdjuBlackProc },
1863 { "AdjuDrawProc", AdjuDrawProc },
1864 { "EnterKeyProc", EnterKeyProc },
1865 { "StopObservingProc", StopObservingProc },
1866 { "StopExaminingProc", StopExaminingProc },
1867 { "BackwardProc", BackwardProc },
1868 { "ForwardProc", ForwardProc },
1869 { "ToStartProc", ToStartProc },
1870 { "ToEndProc", ToEndProc },
1871 { "RevertProc", RevertProc },
1872 { "TruncateGameProc", TruncateGameProc },
1873 { "MoveNowProc", MoveNowProc },
1874 { "RetractMoveProc", RetractMoveProc },
1875 { "AlwaysQueenProc", AlwaysQueenProc },
1876 { "AnimateDraggingProc", AnimateDraggingProc },
1877 { "AnimateMovingProc", AnimateMovingProc },
1878 { "AutoflagProc", AutoflagProc },
1879 { "AutoflipProc", AutoflipProc },
1880 { "AutobsProc", AutobsProc },
1881 { "AutoraiseProc", AutoraiseProc },
1882 { "AutosaveProc", AutosaveProc },
1883 { "BlindfoldProc", BlindfoldProc },
1884 { "FlashMovesProc", FlashMovesProc },
1885 { "FlipViewProc", FlipViewProc },
1886 { "GetMoveListProc", GetMoveListProc },
1888 { "HighlightDraggingProc", HighlightDraggingProc },
1890 { "HighlightLastMoveProc", HighlightLastMoveProc },
1891 { "IcsAlarmProc", IcsAlarmProc },
1892 { "MoveSoundProc", MoveSoundProc },
1893 { "OldSaveStyleProc", OldSaveStyleProc },
1894 { "PeriodicUpdatesProc", PeriodicUpdatesProc },
1895 { "PonderNextMoveProc", PonderNextMoveProc },
1896 { "PopupExitMessageProc", PopupExitMessageProc },
1897 { "PopupMoveErrorsProc", PopupMoveErrorsProc },
1898 { "PremoveProc", PremoveProc },
1899 { "QuietPlayProc", QuietPlayProc },
1900 { "ShowCoordsProc", ShowCoordsProc },
1901 { "ShowThinkingProc", ShowThinkingProc },
1902 { "HideThinkingProc", HideThinkingProc },
1903 { "TestLegalityProc", TestLegalityProc },
1904 { "InfoProc", InfoProc },
1905 { "ManProc", ManProc },
1906 { "HintProc", HintProc },
1907 { "BookProc", BookProc },
1908 { "AboutGameProc", AboutGameProc },
1909 { "AboutProc", AboutProc },
1910 { "DebugProc", DebugProc },
1911 { "NothingProc", NothingProc },
1912 { "CommentPopDown", (XtActionProc) CommentPopDown },
1913 { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
1914 { "TagsPopDown", (XtActionProc) TagsPopDown },
1915 { "ErrorPopDown", (XtActionProc) ErrorPopDown },
1916 { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
1917 { "FileNamePopDown", (XtActionProc) FileNamePopDown },
1918 { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
1919 { "GameListPopDown", (XtActionProc) GameListPopDown },
1920 { "PromotionPopDown", (XtActionProc) PromotionPopDown },
1921 { "HistoryPopDown", (XtActionProc) HistoryPopDown },
1922 { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
1923 { "ShufflePopDown", (XtActionProc) ShufflePopDown },
1924 { "EnginePopDown", (XtActionProc) EnginePopDown },
1925 { "UciPopDown", (XtActionProc) UciPopDown },
1926 { "TimeControlPopDown", (XtActionProc) TimeControlPopDown },
1927 { "NewVariantPopDown", (XtActionProc) NewVariantPopDown },
1928 { "SettingsPopDown", (XtActionProc) SettingsPopDown },
1931 char globalTranslations[] =
1932 ":<Key>R: ResignProc() \n \
1933 :<Key>r: ResetProc() \n \
1934 :<Key>g: LoadGameProc() \n \
1935 :<Key>N: LoadNextGameProc() \n \
1936 :<Key>P: LoadPrevGameProc() \n \
1937 :<Key>Q: QuitProc() \n \
1938 :<Key>F: ToEndProc() \n \
1939 :<Key>f: ForwardProc() \n \
1940 :<Key>B: ToStartProc() \n \
1941 :<Key>b: BackwardProc() \n \
1942 :<Key>p: PauseProc() \n \
1943 :<Key>d: DrawProc() \n \
1944 :<Key>t: CallFlagProc() \n \
1945 :<Key>i: Iconify() \n \
1946 :<Key>c: Iconify() \n \
1947 :<Key>v: FlipViewProc() \n \
1948 <KeyDown>Control_L: BackwardProc() \n \
1949 <KeyUp>Control_L: ForwardProc() \n \
1950 <KeyDown>Control_R: BackwardProc() \n \
1951 <KeyUp>Control_R: ForwardProc() \n \
1952 Shift<Key>1: AskQuestionProc(\"Direct command\",\
1953 \"Send to chess program:\",,1) \n \
1954 Shift<Key>2: AskQuestionProc(\"Direct command\",\
1955 \"Send to second chess program:\",,2) \n";
1957 char boardTranslations[] =
1958 "<Btn1Down>: HandleUserMove() \n \
1959 <Btn1Up>: HandleUserMove() \n \
1960 <Btn1Motion>: AnimateUserMove() \n \
1961 Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
1962 PieceMenuPopup(menuB) \n \
1963 Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
1964 PieceMenuPopup(menuW) \n \
1965 Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
1966 PieceMenuPopup(menuW) \n \
1967 Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
1968 PieceMenuPopup(menuB) \n";
1970 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
1971 char blackTranslations[] = "<BtnDown>: BlackClock()\n";
1973 char ICSInputTranslations[] =
1974 "<Key>Return: EnterKeyProc() \n";
1976 String xboardResources[] = {
1977 "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
1978 "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
1979 "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
1984 /* Max possible square size */
1985 #define MAXSQSIZE 256
1987 static int xpm_avail[MAXSQSIZE];
1989 #ifdef HAVE_DIR_STRUCT
1991 /* Extract piece size from filename */
1993 xpm_getsize(name, len, ext)
2004 if ((p=strchr(name, '.')) == NULL ||
2005 StrCaseCmp(p+1, ext) != 0)
2011 while (*p && isdigit(*p))
2018 /* Setup xpm_avail */
2020 xpm_getavail(dirname, ext)
2028 for (i=0; i<MAXSQSIZE; ++i)
2031 if (appData.debugMode)
2032 fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
2034 dir = opendir(dirname);
2037 fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
2038 programName, dirname);
2042 while ((ent=readdir(dir)) != NULL) {
2043 i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
2044 if (i > 0 && i < MAXSQSIZE)
2054 xpm_print_avail(fp, ext)
2060 fprintf(fp, _("Available `%s' sizes:\n"), ext);
2061 for (i=1; i<MAXSQSIZE; ++i) {
2067 /* Return XPM piecesize closest to size */
2069 xpm_closest_to(dirname, size, ext)
2075 int sm_diff = MAXSQSIZE;
2079 xpm_getavail(dirname, ext);
2081 if (appData.debugMode)
2082 xpm_print_avail(stderr, ext);
2084 for (i=1; i<MAXSQSIZE; ++i) {
2087 diff = (diff<0) ? -diff : diff;
2088 if (diff < sm_diff) {
2096 fprintf(stderr, _("Error: No `%s' files!\n"), ext);
2102 #else /* !HAVE_DIR_STRUCT */
2103 /* If we are on a system without a DIR struct, we can't
2104 read the directory, so we can't collect a list of
2105 filenames, etc., so we can't do any size-fitting. */
2107 xpm_closest_to(dirname, size, ext)
2112 fprintf(stderr, _("\
2113 Warning: No DIR structure found on this system --\n\
2114 Unable to autosize for XPM/XIM pieces.\n\
2115 Please report this error to frankm@hiwaay.net.\n\
2116 Include system type & operating system in message.\n"));
2119 #endif /* HAVE_DIR_STRUCT */
2121 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
2122 "magenta", "cyan", "white" };
2126 TextColors textColors[(int)NColorClasses];
2128 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
2130 parse_color(str, which)
2134 char *p, buf[100], *d;
2137 if (strlen(str) > 99) /* watch bounds on buf */
2142 for (i=0; i<which; ++i) {
2149 /* Could be looking at something like:
2151 .. in which case we want to stop on a comma also */
2152 while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
2156 return -1; /* Use default for empty field */
2159 if (which == 2 || isdigit(*p))
2162 while (*p && isalpha(*p))
2167 for (i=0; i<8; ++i) {
2168 if (!StrCaseCmp(buf, cnames[i]))
2169 return which? (i+40) : (i+30);
2171 if (!StrCaseCmp(buf, "default")) return -1;
2173 fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
2178 parse_cpair(cc, str)
2182 if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
2183 fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
2188 /* bg and attr are optional */
2189 textColors[(int)cc].bg = parse_color(str, 1);
2190 if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {
2191 textColors[(int)cc].attr = 0;
2197 /* Arrange to catch delete-window events */
2198 Atom wm_delete_window;
2200 CatchDeleteWindow(Widget w, String procname)
2203 XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
2204 snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
2205 XtAugmentTranslations(w, XtParseTranslationTable(buf));
2212 XtSetArg(args[0], XtNiconic, False);
2213 XtSetValues(shellWidget, args, 1);
2215 XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
2219 // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
2221 #define BoardSize int
2222 void InitDrawingSizes(BoardSize boardSize, int flags)
2223 { // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
2224 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2226 XtGeometryResult gres;
2229 if(!formWidget) return;
2232 * Enable shell resizing.
2234 shellArgs[0].value = (XtArgVal) &w;
2235 shellArgs[1].value = (XtArgVal) &h;
2236 XtGetValues(shellWidget, shellArgs, 2);
2238 shellArgs[4].value = 2*w; shellArgs[2].value = 10;
2239 shellArgs[5].value = 2*h; shellArgs[3].value = 10;
2240 XtSetValues(shellWidget, &shellArgs[2], 4);
2242 XtSetArg(args[0], XtNdefaultDistance, &sep);
2243 XtGetValues(formWidget, args, 1);
2245 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2246 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2249 XtSetArg(args[0], XtNwidth, boardWidth);
2250 XtSetArg(args[1], XtNheight, boardHeight);
2251 XtSetValues(boardWidget, args, 2);
2253 timerWidth = (boardWidth - sep) / 2;
2254 XtSetArg(args[0], XtNwidth, timerWidth);
2255 XtSetValues(whiteTimerWidget, args, 1);
2256 XtSetValues(blackTimerWidget, args, 1);
2258 XawFormDoLayout(formWidget, False);
2260 if (appData.titleInWindow) {
2262 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2263 XtSetArg(args[i], XtNheight, &h); i++;
2264 XtGetValues(titleWidget, args, i);
2266 w = boardWidth - 2*bor;
2268 XtSetArg(args[0], XtNwidth, &w);
2269 XtGetValues(menuBarWidget, args, 1);
2270 w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
2273 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2274 if (gres != XtGeometryYes && appData.debugMode) {
2276 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2277 programName, gres, w, h, wr, hr);
2281 XawFormDoLayout(formWidget, True);
2284 * Inhibit shell resizing.
2286 shellArgs[0].value = w = (XtArgVal) boardWidth + marginW;
2287 shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
2288 shellArgs[4].value = shellArgs[2].value = w;
2289 shellArgs[5].value = shellArgs[3].value = h;
2290 XtSetValues(shellWidget, &shellArgs[0], 6);
2292 // [HGM] pieces: tailor piece bitmaps to needs of specific variant
2295 for(i=0; i<4; i++) {
2297 for(p=0; p<=(int)WhiteKing; p++)
2298 xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
2299 if(gameInfo.variant == VariantShogi) {
2300 xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
2301 xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
2302 xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
2303 xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
2304 xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
2307 if(gameInfo.variant == VariantGothic) {
2308 xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
2312 // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
2313 for(p=0; p<=(int)WhiteKing; p++)
2314 ximMaskPm[p] = ximMaskPm2[p]; // defaults
2315 if(gameInfo.variant == VariantShogi) {
2316 ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
2317 ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
2318 ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
2319 ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
2320 ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
2323 if(gameInfo.variant == VariantGothic) {
2324 ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
2330 for(i=0; i<2; i++) {
2332 for(p=0; p<=(int)WhiteKing; p++)
2333 pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
2334 if(gameInfo.variant == VariantShogi) {
2335 pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
2336 pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
2337 pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
2338 pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
2339 pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
2342 if(gameInfo.variant == VariantGothic) {
2343 pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
2354 void EscapeExpand(char *p, char *q)
2355 { // [HGM] initstring: routine to shape up string arguments
2356 while(*p++ = *q++) if(p[-1] == '\\')
2358 case 'n': p[-1] = '\n'; break;
2359 case 'r': p[-1] = '\r'; break;
2360 case 't': p[-1] = '\t'; break;
2361 case '\\': p[-1] = '\\'; break;
2362 case 0: *p = 0; return;
2363 default: p[-1] = q[-1]; break;
2372 int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
2373 XSetWindowAttributes window_attributes;
2375 Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
2376 XrmValue vFrom, vTo;
2377 XtGeometryResult gres;
2380 int forceMono = False;
2383 // [HGM] before anything else, expand any indirection files amongst options
2384 char *argvCopy[1000]; // 1000 seems enough
2385 char newArgs[10000]; // holds actual characters
2388 srandom(time(0)); // [HGM] book: make random truly random
2391 for(i=0; i<argc; i++) {
2392 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2393 //fprintf(stderr, "arg %s\n", argv[i]);
2394 if(argv[i][0] != '@') argvCopy[j++] = argv[i]; else {
2396 FILE *f = fopen(argv[i]+1, "rb");
2397 if(f == NULL) { fprintf(stderr, _("ignore %s\n"), argv[i]); continue; } // do not expand non-existing
2398 argvCopy[j++] = newArgs + k; // get ready for first argument from file
2399 while((c = fgetc(f)) != EOF) { // each line of file inserts 1 argument in the list
2401 if(j >= 1000-2) { printf(_("too many arguments\n")); exit(-1); }
2402 newArgs[k++] = 0; // terminate current arg
2403 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2404 argvCopy[j++] = newArgs + k; // get ready for next
2406 if(k >= 10000-1) { printf(_("too long arguments\n")); exit(-1); }
2420 setbuf(stdout, NULL);
2421 setbuf(stderr, NULL);
2424 programName = strrchr(argv[0], '/');
2425 if (programName == NULL)
2426 programName = argv[0];
2431 XtSetLanguageProc(NULL, NULL, NULL);
2432 bindtextdomain(PACKAGE, LOCALEDIR);
2433 textdomain(PACKAGE);
2437 XtAppInitialize(&appContext, "XBoard", shellOptions,
2438 XtNumber(shellOptions),
2439 &argc, argv, xboardResources, NULL, 0);
2441 { /* left over command line arguments, print out help and exit.
2442 * Use two columns to print help
2444 fprintf(stderr, _("%s: unrecognized argument %s\n"),
2445 programName, argv[1]);
2447 fprintf(stderr, "Recognized options:\n");
2448 for(i = 0; i < XtNumber(shellOptions); i++)
2450 /* print first column */
2451 j = fprintf(stderr, " %s%s", shellOptions[i].option,
2452 (shellOptions[i].argKind == XrmoptionSepArg
2454 /* print second column and end line */
2455 if (++i < XtNumber(shellOptions))
2457 fprintf(stderr, "%*c%s%s\n", 40 - j, ' ',
2458 shellOptions[i].option,
2459 (shellOptions[i].argKind == XrmoptionSepArg
2464 fprintf(stderr, "\n");
2471 if (p == NULL) p = "/tmp";
2472 i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
2473 gameCopyFilename = (char*) malloc(i);
2474 gamePasteFilename = (char*) malloc(i);
2475 snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
2476 snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
2478 XtGetApplicationResources(shellWidget, (XtPointer) &appData,
2479 clientResources, XtNumber(clientResources),
2482 { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
2483 static char buf[MSG_SIZ];
2484 EscapeExpand(buf, appData.initString);
2485 appData.initString = strdup(buf);
2486 EscapeExpand(buf, appData.secondInitString);
2487 appData.secondInitString = strdup(buf);
2488 EscapeExpand(buf, appData.firstComputerString);
2489 appData.firstComputerString = strdup(buf);
2490 EscapeExpand(buf, appData.secondComputerString);
2491 appData.secondComputerString = strdup(buf);
2494 if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
2497 if (chdir(chessDir) != 0) {
2498 fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
2504 if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
2505 /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
2506 if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL) {
2507 printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
2510 setbuf(debugFP, NULL);
2513 /* [HGM,HR] make sure board size is acceptable */
2514 if(appData.NrFiles > BOARD_SIZE ||
2515 appData.NrRanks > BOARD_SIZE )
2516 DisplayFatalError(_("Recompile with BOARD_SIZE > 12, to support this size"), 0, 2);
2519 /* This feature does not work; animation needs a rewrite */
2520 appData.highlightDragging = FALSE;
2524 xDisplay = XtDisplay(shellWidget);
2525 xScreen = DefaultScreen(xDisplay);
2526 wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
2528 gameInfo.variant = StringToVariant(appData.variant);
2529 InitPosition(FALSE);
2532 InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
2534 if (isdigit(appData.boardSize[0])) {
2535 i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
2536 &lineGap, &clockFontPxlSize, &coordFontPxlSize,
2537 &fontPxlSize, &smallLayout, &tinyLayout);
2539 fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
2540 programName, appData.boardSize);
2544 /* Find some defaults; use the nearest known size */
2545 SizeDefaults *szd, *nearest;
2546 int distance = 99999;
2547 nearest = szd = sizeDefaults;
2548 while (szd->name != NULL) {
2549 if (abs(szd->squareSize - squareSize) < distance) {
2551 distance = abs(szd->squareSize - squareSize);
2552 if (distance == 0) break;
2556 if (i < 2) lineGap = nearest->lineGap;
2557 if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
2558 if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
2559 if (i < 5) fontPxlSize = nearest->fontPxlSize;
2560 if (i < 6) smallLayout = nearest->smallLayout;
2561 if (i < 7) tinyLayout = nearest->tinyLayout;
2564 SizeDefaults *szd = sizeDefaults;
2565 if (*appData.boardSize == NULLCHAR) {
2566 while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
2567 DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
2570 if (szd->name == NULL) szd--;
2572 while (szd->name != NULL &&
2573 StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
2574 if (szd->name == NULL) {
2575 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
2576 programName, appData.boardSize);
2580 squareSize = szd->squareSize;
2581 lineGap = szd->lineGap;
2582 clockFontPxlSize = szd->clockFontPxlSize;
2583 coordFontPxlSize = szd->coordFontPxlSize;
2584 fontPxlSize = szd->fontPxlSize;
2585 smallLayout = szd->smallLayout;
2586 tinyLayout = szd->tinyLayout;
2589 /* Now, using squareSize as a hint, find a good XPM/XIM set size */
2590 if (strlen(appData.pixmapDirectory) > 0) {
2591 p = ExpandPathName(appData.pixmapDirectory);
2593 fprintf(stderr, _("Error expanding path name \"%s\"\n"),
2594 appData.pixmapDirectory);
2597 if (appData.debugMode) {
2598 fprintf(stderr, _("\
2599 XBoard square size (hint): %d\n\
2600 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
2602 squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
2603 if (appData.debugMode) {
2604 fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
2608 /* [HR] height treated separately (hacked) */
2609 boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
2610 boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2611 if (appData.showJail == 1) {
2612 /* Jail on top and bottom */
2613 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2614 XtSetArg(boardArgs[2], XtNheight,
2615 boardHeight + 2*(lineGap + squareSize));
2616 } else if (appData.showJail == 2) {
2618 XtSetArg(boardArgs[1], XtNwidth,
2619 boardWidth + 2*(lineGap + squareSize));
2620 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2623 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2624 XtSetArg(boardArgs[2], XtNheight, boardHeight);
2628 * Determine what fonts to use.
2630 appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
2631 clockFontID = XLoadFont(xDisplay, appData.clockFont);
2632 clockFontStruct = XQueryFont(xDisplay, clockFontID);
2633 appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
2634 coordFontID = XLoadFont(xDisplay, appData.coordFont);
2635 coordFontStruct = XQueryFont(xDisplay, coordFontID);
2636 appData.font = FindFont(appData.font, fontPxlSize);
2637 countFontID = XLoadFont(xDisplay, appData.coordFont); // [HGM] holdings
2638 countFontStruct = XQueryFont(xDisplay, countFontID);
2639 // appData.font = FindFont(appData.font, fontPxlSize);
2641 xdb = XtDatabase(xDisplay);
2642 XrmPutStringResource(&xdb, "*font", appData.font);
2645 * Detect if there are not enough colors available and adapt.
2647 if (DefaultDepth(xDisplay, xScreen) <= 2) {
2648 appData.monoMode = True;
2651 if (!appData.monoMode) {
2652 vFrom.addr = (caddr_t) appData.lightSquareColor;
2653 vFrom.size = strlen(appData.lightSquareColor);
2654 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2655 if (vTo.addr == NULL) {
2656 appData.monoMode = True;
2659 lightSquareColor = *(Pixel *) vTo.addr;
2662 if (!appData.monoMode) {
2663 vFrom.addr = (caddr_t) appData.darkSquareColor;
2664 vFrom.size = strlen(appData.darkSquareColor);
2665 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2666 if (vTo.addr == NULL) {
2667 appData.monoMode = True;
2670 darkSquareColor = *(Pixel *) vTo.addr;
2673 if (!appData.monoMode) {
2674 vFrom.addr = (caddr_t) appData.whitePieceColor;
2675 vFrom.size = strlen(appData.whitePieceColor);
2676 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2677 if (vTo.addr == NULL) {
2678 appData.monoMode = True;
2681 whitePieceColor = *(Pixel *) vTo.addr;
2684 if (!appData.monoMode) {
2685 vFrom.addr = (caddr_t) appData.blackPieceColor;
2686 vFrom.size = strlen(appData.blackPieceColor);
2687 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2688 if (vTo.addr == NULL) {
2689 appData.monoMode = True;
2692 blackPieceColor = *(Pixel *) vTo.addr;
2696 if (!appData.monoMode) {
2697 vFrom.addr = (caddr_t) appData.highlightSquareColor;
2698 vFrom.size = strlen(appData.highlightSquareColor);
2699 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2700 if (vTo.addr == NULL) {
2701 appData.monoMode = True;
2704 highlightSquareColor = *(Pixel *) vTo.addr;
2708 if (!appData.monoMode) {
2709 vFrom.addr = (caddr_t) appData.premoveHighlightColor;
2710 vFrom.size = strlen(appData.premoveHighlightColor);
2711 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2712 if (vTo.addr == NULL) {
2713 appData.monoMode = True;
2716 premoveHighlightColor = *(Pixel *) vTo.addr;
2721 fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
2724 if (appData.bitmapDirectory == NULL ||
2725 appData.bitmapDirectory[0] == NULLCHAR)
2726 appData.bitmapDirectory = DEF_BITMAP_DIR;
2729 if (appData.lowTimeWarning && !appData.monoMode) {
2730 vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
2731 vFrom.size = strlen(appData.lowTimeWarningColor);
2732 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2733 if (vTo.addr == NULL)
2734 appData.monoMode = True;
2736 lowTimeWarningColor = *(Pixel *) vTo.addr;
2739 if (appData.monoMode && appData.debugMode) {
2740 fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
2741 (unsigned long) XWhitePixel(xDisplay, xScreen),
2742 (unsigned long) XBlackPixel(xDisplay, xScreen));
2745 if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
2746 parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
2747 parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
2748 parse_cpair(ColorChannel, appData.colorChannel) < 0 ||
2749 parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||
2750 parse_cpair(ColorTell, appData.colorTell) < 0 ||
2751 parse_cpair(ColorChallenge, appData.colorChallenge) < 0 ||
2752 parse_cpair(ColorRequest, appData.colorRequest) < 0 ||
2753 parse_cpair(ColorSeek, appData.colorSeek) < 0 ||
2754 parse_cpair(ColorNormal, appData.colorNormal) < 0)
2756 if (appData.colorize) {
2758 _("%s: can't parse color names; disabling colorization\n"),
2761 appData.colorize = FALSE;
2763 textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
2764 textColors[ColorNone].attr = 0;
2766 XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
2772 layoutName = "tinyLayout";
2773 } else if (smallLayout) {
2774 layoutName = "smallLayout";
2776 layoutName = "normalLayout";
2778 /* Outer layoutWidget is there only to provide a name for use in
2779 resources that depend on the layout style */
2781 XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
2782 layoutArgs, XtNumber(layoutArgs));
2784 XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
2785 formArgs, XtNumber(formArgs));
2786 XtSetArg(args[0], XtNdefaultDistance, &sep);
2787 XtGetValues(formWidget, args, 1);
2790 widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
2791 XtSetArg(args[0], XtNtop, XtChainTop);
2792 XtSetArg(args[1], XtNbottom, XtChainTop);
2793 XtSetArg(args[2], XtNright, XtChainLeft);
2794 XtSetValues(menuBarWidget, args, 3);
2796 widgetList[j++] = whiteTimerWidget =
2797 XtCreateWidget("whiteTime", labelWidgetClass,
2798 formWidget, timerArgs, XtNumber(timerArgs));
2799 XtSetArg(args[0], XtNfont, clockFontStruct);
2800 XtSetArg(args[1], XtNtop, XtChainTop);
2801 XtSetArg(args[2], XtNbottom, XtChainTop);
2802 XtSetValues(whiteTimerWidget, args, 3);
2804 widgetList[j++] = blackTimerWidget =
2805 XtCreateWidget("blackTime", labelWidgetClass,
2806 formWidget, timerArgs, XtNumber(timerArgs));
2807 XtSetArg(args[0], XtNfont, clockFontStruct);
2808 XtSetArg(args[1], XtNtop, XtChainTop);
2809 XtSetArg(args[2], XtNbottom, XtChainTop);
2810 XtSetValues(blackTimerWidget, args, 3);
2812 if (appData.titleInWindow) {
2813 widgetList[j++] = titleWidget =
2814 XtCreateWidget("title", labelWidgetClass, formWidget,
2815 titleArgs, XtNumber(titleArgs));
2816 XtSetArg(args[0], XtNtop, XtChainTop);
2817 XtSetArg(args[1], XtNbottom, XtChainTop);
2818 XtSetValues(titleWidget, args, 2);
2821 if (appData.showButtonBar) {
2822 widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
2823 XtSetArg(args[0], XtNleft, XtChainRight); // [HGM] glue to right window edge
2824 XtSetArg(args[1], XtNright, XtChainRight); // for good run-time sizing
2825 XtSetArg(args[2], XtNtop, XtChainTop);
2826 XtSetArg(args[3], XtNbottom, XtChainTop);
2827 XtSetValues(buttonBarWidget, args, 4);
2830 widgetList[j++] = messageWidget =
2831 XtCreateWidget("message", labelWidgetClass, formWidget,
2832 messageArgs, XtNumber(messageArgs));
2833 XtSetArg(args[0], XtNtop, XtChainTop);
2834 XtSetArg(args[1], XtNbottom, XtChainTop);
2835 XtSetValues(messageWidget, args, 2);
2837 widgetList[j++] = boardWidget =
2838 XtCreateWidget("board", widgetClass, formWidget, boardArgs,
2839 XtNumber(boardArgs));
2841 XtManageChildren(widgetList, j);
2843 timerWidth = (boardWidth - sep) / 2;
2844 XtSetArg(args[0], XtNwidth, timerWidth);
2845 XtSetValues(whiteTimerWidget, args, 1);
2846 XtSetValues(blackTimerWidget, args, 1);
2848 XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
2849 XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
2850 XtGetValues(whiteTimerWidget, args, 2);
2852 if (appData.showButtonBar) {
2853 XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
2854 XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
2855 XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
2859 * formWidget uses these constraints but they are stored
2863 XtSetArg(args[i], XtNfromHoriz, 0); i++;
2864 XtSetValues(menuBarWidget, args, i);
2865 if (appData.titleInWindow) {
2868 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2869 XtSetValues(whiteTimerWidget, args, i);
2871 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2872 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2873 XtSetValues(blackTimerWidget, args, i);
2875 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2876 XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
2877 XtSetValues(titleWidget, args, i);
2879 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2880 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2881 XtSetValues(messageWidget, args, i);
2882 if (appData.showButtonBar) {
2884 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2885 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2886 XtSetValues(buttonBarWidget, args, i);
2890 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2891 XtSetValues(whiteTimerWidget, args, i);
2893 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2894 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2895 XtSetValues(blackTimerWidget, args, i);
2897 XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
2898 XtSetValues(titleWidget, args, i);
2900 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2901 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2902 XtSetValues(messageWidget, args, i);
2903 if (appData.showButtonBar) {
2905 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2906 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2907 XtSetValues(buttonBarWidget, args, i);
2912 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2913 XtSetValues(whiteTimerWidget, args, i);
2915 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2916 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2917 XtSetValues(blackTimerWidget, args, i);
2919 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2920 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2921 XtSetValues(messageWidget, args, i);
2922 if (appData.showButtonBar) {
2924 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2925 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2926 XtSetValues(buttonBarWidget, args, i);
2930 XtSetArg(args[0], XtNfromVert, messageWidget);
2931 XtSetArg(args[1], XtNtop, XtChainTop);
2932 XtSetArg(args[2], XtNbottom, XtChainBottom);
2933 XtSetArg(args[3], XtNleft, XtChainLeft);
2934 XtSetArg(args[4], XtNright, XtChainRight);
2935 XtSetValues(boardWidget, args, 5);
2937 XtRealizeWidget(shellWidget);
2940 * Correct the width of the message and title widgets.
2941 * It is not known why some systems need the extra fudge term.
2942 * The value "2" is probably larger than needed.
2944 XawFormDoLayout(formWidget, False);
2946 #define WIDTH_FUDGE 2
2948 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2949 XtSetArg(args[i], XtNheight, &h); i++;
2950 XtGetValues(messageWidget, args, i);
2951 if (appData.showButtonBar) {
2953 XtSetArg(args[i], XtNwidth, &w); i++;
2954 XtGetValues(buttonBarWidget, args, i);
2955 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2957 w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
2960 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2961 if (gres != XtGeometryYes && appData.debugMode) {
2962 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2963 programName, gres, w, h, wr, hr);
2966 /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
2967 /* The size used for the child widget in layout lags one resize behind
2968 its true size, so we resize a second time, 1 pixel smaller. Yeech! */
2970 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2971 if (gres != XtGeometryYes && appData.debugMode) {
2972 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2973 programName, gres, w, h, wr, hr);
2976 XtSetArg(args[0], XtNleft, XtChainLeft); // [HGM] glue ends for good run-time sizing
2977 XtSetArg(args[1], XtNright, XtChainRight);
2978 XtSetValues(messageWidget, args, 2);
2980 if (appData.titleInWindow) {
2982 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2983 XtSetArg(args[i], XtNheight, &h); i++;
2984 XtGetValues(titleWidget, args, i);
2986 w = boardWidth - 2*bor;
2988 XtSetArg(args[0], XtNwidth, &w);
2989 XtGetValues(menuBarWidget, args, 1);
2990 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2993 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2994 if (gres != XtGeometryYes && appData.debugMode) {
2996 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2997 programName, gres, w, h, wr, hr);
3000 XawFormDoLayout(formWidget, True);
3002 xBoardWindow = XtWindow(boardWidget);
3004 // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
3005 // not need to go into InitDrawingSizes().
3009 * Create X checkmark bitmap and initialize option menu checks.
3011 ReadBitmap(&xMarkPixmap, "checkmark.bm",
3012 checkmark_bits, checkmark_width, checkmark_height);
3013 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
3014 if (appData.alwaysPromoteToQueen) {
3015 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
3018 if (appData.animateDragging) {
3019 XtSetValues(XtNameToWidget(menuBarWidget,
3020 "menuOptions.Animate Dragging"),
3023 if (appData.animate) {
3024 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
3027 if (appData.autoComment) {
3028 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
3031 if (appData.autoCallFlag) {
3032 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
3035 if (appData.autoFlipView) {
3036 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
3039 if (appData.autoObserve) {
3040 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
3043 if (appData.autoRaiseBoard) {
3044 XtSetValues(XtNameToWidget(menuBarWidget,
3045 "menuOptions.Auto Raise Board"), args, 1);
3047 if (appData.autoSaveGames) {
3048 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3051 if (appData.saveGameFile[0] != NULLCHAR) {
3052 /* Can't turn this off from menu */
3053 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3055 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
3059 if (appData.blindfold) {
3060 XtSetValues(XtNameToWidget(menuBarWidget,
3061 "menuOptions.Blindfold"), args, 1);
3063 if (appData.flashCount > 0) {
3064 XtSetValues(XtNameToWidget(menuBarWidget,
3065 "menuOptions.Flash Moves"),
3068 if (appData.getMoveList) {
3069 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
3073 if (appData.highlightDragging) {
3074 XtSetValues(XtNameToWidget(menuBarWidget,
3075 "menuOptions.Highlight Dragging"),
3079 if (appData.highlightLastMove) {
3080 XtSetValues(XtNameToWidget(menuBarWidget,
3081 "menuOptions.Highlight Last Move"),
3084 if (appData.icsAlarm) {
3085 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
3088 if (appData.ringBellAfterMoves) {
3089 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
3092 if (appData.oldSaveStyle) {
3093 XtSetValues(XtNameToWidget(menuBarWidget,
3094 "menuOptions.Old Save Style"), args, 1);
3096 if (appData.periodicUpdates) {
3097 XtSetValues(XtNameToWidget(menuBarWidget,
3098 "menuOptions.Periodic Updates"), args, 1);
3100 if (appData.ponderNextMove) {
3101 XtSetValues(XtNameToWidget(menuBarWidget,
3102 "menuOptions.Ponder Next Move"), args, 1);
3104 if (appData.popupExitMessage) {
3105 XtSetValues(XtNameToWidget(menuBarWidget,
3106 "menuOptions.Popup Exit Message"), args, 1);
3108 if (appData.popupMoveErrors) {
3109 XtSetValues(XtNameToWidget(menuBarWidget,
3110 "menuOptions.Popup Move Errors"), args, 1);
3112 if (appData.premove) {
3113 XtSetValues(XtNameToWidget(menuBarWidget,
3114 "menuOptions.Premove"), args, 1);
3116 if (appData.quietPlay) {
3117 XtSetValues(XtNameToWidget(menuBarWidget,
3118 "menuOptions.Quiet Play"), args, 1);
3120 if (appData.showCoords) {
3121 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
3124 if (appData.hideThinkingFromHuman) {
3125 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
3128 if (appData.testLegality) {
3129 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
3136 ReadBitmap(&wIconPixmap, "icon_white.bm",
3137 icon_white_bits, icon_white_width, icon_white_height);
3138 ReadBitmap(&bIconPixmap, "icon_black.bm",
3139 icon_black_bits, icon_black_width, icon_black_height);
3140 iconPixmap = wIconPixmap;
3142 XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
3143 XtSetValues(shellWidget, args, i);
3146 * Create a cursor for the board widget.
3148 window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
3149 XChangeWindowAttributes(xDisplay, xBoardWindow,
3150 CWCursor, &window_attributes);
3153 * Inhibit shell resizing.
3155 shellArgs[0].value = (XtArgVal) &w;
3156 shellArgs[1].value = (XtArgVal) &h;
3157 XtGetValues(shellWidget, shellArgs, 2);
3158 shellArgs[4].value = shellArgs[2].value = w;
3159 shellArgs[5].value = shellArgs[3].value = h;
3160 XtSetValues(shellWidget, &shellArgs[2], 4);
3161 marginW = w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
3162 marginH = h - boardHeight;
3164 CatchDeleteWindow(shellWidget, "QuitProc");
3169 if (appData.bitmapDirectory[0] != NULLCHAR) {
3176 /* Create regular pieces */
3177 if (!useImages) CreatePieces();
3182 if (appData.animate || appData.animateDragging)
3185 XtAugmentTranslations(formWidget,
3186 XtParseTranslationTable(globalTranslations));
3187 XtAugmentTranslations(boardWidget,
3188 XtParseTranslationTable(boardTranslations));
3189 XtAugmentTranslations(whiteTimerWidget,
3190 XtParseTranslationTable(whiteTranslations));
3191 XtAugmentTranslations(blackTimerWidget,
3192 XtParseTranslationTable(blackTranslations));
3194 /* Why is the following needed on some versions of X instead
3195 * of a translation? */
3196 XtAddEventHandler(boardWidget, ExposureMask, False,
3197 (XtEventHandler) EventProc, NULL);
3202 if (errorExitStatus == -1) {
3203 if (appData.icsActive) {
3204 /* We now wait until we see "login:" from the ICS before
3205 sending the logon script (problems with timestamp otherwise) */
3206 /*ICSInitScript();*/
3207 if (appData.icsInputBox) ICSInputBoxPopUp();
3211 signal(SIGWINCH, TermSizeSigHandler);
3213 signal(SIGINT, IntSigHandler);
3214 signal(SIGTERM, IntSigHandler);
3215 if (*appData.cmailGameName != NULLCHAR) {
3216 signal(SIGUSR1, CmailSigHandler);
3219 gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
3222 XtAppMainLoop(appContext);
3223 if (appData.debugMode) fclose(debugFP); // [DM] debug
3230 if (appData.icsActive && oldICSInteractionTitle != NULL) {
3231 DisplayIcsInteractionTitle(oldICSInteractionTitle);
3233 unlink(gameCopyFilename);
3234 unlink(gamePasteFilename);
3237 RETSIGTYPE TermSizeSigHandler(int sig)
3250 CmailSigHandler(sig)
3256 signal(SIGUSR1, SIG_IGN); /* suspend handler */
3258 /* Activate call-back function CmailSigHandlerCallBack() */
3259 OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
3261 signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
3265 CmailSigHandlerCallBack(isr, closure, message, count, error)
3273 ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */
3275 /**** end signal code ****/
3285 f = fopen(appData.icsLogon, "r");
3291 strcat(buf, appData.icsLogon);
3292 f = fopen(buf, "r");
3296 ProcessICSInitScript(f);
3303 EditCommentPopDown();
3314 SetMenuEnables(enab)
3318 if (!menuBarWidget) return;
3319 while (enab->name != NULL) {
3320 w = XtNameToWidget(menuBarWidget, enab->name);
3322 DisplayError(enab->name, 0);
3324 XtSetSensitive(w, enab->value);
3330 Enables icsEnables[] = {
3331 { "menuFile.Mail Move", False },
3332 { "menuFile.Reload CMail Message", False },
3333 { "menuMode.Machine Black", False },
3334 { "menuMode.Machine White", False },
3335 { "menuMode.Analysis Mode", False },
3336 { "menuMode.Analyze File", False },
3337 { "menuMode.Two Machines", False },
3339 { "menuHelp.Hint", False },
3340 { "menuHelp.Book", False },
3341 { "menuStep.Move Now", False },
3342 { "menuOptions.Periodic Updates", False },
3343 { "menuOptions.Hide Thinking", False },
3344 { "menuOptions.Ponder Next Move", False },
3349 Enables ncpEnables[] = {
3350 { "menuFile.Mail Move", False },
3351 { "menuFile.Reload CMail Message", False },
3352 { "menuMode.Machine White", False },
3353 { "menuMode.Machine Black", False },
3354 { "menuMode.Analysis Mode", False },
3355 { "menuMode.Analyze File", False },
3356 { "menuMode.Two Machines", False },
3357 { "menuMode.ICS Client", False },
3358 { "menuMode.ICS Input Box", False },
3359 { "Action", False },
3360 { "menuStep.Revert", False },
3361 { "menuStep.Move Now", False },
3362 { "menuStep.Retract Move", False },
3363 { "menuOptions.Auto Comment", False },
3364 { "menuOptions.Auto Flag", False },
3365 { "menuOptions.Auto Flip View", False },
3366 { "menuOptions.Auto Observe", False },
3367 { "menuOptions.Auto Raise Board", False },
3368 { "menuOptions.Get Move List", False },
3369 { "menuOptions.ICS Alarm", False },
3370 { "menuOptions.Move Sound", False },
3371 { "menuOptions.Quiet Play", False },
3372 { "menuOptions.Hide Thinking", False },
3373 { "menuOptions.Periodic Updates", False },
3374 { "menuOptions.Ponder Next Move", False },
3375 { "menuHelp.Hint", False },
3376 { "menuHelp.Book", False },
3380 Enables gnuEnables[] = {
3381 { "menuMode.ICS Client", False },
3382 { "menuMode.ICS Input Box", False },
3383 { "menuAction.Accept", False },
3384 { "menuAction.Decline", False },
3385 { "menuAction.Rematch", False },
3386 { "menuAction.Adjourn", False },
3387 { "menuAction.Stop Examining", False },
3388 { "menuAction.Stop Observing", False },
3389 { "menuStep.Revert", False },
3390 { "menuOptions.Auto Comment", False },
3391 { "menuOptions.Auto Observe", False },
3392 { "menuOptions.Auto Raise Board", False },
3393 { "menuOptions.Get Move List", False },
3394 { "menuOptions.Premove", False },
3395 { "menuOptions.Quiet Play", False },
3397 /* The next two options rely on SetCmailMode being called *after* */
3398 /* SetGNUMode so that when GNU is being used to give hints these */
3399 /* menu options are still available */
3401 { "menuFile.Mail Move", False },
3402 { "menuFile.Reload CMail Message", False },
3406 Enables cmailEnables[] = {
3408 { "menuAction.Call Flag", False },
3409 { "menuAction.Draw", True },
3410 { "menuAction.Adjourn", False },
3411 { "menuAction.Abort", False },
3412 { "menuAction.Stop Observing", False },
3413 { "menuAction.Stop Examining", False },
3414 { "menuFile.Mail Move", True },
3415 { "menuFile.Reload CMail Message", True },
3419 Enables trainingOnEnables[] = {
3420 { "menuMode.Edit Comment", False },
3421 { "menuMode.Pause", False },
3422 { "menuStep.Forward", False },
3423 { "menuStep.Backward", False },
3424 { "menuStep.Forward to End", False },
3425 { "menuStep.Back to Start", False },
3426 { "menuStep.Move Now", False },
3427 { "menuStep.Truncate Game", False },
3431 Enables trainingOffEnables[] = {
3432 { "menuMode.Edit Comment", True },
3433 { "menuMode.Pause", True },
3434 { "menuStep.Forward", True },
3435 { "menuStep.Backward", True },
3436 { "menuStep.Forward to End", True },
3437 { "menuStep.Back to Start", True },
3438 { "menuStep.Move Now", True },
3439 { "menuStep.Truncate Game", True },
3443 Enables machineThinkingEnables[] = {
3444 { "menuFile.Load Game", False },
3445 { "menuFile.Load Next Game", False },
3446 { "menuFile.Load Previous Game", False },
3447 { "menuFile.Reload Same Game", False },
3448 { "menuFile.Paste Game", False },
3449 { "menuFile.Load Position", False },
3450 { "menuFile.Load Next Position", False },
3451 { "menuFile.Load Previous Position", False },
3452 { "menuFile.Reload Same Position", False },
3453 { "menuFile.Paste Position", False },
3454 { "menuMode.Machine White", False },
3455 { "menuMode.Machine Black", False },
3456 { "menuMode.Two Machines", False },
3457 { "menuStep.Retract Move", False },
3461 Enables userThinkingEnables[] = {
3462 { "menuFile.Load Game", True },
3463 { "menuFile.Load Next Game", True },
3464 { "menuFile.Load Previous Game", True },
3465 { "menuFile.Reload Same Game", True },
3466 { "menuFile.Paste Game", True },
3467 { "menuFile.Load Position", True },
3468 { "menuFile.Load Next Position", True },
3469 { "menuFile.Load Previous Position", True },
3470 { "menuFile.Reload Same Position", True },
3471 { "menuFile.Paste Position", True },
3472 { "menuMode.Machine White", True },
3473 { "menuMode.Machine Black", True },
3474 { "menuMode.Two Machines", True },
3475 { "menuStep.Retract Move", True },
3481 SetMenuEnables(icsEnables);
3484 if (appData.zippyPlay && !appData.noChessProgram) /* [DM] icsEngineAnalyze */
3485 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
3492 SetMenuEnables(ncpEnables);
3498 SetMenuEnables(gnuEnables);
3504 SetMenuEnables(cmailEnables);
3510 SetMenuEnables(trainingOnEnables);
3511 if (appData.showButtonBar) {
3512 XtSetSensitive(buttonBarWidget, False);
3518 SetTrainingModeOff()
3520 SetMenuEnables(trainingOffEnables);
3521 if (appData.showButtonBar) {
3522 XtSetSensitive(buttonBarWidget, True);
3527 SetUserThinkingEnables()
3529 if (appData.noChessProgram) return;
3530 SetMenuEnables(userThinkingEnables);
3534 SetMachineThinkingEnables()
3536 if (appData.noChessProgram) return;
3537 SetMenuEnables(machineThinkingEnables);
3539 case MachinePlaysBlack:
3540 case MachinePlaysWhite:
3541 case TwoMachinesPlay:
3542 XtSetSensitive(XtNameToWidget(menuBarWidget,
3543 ModeToWidgetName(gameMode)), True);
3550 #define Abs(n) ((n)<0 ? -(n) : (n))
3553 * Find a font that matches "pattern" that is as close as
3554 * possible to the targetPxlSize. Prefer fonts that are k
3555 * pixels smaller to fonts that are k pixels larger. The
3556 * pattern must be in the X Consortium standard format,
3557 * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
3558 * The return value should be freed with XtFree when no
3561 char *FindFont(pattern, targetPxlSize)
3565 char **fonts, *p, *best, *scalable, *scalableTail;
3566 int i, j, nfonts, minerr, err, pxlSize;
3569 char **missing_list;
3571 char *def_string, *base_fnt_lst, strInt[3];
3573 XFontStruct **fnt_list;
3575 base_fnt_lst = calloc(1, strlen(pattern) + 3);
3576 sprintf(strInt, "%d", targetPxlSize);
3577 p = strstr(pattern, "--");
3578 strncpy(base_fnt_lst, pattern, p - pattern + 2);
3579 strcat(base_fnt_lst, strInt);
3580 strcat(base_fnt_lst, strchr(p + 2, '-'));
3582 if ((fntSet = XCreateFontSet(xDisplay,
3586 &def_string)) == NULL) {
3588 fprintf(stderr, _("Unable to create font set.\n"));
3592 nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
3594 fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
3596 fprintf(stderr, _("%s: no fonts match pattern %s\n"),
3597 programName, pattern);
3605 for (i=0; i<nfonts; i++) {
3608 if (*p != '-') continue;
3610 if (*p == NULLCHAR) break;
3611 if (*p++ == '-') j++;
3613 if (j < 7) continue;
3616 scalable = fonts[i];
3619 err = pxlSize - targetPxlSize;
3620 if (Abs(err) < Abs(minerr) ||
3621 (minerr > 0 && err < 0 && -err == minerr)) {
3627 if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
3628 /* If the error is too big and there is a scalable font,
3629 use the scalable font. */
3630 int headlen = scalableTail - scalable;
3631 p = (char *) XtMalloc(strlen(scalable) + 10);
3632 while (isdigit(*scalableTail)) scalableTail++;
3633 sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
3635 p = (char *) XtMalloc(strlen(best) + 1);
3638 if (appData.debugMode) {
3639 fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
3640 pattern, targetPxlSize, p);
3643 if (missing_count > 0)
3644 XFreeStringList(missing_list);
3645 XFreeFontSet(xDisplay, fntSet);
3647 XFreeFontNames(fonts);
3654 XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
3655 | GCBackground | GCFunction | GCPlaneMask;
3656 XGCValues gc_values;
3659 gc_values.plane_mask = AllPlanes;
3660 gc_values.line_width = lineGap;
3661 gc_values.line_style = LineSolid;
3662 gc_values.function = GXcopy;
3664 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3665 gc_values.background = XBlackPixel(xDisplay, xScreen);
3666 lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3668 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3669 gc_values.background = XWhitePixel(xDisplay, xScreen);
3670 coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
3671 XSetFont(xDisplay, coordGC, coordFontID);
3673 // [HGM] make font for holdings counts (white on black0
3674 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3675 gc_values.background = XBlackPixel(xDisplay, xScreen);
3676 countGC = XtGetGC(shellWidget, value_mask, &gc_values);
3677 XSetFont(xDisplay, countGC, countFontID);
3679 if (appData.monoMode) {
3680 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3681 gc_values.background = XWhitePixel(xDisplay, xScreen);
3682 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3684 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3685 gc_values.background = XBlackPixel(xDisplay, xScreen);
3686 lightSquareGC = wbPieceGC
3687 = XtGetGC(shellWidget, value_mask, &gc_values);
3689 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3690 gc_values.background = XWhitePixel(xDisplay, xScreen);
3691 darkSquareGC = bwPieceGC
3692 = XtGetGC(shellWidget, value_mask, &gc_values);
3694 if (DefaultDepth(xDisplay, xScreen) == 1) {
3695 /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
3696 gc_values.function = GXcopyInverted;
3697 copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);
3698 gc_values.function = GXcopy;
3699 if (XBlackPixel(xDisplay, xScreen) == 1) {
3700 bwPieceGC = darkSquareGC;
3701 wbPieceGC = copyInvertedGC;
3703 bwPieceGC = copyInvertedGC;
3704 wbPieceGC = lightSquareGC;
3708 gc_values.foreground = highlightSquareColor;
3709 gc_values.background = highlightSquareColor;
3710 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3712 gc_values.foreground = premoveHighlightColor;
3713 gc_values.background = premoveHighlightColor;
3714 prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3716 gc_values.foreground = lightSquareColor;
3717 gc_values.background = darkSquareColor;
3718 lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3720 gc_values.foreground = darkSquareColor;
3721 gc_values.background = lightSquareColor;
3722 darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3724 gc_values.foreground = jailSquareColor;
3725 gc_values.background = jailSquareColor;
3726 jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3728 gc_values.foreground = whitePieceColor;
3729 gc_values.background = darkSquareColor;
3730 wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3732 gc_values.foreground = whitePieceColor;
3733 gc_values.background = lightSquareColor;
3734 wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3736 gc_values.foreground = whitePieceColor;
3737 gc_values.background = jailSquareColor;
3738 wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3740 gc_values.foreground = blackPieceColor;
3741 gc_values.background = darkSquareColor;
3742 bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3744 gc_values.foreground = blackPieceColor;
3745 gc_values.background = lightSquareColor;
3746 blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3748 gc_values.foreground = blackPieceColor;
3749 gc_values.background = jailSquareColor;
3750 bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3754 void loadXIM(xim, xmask, filename, dest, mask)
3767 fp = fopen(filename, "rb");
3769 fprintf(stderr, _("%s: error loading XIM!\n"), programName);
3776 for (y=0; y<h; ++y) {
3777 for (x=0; x<h; ++x) {
3782 XPutPixel(xim, x, y, blackPieceColor);
3784 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3787 XPutPixel(xim, x, y, darkSquareColor);
3789 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3792 XPutPixel(xim, x, y, whitePieceColor);
3794 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3797 XPutPixel(xim, x, y, lightSquareColor);
3799 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3805 /* create Pixmap of piece */
3806 *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3808 XPutImage(xDisplay, *dest, lightSquareGC, xim,
3811 /* create Pixmap of clipmask
3812 Note: We assume the white/black pieces have the same
3813 outline, so we make only 6 masks. This is okay
3814 since the XPM clipmask routines do the same. */
3816 temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3818 XPutImage(xDisplay, temp, lightSquareGC, xmask,
3821 /* now create the 1-bit version */
3822 *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3825 values.foreground = 1;
3826 values.background = 0;
3828 /* Don't use XtGetGC, not read only */
3829 maskGC = XCreateGC(xDisplay, *mask,
3830 GCForeground | GCBackground, &values);
3831 XCopyPlane(xDisplay, temp, *mask, maskGC,
3832 0, 0, squareSize, squareSize, 0, 0, 1);
3833 XFreePixmap(xDisplay, temp);
3838 char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
3840 void CreateXIMPieces()
3845 static char *ximkind[] = { "ll", "ld", "dl", "dd" };
3850 /* The XSynchronize calls were copied from CreatePieces.
3851 Not sure if needed, but can't hurt */
3852 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3855 /* temp needed by loadXIM() */
3856 ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3857 0, 0, ss, ss, AllPlanes, XYPixmap);
3859 if (strlen(appData.pixmapDirectory) == 0) {
3863 if (appData.monoMode) {
3864 DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
3868 fprintf(stderr, _("\nLoading XIMs...\n"));
3870 for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
3871 fprintf(stderr, "%d", piece+1);
3872 for (kind=0; kind<4; kind++) {
3873 fprintf(stderr, ".");
3874 snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
3875 ExpandPathName(appData.pixmapDirectory),
3876 piece <= (int) WhiteKing ? "" : "w",
3877 pieceBitmapNames[piece],
3879 ximPieceBitmap[kind][piece] =
3880 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3881 0, 0, ss, ss, AllPlanes, XYPixmap);
3882 if (appData.debugMode)
3883 fprintf(stderr, _("(File:%s:) "), buf);
3884 loadXIM(ximPieceBitmap[kind][piece],
3886 &(xpmPieceBitmap2[kind][piece]),
3887 &(ximMaskPm2[piece]));
3888 if(piece <= (int)WhiteKing)
3889 xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
3891 fprintf(stderr," ");
3893 /* Load light and dark squares */
3894 /* If the LSQ and DSQ pieces don't exist, we will
3895 draw them with solid squares. */
3896 snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
3897 if (access(buf, 0) != 0) {
3901 fprintf(stderr, _("light square "));
3903 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3904 0, 0, ss, ss, AllPlanes, XYPixmap);
3905 if (appData.debugMode)
3906 fprintf(stderr, _("(File:%s:) "), buf);
3908 loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
3909 fprintf(stderr, _("dark square "));
3910 snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
3911 ExpandPathName(appData.pixmapDirectory), ss);
3912 if (appData.debugMode)
3913 fprintf(stderr, _("(File:%s:) "), buf);
3915 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3916 0, 0, ss, ss, AllPlanes, XYPixmap);
3917 loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
3918 xpmJailSquare = xpmLightSquare;
3920 fprintf(stderr, _("Done.\n"));
3922 XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
3926 void CreateXPMPieces()
3930 u_int ss = squareSize;
3932 static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
3933 XpmColorSymbol symbols[4];
3935 /* The XSynchronize calls were copied from CreatePieces.
3936 Not sure if needed, but can't hurt */
3937 XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
3939 /* Setup translations so piece colors match square colors */
3940 symbols[0].name = "light_piece";
3941 symbols[0].value = appData.whitePieceColor;
3942 symbols[1].name = "dark_piece";
3943 symbols[1].value = appData.blackPieceColor;
3944 symbols[2].name = "light_square";
3945 symbols[2].value = appData.lightSquareColor;
3946 symbols[3].name = "dark_square";
3947 symbols[3].value = appData.darkSquareColor;
3949 attr.valuemask = XpmColorSymbols;
3950 attr.colorsymbols = symbols;
3951 attr.numsymbols = 4;
3953 if (appData.monoMode) {
3954 DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
3958 if (strlen(appData.pixmapDirectory) == 0) {
3959 XpmPieces* pieces = builtInXpms;
3962 while (pieces->size != squareSize && pieces->size) pieces++;
3963 if (!pieces->size) {
3964 fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
3967 for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
3968 for (kind=0; kind<4; kind++) {
3970 if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
3971 pieces->xpm[piece][kind],
3972 &(xpmPieceBitmap2[kind][piece]),
3973 NULL, &attr)) != 0) {
3974 fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
3978 if(piece <= (int) WhiteKing)
3979 xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
3983 xpmJailSquare = xpmLightSquare;
3987 fprintf(stderr, _("\nLoading XPMs...\n"));
3990 for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
3991 fprintf(stderr, "%d ", piece+1);
3992 for (kind=0; kind<4; kind++) {
3993 snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
3994 ExpandPathName(appData.pixmapDirectory),
3995 piece > (int) WhiteKing ? "w" : "",
3996 pieceBitmapNames[piece],
3998 if (appData.debugMode) {
3999 fprintf(stderr, _("(File:%s:) "), buf);
4001 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
4002 &(xpmPieceBitmap2[kind][piece]),
4003 NULL, &attr)) != 0) {
4004 if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
4005 // [HGM] missing: read of unorthodox piece failed; substitute King.
4006 snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
4007 ExpandPathName(appData.pixmapDirectory),
4009 if (appData.debugMode) {
4010 fprintf(stderr, _("(Replace by File:%s:) "), buf);
4012 r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
4013 &(xpmPieceBitmap2[kind][piece]),
4017 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
4022 if(piece <= (int) WhiteKing)
4023 xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
4026 /* Load light and dark squares */
4027 /* If the LSQ and DSQ pieces don't exist, we will
4028 draw them with solid squares. */
4029 fprintf(stderr, _("light square "));
4030 snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
4031 if (access(buf, 0) != 0) {
4035 if (appData.debugMode)
4036 fprintf(stderr, _("(File:%s:) "), buf);
4038 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
4039 &xpmLightSquare, NULL, &attr)) != 0) {
4040 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
4043 fprintf(stderr, _("dark square "));
4044 snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
4045 ExpandPathName(appData.pixmapDirectory), ss);
4046 if (appData.debugMode) {
4047 fprintf(stderr, _("(File:%s:) "), buf);
4049 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
4050 &xpmDarkSquare, NULL, &attr)) != 0) {
4051 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
4055 xpmJailSquare = xpmLightSquare;
4056 fprintf(stderr, _("Done.\n"));
4058 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
4061 #endif /* HAVE_LIBXPM */
4064 /* No built-in bitmaps */
4069 u_int ss = squareSize;
4071 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
4074 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
4075 for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
4076 sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
4077 pieceBitmapNames[piece],
4078 ss, kind == SOLID ? 's' : 'o');
4079 ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
4080 if(piece <= (int)WhiteKing)
4081 pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
4085 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
4089 /* With built-in bitmaps */
4092 BuiltInBits* bib = builtInBits;
4095 u_int ss = squareSize;
4097 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
4100 while (bib->squareSize != ss && bib->squareSize != 0) bib++;
4102 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
4103 for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
4104 sprintf(buf, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
4105 pieceBitmapNames[piece],
4106 ss, kind == SOLID ? 's' : 'o');
4107 ReadBitmap(&pieceBitmap2[kind][piece], buf,
4108 bib->bits[kind][piece], ss, ss);
4109 if(piece <= (int)WhiteKing)
4110 pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
4114 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
4119 void ReadBitmap(pm, name, bits, wreq, hreq)
4122 unsigned char bits[];
4128 char msg[MSG_SIZ], fullname[MSG_SIZ];
4130 if (*appData.bitmapDirectory != NULLCHAR) {
4131 strcpy(fullname, appData.bitmapDirectory);
4132 strcat(fullname, "/");
4133 strcat(fullname, name);
4134 errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
4135 &w, &h, pm, &x_hot, &y_hot);
4136 fprintf(stderr, "load %s\n", name);
4137 if (errcode != BitmapSuccess) {
4139 case BitmapOpenFailed:
4140 snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
4142 case BitmapFileInvalid:
4143 snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
4145 case BitmapNoMemory:
4146 snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
4150 snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
4154 fprintf(stderr, _("%s: %s...using built-in\n"),
4156 } else if (w != wreq || h != hreq) {
4158 _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
4159 programName, fullname, w, h, wreq, hreq);
4165 *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
4174 if (lineGap == 0) return;
4176 /* [HR] Split this into 2 loops for non-square boards. */
4178 for (i = 0; i < BOARD_HEIGHT + 1; i++) {
4179 gridSegments[i].x1 = 0;
4180 gridSegments[i].x2 =
4181 lineGap + BOARD_WIDTH * (squareSize + lineGap);
4182 gridSegments[i].y1 = gridSegments[i].y2
4183 = lineGap / 2 + (i * (squareSize + lineGap));
4186 for (j = 0; j < BOARD_WIDTH + 1; j++) {
4187 gridSegments[j + i].y1 = 0;
4188 gridSegments[j + i].y2 =
4189 lineGap + BOARD_HEIGHT * (squareSize + lineGap);
4190 gridSegments[j + i].x1 = gridSegments[j + i].x2
4191 = lineGap / 2 + (j * (squareSize + lineGap));
4195 static void MenuBarSelect(w, addr, index)
4200 XtActionProc proc = (XtActionProc) addr;
4202 (proc)(NULL, NULL, NULL, NULL);
4205 void CreateMenuBarPopup(parent, name, mb)
4215 menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
4218 XtSetArg(args[j], XtNleftMargin, 20); j++;
4219 XtSetArg(args[j], XtNrightMargin, 20); j++;
4221 while (mi->string != NULL) {
4222 if (strcmp(mi->string, "----") == 0) {
4223 entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
4226 XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
4227 entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
4229 XtAddCallback(entry, XtNcallback,
4230 (XtCallbackProc) MenuBarSelect,
4231 (caddr_t) mi->proc);
4237 Widget CreateMenuBar(mb)
4241 Widget anchor, menuBar;
4243 char menuName[MSG_SIZ];
4246 XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
4247 XtSetArg(args[j], XtNvSpace, 0); j++;
4248 XtSetArg(args[j], XtNborderWidth, 0); j++;
4249 menuBar = XtCreateWidget("menuBar", boxWidgetClass,
4250 formWidget, args, j);
4252 while (mb->name != NULL) {
4253 strcpy(menuName, "menu");
4254 strcat(menuName, mb->name);
4256 XtSetArg(args[j], XtNmenuName, XtNewString(menuName)); j++;
4259 shortName[0] = _(mb->name)[0];
4260 shortName[1] = NULLCHAR;
4261 XtSetArg(args[j], XtNlabel, XtNewString(shortName)); j++;
4264 XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name))); j++;
4267 XtSetArg(args[j], XtNborderWidth, 0); j++;
4268 anchor = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,
4270 CreateMenuBarPopup(menuBar, menuName, mb);
4276 Widget CreateButtonBar(mi)
4280 Widget button, buttonBar;
4284 XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
4286 XtSetArg(args[j], XtNhSpace, 0); j++;
4288 XtSetArg(args[j], XtNborderWidth, 0); j++;
4289 XtSetArg(args[j], XtNvSpace, 0); j++;
4290 buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,
4291 formWidget, args, j);
4293 while (mi->string != NULL) {
4296 XtSetArg(args[j], XtNinternalWidth, 2); j++;
4297 XtSetArg(args[j], XtNborderWidth, 0); j++;
4299 XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
4300 button = XtCreateManagedWidget(mi->string, commandWidgetClass,
4301 buttonBar, args, j);
4302 XtAddCallback(button, XtNcallback,
4303 (XtCallbackProc) MenuBarSelect,
4304 (caddr_t) mi->proc);
4311 CreatePieceMenu(name, color)
4318 ChessSquare selection;
4320 menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
4321 boardWidget, args, 0);
4323 for (i = 0; i < PIECE_MENU_SIZE; i++) {
4324 String item = pieceMenuStrings[color][i];
4326 if (strcmp(item, "----") == 0) {
4327 entry = XtCreateManagedWidget(item, smeLineObjectClass,
4330 XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
4331 entry = XtCreateManagedWidget(item, smeBSBObjectClass,
4333 selection = pieceMenuTranslation[color][i];
4334 XtAddCallback(entry, XtNcallback,
4335 (XtCallbackProc) PieceMenuSelect,
4336 (caddr_t) selection);
4337 if (selection == WhitePawn || selection == BlackPawn) {
4338 XtSetArg(args[0], XtNpopupOnEntry, entry);
4339 XtSetValues(menu, args, 1);
4352 ChessSquare selection;
4354 whitePieceMenu = CreatePieceMenu("menuW", 0);
4355 blackPieceMenu = CreatePieceMenu("menuB", 1);
4357 XtRegisterGrabAction(PieceMenuPopup, True,
4358 (unsigned)(ButtonPressMask|ButtonReleaseMask),
4359 GrabModeAsync, GrabModeAsync);
4361 XtSetArg(args[0], XtNlabel, _("Drop"));
4362 dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,
4363 boardWidget, args, 1);
4364 for (i = 0; i < DROP_MENU_SIZE; i++) {
4365 String item = dropMenuStrings[i];
4367 if (strcmp(item, "----") == 0) {
4368 entry = XtCreateManagedWidget(item, smeLineObjectClass,
4371 XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
4372 entry = XtCreateManagedWidget(item, smeBSBObjectClass,
4374 selection = dropMenuTranslation[i];
4375 XtAddCallback(entry, XtNcallback,
4376 (XtCallbackProc) DropMenuSelect,
4377 (caddr_t) selection);
4382 void SetupDropMenu()
4390 for (i=0; i<sizeof(dmEnables)/sizeof(DropMenuEnables); i++) {
4391 entry = XtNameToWidget(dropMenu, dmEnables[i].widget);
4392 p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,
4393 dmEnables[i].piece);
4394 XtSetSensitive(entry, p != NULL || !appData.testLegality
4395 /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse
4396 && !appData.icsActive));
4398 while (p && *p++ == dmEnables[i].piece) count++;
4399 snprintf(label, sizeof(label), "%s %d", dmEnables[i].widget, count);
4401 XtSetArg(args[j], XtNlabel, label); j++;
4402 XtSetValues(entry, args, j);
4406 void PieceMenuPopup(w, event, params, num_params)
4410 Cardinal *num_params;
4413 if (event->type != ButtonPress) return;
4414 if (errorUp) ErrorPopDown();
4418 whichMenu = params[0];
4420 case IcsPlayingWhite:
4421 case IcsPlayingBlack:
4423 case MachinePlaysWhite:
4424 case MachinePlaysBlack:
4425 if (appData.testLegality &&
4426 gameInfo.variant != VariantBughouse &&
4427 gameInfo.variant != VariantCrazyhouse) return;
4429 whichMenu = "menuD";
4435 if (((pmFromX = EventToSquare(event->xbutton.x, BOARD_WIDTH)) < 0) ||
4436 ((pmFromY = EventToSquare(event->xbutton.y, BOARD_HEIGHT)) < 0)) {
4437 pmFromX = pmFromY = -1;
4441 pmFromX = BOARD_WIDTH - 1 - pmFromX;
4443 pmFromY = BOARD_HEIGHT - 1 - pmFromY;
4445 XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
4448 static void PieceMenuSelect(w, piece, junk)
4453 if (pmFromX < 0 || pmFromY < 0) return;
4454 EditPositionMenuEvent(piece, pmFromX, pmFromY);
4457 static void DropMenuSelect(w, piece, junk)
4462 if (pmFromX < 0 || pmFromY < 0) return;
4463 DropMenuEvent(piece, pmFromX, pmFromY);
4466 void WhiteClock(w, event, prms, nprms)
4472 if (gameMode == EditPosition || gameMode == IcsExamining) {
4473 SetWhiteToPlayEvent();
4474 } else if (gameMode == IcsPlayingBlack || gameMode == MachinePlaysWhite) {
4479 void BlackClock(w, event, prms, nprms)
4485 if (gameMode == EditPosition || gameMode == IcsExamining) {
4486 SetBlackToPlayEvent();
4487 } else if (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack) {
4494 * If the user selects on a border boundary, return -1; if off the board,
4495 * return -2. Otherwise map the event coordinate to the square.
4497 int EventToSquare(x, limit)
4505 if ((x % (squareSize + lineGap)) >= squareSize)
4507 x /= (squareSize + lineGap);
4513 static void do_flash_delay(msec)
4519 static void drawHighlight(file, rank, gc)
4525 if (lineGap == 0 || appData.blindfold) return;
4528 x = lineGap/2 + ((BOARD_WIDTH-1)-file) *
4529 (squareSize + lineGap);
4530 y = lineGap/2 + rank * (squareSize + lineGap);
4532 x = lineGap/2 + file * (squareSize + lineGap);
4533 y = lineGap/2 + ((BOARD_HEIGHT-1)-rank) *
4534 (squareSize + lineGap);
4537 XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
4538 squareSize+lineGap, squareSize+lineGap);
4541 int hi1X = -1, hi1Y = -1, hi2X = -1, hi2Y = -1;
4542 int pm1X = -1, pm1Y = -1, pm2X = -1, pm2Y = -1;
4545 SetHighlights(fromX, fromY, toX, toY)
4546 int fromX, fromY, toX, toY;
4548 if (hi1X != fromX || hi1Y != fromY) {
4549 if (hi1X >= 0 && hi1Y >= 0) {
4550 drawHighlight(hi1X, hi1Y, lineGC);
4552 if (fromX >= 0 && fromY >= 0) {
4553 drawHighlight(fromX, fromY, highlineGC);
4556 if (hi2X != toX || hi2Y != toY) {
4557 if (hi2X >= 0 && hi2Y >= 0) {
4558 drawHighlight(hi2X, hi2Y, lineGC);
4560 if (toX >= 0 && toY >= 0) {
4561 drawHighlight(toX, toY, highlineGC);
4573 SetHighlights(-1, -1, -1, -1);
4578 SetPremoveHighlights(fromX, fromY, toX, toY)
4579 int fromX, fromY, toX, toY;
4581 if (pm1X != fromX || pm1Y != fromY) {
4582 if (pm1X >= 0 && pm1Y >= 0) {
4583 drawHighlight(pm1X, pm1Y, lineGC);
4585 if (fromX >= 0 && fromY >= 0) {
4586 drawHighlight(fromX, fromY, prelineGC);
4589 if (pm2X != toX || pm2Y != toY) {
4590 if (pm2X >= 0 && pm2Y >= 0) {
4591 drawHighlight(pm2X, pm2Y, lineGC);
4593 if (toX >= 0 && toY >= 0) {
4594 drawHighlight(toX, toY, prelineGC);
4604 ClearPremoveHighlights()
4606 SetPremoveHighlights(-1, -1, -1, -1);
4609 static void BlankSquare(x, y, color, piece, dest)
4614 if (useImages && useImageSqs) {
4618 pm = xpmLightSquare;
4623 case 2: /* neutral */
4628 XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
4629 squareSize, squareSize, x, y);
4639 case 2: /* neutral */
4644 XFillRectangle(xDisplay, dest, gc, x, y, squareSize, squareSize);
4649 I split out the routines to draw a piece so that I could
4650 make a generic flash routine.
4652 static void monoDrawPiece_1bit(piece, square_color, x, y, dest)
4654 int square_color, x, y;
4657 /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
4658 switch (square_color) {
4660 case 2: /* neutral */
4662 XCopyArea(xDisplay, (int) piece < (int) BlackPawn
4663 ? *pieceToOutline(piece)
4664 : *pieceToSolid(piece),
4665 dest, bwPieceGC, 0, 0,
4666 squareSize, squareSize, x, y);
4669 XCopyArea(xDisplay, (int) piece < (int) BlackPawn
4670 ? *pieceToSolid(piece)
4671 : *pieceToOutline(piece),
4672 dest, wbPieceGC, 0, 0,
4673 squareSize, squareSize, x, y);
4678 static void monoDrawPiece(piece, square_color, x, y, dest)
4680 int square_color, x, y;
4683 switch (square_color) {
4685 case 2: /* neutral */
4687 XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
4688 ? *pieceToOutline(piece)
4689 : *pieceToSolid(piece),
4690 dest, bwPieceGC, 0, 0,
4691 squareSize, squareSize, x, y, 1);
4694 XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
4695 ? *pieceToSolid(piece)
4696 : *pieceToOutline(piece),
4697 dest, wbPieceGC, 0, 0,
4698 squareSize, squareSize, x, y, 1);
4703 static void colorDrawPiece(piece, square_color, x, y, dest)
4705 int square_color, x, y;
4708 if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
4709 switch (square_color) {
4711 XCopyPlane(xDisplay, *pieceToSolid(piece),
4712 dest, (int) piece < (int) BlackPawn
4713 ? wlPieceGC : blPieceGC, 0, 0,
4714 squareSize, squareSize, x, y, 1);
4717 XCopyPlane(xDisplay, *pieceToSolid(piece),
4718 dest, (int) piece < (int) BlackPawn
4719 ? wdPieceGC : bdPieceGC, 0, 0,
4720 squareSize, squareSize, x, y, 1);
4722 case 2: /* neutral */
4724 XCopyPlane(xDisplay, *pieceToSolid(piece),
4725 dest, (int) piece < (int) BlackPawn
4726 ? wjPieceGC : bjPieceGC, 0, 0,
4727 squareSize, squareSize, x, y, 1);
4732 static void colorDrawPieceImage(piece, square_color, x, y, dest)
4734 int square_color, x, y;
4739 switch (square_color) {
4741 case 2: /* neutral */
4743 if ((int)piece < (int) BlackPawn) {
4751 if ((int)piece < (int) BlackPawn) {
4759 XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
4760 dest, wlPieceGC, 0, 0,
4761 squareSize, squareSize, x, y);
4764 typedef void (*DrawFunc)();
4766 DrawFunc ChooseDrawFunc()
4768 if (appData.monoMode) {
4769 if (DefaultDepth(xDisplay, xScreen) == 1) {
4770 return monoDrawPiece_1bit;
4772 return monoDrawPiece;
4776 return colorDrawPieceImage;
4778 return colorDrawPiece;
4782 /* [HR] determine square color depending on chess variant. */
4783 static int SquareColor(row, column)
4788 if (gameInfo.variant == VariantXiangqi) {
4789 if (column >= 3 && column <= 5 && row >= 0 && row <= 2) {
4791 } else if (column >= 3 && column <= 5 && row >= 7 && row <= 9) {
4793 } else if (row <= 4) {
4799 square_color = ((column + row) % 2) == 1;
4802 /* [hgm] holdings: next line makes all holdings squares light */
4803 if(column < BOARD_LEFT || column >= BOARD_RGHT) square_color = 1;
4805 return square_color;
4808 void DrawSquare(row, column, piece, do_flash)
4809 int row, column, do_flash;
4812 int square_color, x, y, direction, font_ascent, font_descent;
4815 XCharStruct overall;
4819 /* Calculate delay in milliseconds (2-delays per complete flash) */
4820 flash_delay = 500 / appData.flashRate;
4823 x = lineGap + ((BOARD_WIDTH-1)-column) *
4824 (squareSize + lineGap);
4825 y = lineGap + row * (squareSize + lineGap);
4827 x = lineGap + column * (squareSize + lineGap);
4828 y = lineGap + ((BOARD_HEIGHT-1)-row) *
4829 (squareSize + lineGap);
4832 square_color = SquareColor(row, column);
4834 if ( // [HGM] holdings: blank out area between board and holdings
4835 column == BOARD_LEFT-1 || column == BOARD_RGHT
4836 || (column == BOARD_LEFT-2 && row < BOARD_HEIGHT-gameInfo.holdingsSize)
4837 || (column == BOARD_RGHT+1 && row >= gameInfo.holdingsSize) ) {
4838 BlankSquare(x, y, 2, EmptySquare, xBoardWindow);
4840 // [HGM] print piece counts next to holdings
4841 string[1] = NULLCHAR;
4842 if (column == (flipView ? BOARD_LEFT-1 : BOARD_RGHT) && piece > 1 ) {
4843 string[0] = '0' + piece;
4844 XTextExtents(countFontStruct, string, 1, &direction,
4845 &font_ascent, &font_descent, &overall);
4846 if (appData.monoMode) {
4847 XDrawImageString(xDisplay, xBoardWindow, countGC,
4848 x + squareSize - overall.width - 2,
4849 y + font_ascent + 1, string, 1);
4851 XDrawString(xDisplay, xBoardWindow, countGC,
4852 x + squareSize - overall.width - 2,
4853 y + font_ascent + 1, string, 1);
4856 if (column == (flipView ? BOARD_RGHT : BOARD_LEFT-1) && piece > 1) {
4857 string[0] = '0' + piece;
4858 XTextExtents(countFontStruct, string, 1, &direction,
4859 &font_ascent, &font_descent, &overall);
4860 if (appData.monoMode) {
4861 XDrawImageString(xDisplay, xBoardWindow, countGC,
4862 x + 2, y + font_ascent + 1, string, 1);
4864 XDrawString(xDisplay, xBoardWindow, countGC,
4865 x + 2, y + font_ascent + 1, string, 1);
4869 if (piece == EmptySquare || appData.blindfold) {
4870 BlankSquare(x, y, square_color, piece, xBoardWindow);
4872 drawfunc = ChooseDrawFunc();
4873 if (do_flash && appData.flashCount > 0) {
4874 for (i=0; i<appData.flashCount; ++i) {
4876 drawfunc(piece, square_color, x, y, xBoardWindow);
4877 XSync(xDisplay, False);
4878 do_flash_delay(flash_delay);
4880 BlankSquare(x, y, square_color, piece, xBoardWindow);
4881 XSync(xDisplay, False);
4882 do_flash_delay(flash_delay);
4885 drawfunc(piece, square_color, x, y, xBoardWindow);
4889 string[1] = NULLCHAR;
4890 if (appData.showCoords && row == (flipView ? BOARD_HEIGHT-1 : 0)
4891 && column >= BOARD_LEFT && column < BOARD_RGHT) {
4892 string[0] = 'a' + column - BOARD_LEFT;
4893 XTextExtents(coordFontStruct, string, 1, &direction,
4894 &font_ascent, &font_descent, &overall);
4895 if (appData.monoMode) {
4896 XDrawImageString(xDisplay, xBoardWindow, coordGC,
4897 x + squareSize - overall.width - 2,
4898 y + squareSize - font_descent - 1, string, 1);
4900 XDrawString(xDisplay, xBoardWindow, coordGC,
4901 x + squareSize - overall.width - 2,
4902 y + squareSize - font_descent - 1, string, 1);
4905 if (appData.showCoords && column == (flipView ? BOARD_RGHT-1 : BOARD_LEFT)) {
4906 string[0] = ONE + row;
4907 XTextExtents(coordFontStruct, string, 1, &direction,
4908 &font_ascent, &font_descent, &overall);
4909 if (appData.monoMode) {
4910 XDrawImageString(xDisplay, xBoardWindow, coordGC,
4911 x + 2, y + font_ascent + 1, string, 1);
4913 XDrawString(xDisplay, xBoardWindow, coordGC,
4914 x + 2, y + font_ascent + 1, string, 1);
4920 /* Why is this needed on some versions of X? */
4921 void EventProc(widget, unused, event)
4926 if (!XtIsRealized(widget))
4929 switch (event->type) {
4931 if (event->xexpose.count > 0) return; /* no clipping is done */
4932 XDrawPosition(widget, True, NULL);
4940 void DrawPosition(fullRedraw, board)
4941 /*Boolean*/int fullRedraw;
4944 XDrawPosition(boardWidget, fullRedraw, board);
4947 /* Returns 1 if there are "too many" differences between b1 and b2
4948 (i.e. more than 1 move was made) */
4949 static int too_many_diffs(b1, b2)
4955 for (i=0; i<BOARD_HEIGHT; ++i) {
4956 for (j=0; j<BOARD_WIDTH; ++j) {
4957 if (b1[i][j] != b2[i][j]) {
4958 if (++c > 4) /* Castling causes 4 diffs */
4967 /* Matrix describing castling maneuvers */
4968 /* Row, ColRookFrom, ColKingFrom, ColRookTo, ColKingTo */
4969 static int castling_matrix[4][5] = {
4970 { 0, 0, 4, 3, 2 }, /* 0-0-0, white */
4971 { 0, 7, 4, 5, 6 }, /* 0-0, white */
4972 { 7, 0, 4, 3, 2 }, /* 0-0-0, black */
4973 { 7, 7, 4, 5, 6 } /* 0-0, black */
4976 /* Checks whether castling occurred. If it did, *rrow and *rcol
4977 are set to the destination (row,col) of the rook that moved.
4979 Returns 1 if castling occurred, 0 if not.
4981 Note: Only handles a max of 1 castling move, so be sure
4982 to call too_many_diffs() first.
4984 static int check_castle_draw(newb, oldb, rrow, rcol)
4991 /* For each type of castling... */
4992 for (i=0; i<4; ++i) {
4993 r = castling_matrix[i];
4995 /* Check the 4 squares involved in the castling move */
4997 for (j=1; j<=4; ++j) {
4998 if (newb[r[0]][r[j]] == oldb[r[0]][r[j]]) {
5005 /* All 4 changed, so it must be a castling move */
5014 static int damage[BOARD_SIZE][BOARD_SIZE];
5017 * event handler for redrawing the board
5019 void XDrawPosition(w, repaint, board)
5021 /*Boolean*/int repaint;
5025 static int lastFlipView = 0;
5026 static int lastBoardValid = 0;
5027 static Board lastBoard;
5031 if (board == NULL) {
5032 if (!lastBoardValid) return;
5035 if (!lastBoardValid || lastFlipView != flipView) {
5036 XtSetArg(args[0], XtNleftBitmap, (flipView ? xMarkPixmap : None));
5037 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flip View"),
5042 * It would be simpler to clear the window with XClearWindow()
5043 * but this causes a very distracting flicker.
5046 if (!repaint && lastBoardValid && lastFlipView == flipView) {
5048 /* If too much changes (begin observing new game, etc.), don't
5050 do_flash = too_many_diffs(board, lastBoard) ? 0 : 1;
5052 /* Special check for castling so we don't flash both the king
5053 and the rook (just flash the king). */
5055 if (check_castle_draw(board, lastBoard, &rrow, &rcol)) {
5056 /* Draw rook with NO flashing. King will be drawn flashing later */
5057 DrawSquare(rrow, rcol, board[rrow][rcol], 0);
5058 lastBoard[rrow][rcol] = board[rrow][rcol];
5062 /* First pass -- Draw (newly) empty squares and repair damage.
5063 This prevents you from having a piece show up twice while it
5064 is flashing on its new square */
5065 for (i = 0; i < BOARD_HEIGHT; i++)
5066 for (j = 0; j < BOARD_WIDTH; j++)
5067 if ((board[i][j] != lastBoard[i][j] && board[i][j] == EmptySquare)
5069 DrawSquare(i, j, board[i][j], 0);
5070 damage[i][j] = False;
5073 /* Second pass -- Draw piece(s) in new position and flash them */
5074 for (i = 0; i < BOARD_HEIGHT; i++)
5075 for (j = 0; j < BOARD_WIDTH; j++)
5076 if (board[i][j] != lastBoard[i][j]) {
5077 DrawSquare(i, j, board[i][j], do_flash);
5081 XDrawSegments(xDisplay, xBoardWindow, lineGC,
5082 gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
5084 for (i = 0; i < BOARD_HEIGHT; i++)
5085 for (j = 0; j < BOARD_WIDTH; j++) {
5086 DrawSquare(i, j, board[i][j], 0);
5087 damage[i][j] = False;
5091 CopyBoard(lastBoard, board);
5093 lastFlipView = flipView;
5095 /* Draw highlights */
5096 if (pm1X >= 0 && pm1Y >= 0) {
5097 drawHighlight(pm1X, pm1Y, prelineGC);
5099 if (pm2X >= 0 && pm2Y >= 0) {
5100 drawHighlight(pm2X, pm2Y, prelineGC);
5102 if (hi1X >= 0 && hi1Y >= 0) {
5103 drawHighlight(hi1X, hi1Y, highlineGC);
5105 if (hi2X >= 0 && hi2Y >= 0) {
5106 drawHighlight(hi2X, hi2Y, highlineGC);
5109 /* If piece being dragged around board, must redraw that too */
5112 XSync(xDisplay, False);
5117 * event handler for redrawing the board
5119 void DrawPositionProc(w, event, prms, nprms)
5125 XDrawPosition(w, True, NULL);
5130 * event handler for parsing user moves
5132 // [HGM] This routine will need quite some reworking. Although the backend still supports the old
5133 // way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform
5134 // it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it
5135 // should be made to use the new way, of calling UserMoveTest early to determine the legality of the
5136 // move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),
5137 // and at the end FinishMove() to perform the move after optional promotion popups.
5138 // For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.
5139 void HandleUserMove(w, event, prms, nprms)
5145 if (w != boardWidget || errorExitStatus != -1) return;
5148 if (event->type == ButtonPress) {
5149 XtPopdown(promotionShell);
5150 XtDestroyWidget(promotionShell);
5151 promotionUp = False;
5159 // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
5160 if(event->type == ButtonPress) LeftClick(Press, event->xbutton.x, event->xbutton.y);
5161 if(event->type == ButtonRelease) LeftClick(Release, event->xbutton.x, event->xbutton.y);
5164 void AnimateUserMove (Widget w, XEvent * event,
5165 String * params, Cardinal * nParams)
5167 DragPieceMove(event->xmotion.x, event->xmotion.y);
5170 Widget CommentCreate(name, text, mutable, callback, lines)
5172 int /*Boolean*/ mutable;
5173 XtCallbackProc callback;
5177 Widget shell, layout, form, edit, b_ok, b_cancel, b_clear, b_close, b_edit;
5182 XtSetArg(args[j], XtNwidth, &bw_width); j++;
5183 XtGetValues(boardWidget, args, j);
5186 XtSetArg(args[j], XtNresizable, True); j++;
5189 XtCreatePopupShell(name, topLevelShellWidgetClass,
5190 shellWidget, args, j);
5193 XtCreatePopupShell(name, transientShellWidgetClass,
5194 shellWidget, args, j);
5197 XtCreateManagedWidget(layoutName, formWidgetClass, shell,
5198 layoutArgs, XtNumber(layoutArgs));
5200 XtCreateManagedWidget("form", formWidgetClass, layout,
5201 formArgs, XtNumber(formArgs));
5205 XtSetArg(args[j], XtNeditType, XawtextEdit); j++;
5206 XtSetArg(args[j], XtNuseStringInPlace, False); j++;
5208 XtSetArg(args[j], XtNstring, text); j++;
5209 XtSetArg(args[j], XtNtop, XtChainTop); j++;
5210 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5211 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5212 XtSetArg(args[j], XtNright, XtChainRight); j++;
5213 XtSetArg(args[j], XtNresizable, True); j++;
5214 XtSetArg(args[j], XtNwidth, bw_width); j++; /*force wider than buttons*/
5215 /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
5216 XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;
5217 XtSetArg(args[j], XtNautoFill, True); j++;
5218 XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
5220 XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);
5224 XtSetArg(args[j], XtNfromVert, edit); j++;
5225 XtSetArg(args[j], XtNtop, XtChainBottom); j++;
5226 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5227 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5228 XtSetArg(args[j], XtNright, XtChainLeft); j++;
5230 XtCreateManagedWidget(_("ok"), commandWidgetClass, form, args, j);
5231 XtAddCallback(b_ok, XtNcallback, callback, (XtPointer) 0);
5234 XtSetArg(args[j], XtNfromVert, edit); j++;
5235 XtSetArg(args[j], XtNfromHoriz, b_ok); j++;
5236 XtSetArg(args[j], XtNtop, XtChainBottom); j++;
5237 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5238 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5239 XtSetArg(args[j], XtNright, XtChainLeft); j++;
5241 XtCreateManagedWidget(_("cancel"), commandWidgetClass, form, args, j);
5242 XtAddCallback(b_cancel, XtNcallback, callback, (XtPointer) 0);
5245 XtSetArg(args[j], XtNfromVert, edit); j++;
5246 XtSetArg(args[j], XtNfromHoriz, b_cancel); j++;
5247 XtSetArg(args[j], XtNtop, XtChainBottom); j++;
5248 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5249 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5250 XtSetArg(args[j], XtNright, XtChainLeft); j++;
5252 XtCreateManagedWidget(_("clear"), commandWidgetClass, form, args, j);
5253 XtAddCallback(b_clear, XtNcallback, callback, (XtPointer) 0);
5256 XtSetArg(args[j], XtNfromVert, edit); j++;
5257 XtSetArg(args[j], XtNtop, XtChainBottom); j++;
5258 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5259 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5260 XtSetArg(args[j], XtNright, XtChainLeft); j++;
5262 XtCreateManagedWidget(_("close"), commandWidgetClass, form, args, j);
5263 XtAddCallback(b_close, XtNcallback, callback, (XtPointer) 0);
5266 XtSetArg(args[j], XtNfromVert, edit); j++;
5267 XtSetArg(args[j], XtNfromHoriz, b_close); j++;
5268 XtSetArg(args[j], XtNtop, XtChainBottom); j++;
5269 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5270 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5271 XtSetArg(args[j], XtNright, XtChainLeft); j++;
5273 XtCreateManagedWidget(_("edit"), commandWidgetClass, form, args, j);
5274 XtAddCallback(b_edit, XtNcallback, callback, (XtPointer) 0);
5277 XtRealizeWidget(shell);
5279 if (commentX == -1) {
5282 Dimension pw_height;
5283 Dimension ew_height;
5286 XtSetArg(args[j], XtNheight, &ew_height); j++;
5287 XtGetValues(edit, args, j);
5290 XtSetArg(args[j], XtNheight, &pw_height); j++;
5291 XtGetValues(shell, args, j);
5292 commentH = pw_height + (lines - 1) * ew_height;
5293 commentW = bw_width - 16;
5295 XSync(xDisplay, False);
5297 /* This code seems to tickle an X bug if it is executed too soon
5298 after xboard starts up. The coordinates get transformed as if
5299 the main window was positioned at (0, 0).
5301 XtTranslateCoords(shellWidget,
5302 (bw_width - commentW) / 2, 0 - commentH / 2,
5303 &commentX, &commentY);
5305 XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
5306 RootWindowOfScreen(XtScreen(shellWidget)),
5307 (bw_width - commentW) / 2, 0 - commentH / 2,
5312 if (commentY < 0) commentY = 0; /*avoid positioning top offscreen*/
5315 XtSetArg(args[j], XtNheight, commentH); j++;
5316 XtSetArg(args[j], XtNwidth, commentW); j++;
5317 XtSetArg(args[j], XtNx, commentX); j++;
5318 XtSetArg(args[j], XtNy, commentY); j++;
5319 XtSetValues(shell, args, j);
5320 XtSetKeyboardFocus(shell, edit);
5325 /* Used for analysis window and ICS input window */
5326 Widget MiscCreate(name, text, mutable, callback, lines)
5328 int /*Boolean*/ mutable;
5329 XtCallbackProc callback;
5333 Widget shell, layout, form, edit;
5335 Dimension bw_width, pw_height, ew_height, w, h;
5341 XtSetArg(args[j], XtNresizable, True); j++;
5344 XtCreatePopupShell(name, topLevelShellWidgetClass,
5345 shellWidget, args, j);
5348 XtCreatePopupShell(name, transientShellWidgetClass,
5349 shellWidget, args, j);
5352 XtCreateManagedWidget(layoutName, formWidgetClass, shell,
5353 layoutArgs, XtNumber(layoutArgs));
5355 XtCreateManagedWidget("form", formWidgetClass, layout,
5356 formArgs, XtNumber(formArgs));
5360 XtSetArg(args[j], XtNeditType, XawtextEdit); j++;
5361 XtSetArg(args[j], XtNuseStringInPlace, False); j++;
5363 XtSetArg(args[j], XtNstring, text); j++;
5364 XtSetArg(args[j], XtNtop, XtChainTop); j++;
5365 XtSetArg(args[j], XtNbottom, XtChainBottom); j++;
5366 XtSetArg(args[j], XtNleft, XtChainLeft); j++;
5367 XtSetArg(args[j], XtNright, XtChainRight); j++;
5368 XtSetArg(args[j], XtNresizable, True); j++;
5369 /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */
5370 XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways); j++;
5371 XtSetArg(args[j], XtNautoFill, True); j++;
5372 XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;
5374 XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);
5376 XtRealizeWidget(shell);
5379 XtSetArg(args[j], XtNwidth, &bw_width); j++;
5380 XtGetValues(boardWidget, args, j);
5383 XtSetArg(args[j], XtNheight, &ew_height); j++;
5384 XtGetValues(edit, args, j);
5387 XtSetArg(args[j], XtNheight, &pw_height); j++;
5388 XtGetValues(shell, args, j);
5389 h = pw_height + (lines - 1) * ew_height;
5392 XSync(xDisplay, False);
5394 /* This code seems to tickle an X bug if it is executed too soon
5395 after xboard starts up. The coordinates get transformed as if
5396 the main window was positioned at (0, 0).
5398 XtTranslateCoords(shellWidget, (bw_width - w) / 2, 0 - h / 2, &x, &y);
5400 XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
5401 RootWindowOfScreen(XtScreen(shellWidget)),
5402 (bw_width - w) / 2, 0 - h / 2, &xx, &yy, &junk);
5406 if (y < 0) y = 0; /*avoid positioning top offscreen*/
5409 XtSetArg(args[j], XtNheight, h); j++;
5410 XtSetArg(args[j], XtNwidth, w); j++;
5411 XtSetArg(args[j], XtNx, x); j++;
5412 XtSetArg(args[j], XtNy, y); j++;
5413 XtSetValues(shell, args, j);
5419 static int savedIndex; /* gross that this is global */
5421 void EditCommentPopUp(index, title, text)
5430 if (text == NULL) text = "";
5432 if (editShell == NULL) {
5434 CommentCreate(title, text, True, EditCommentCallback, 4);
5435 XtRealizeWidget(editShell);
5436 CatchDeleteWindow(editShell, "EditCommentPopDown");
5438 edit = XtNameToWidget(editShell, "*form.text");
5440 XtSetArg(args[j], XtNstring, text); j++;
5441 XtSetValues(edit, args, j);
5443 XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;
5444 XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;
5445 XtSetValues(editShell, args, j);
5448 XtPopup(editShell, XtGrabNone);
5452 XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;
5453 XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),
5457 void EditCommentCallback(w, client_data, call_data)
5459 XtPointer client_data, call_data;
5467 XtSetArg(args[j], XtNlabel, &name); j++;
5468 XtGetValues(w, args, j);
5470 if (strcmp(name, _("ok")) == 0) {
5471 edit = XtNameToWidget(editShell, "*form.text");
5473 XtSetArg(args[j], XtNstring, &val); j++;
5474 XtGetValues(edit, args, j);
5475 ReplaceComment(savedIndex, val);
5476 EditCommentPopDown();
5477 } else if (strcmp(name, _("cancel")) == 0) {
5478 EditCommentPopDown();
5479 } else if (strcmp(name, _("clear")) == 0) {
5480 edit = XtNameToWidget(editShell, "*form.text");
5481 XtCallActionProc(edit, "select-all", NULL, NULL, 0);
5482 XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
5486 void EditCommentPopDown()
5491 if (!editUp) return;
5493 XtSetArg(args[j], XtNx, &commentX); j++;
5494 XtSetArg(args[j], XtNy, &commentY); j++;
5495 XtSetArg(args[j], XtNheight, &commentH); j++;
5496 XtSetArg(args[j], XtNwidth, &commentW); j++;
5497 XtGetValues(editShell, args, j);
5498 XtPopdown(editShell);
5501 XtSetArg(args[j], XtNleftBitmap, None); j++;
5502 XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Edit Comment"),
5506 void ICSInputBoxPopUp()
5511 char *title = _("ICS Input");
5514 if (ICSInputShell == NULL) {
5515 ICSInputShell = MiscCreate(title, "", True, NULL, 1);
5516 tr = XtParseTranslationTable(ICSInputTranslations);
5517 edit = XtNameToWidget(ICSInputShell, "*form.text");
5518 XtOverrideTranslations(edit, tr);
5519 XtRealizeWidget(ICSInputShell);
5520 CatchDeleteWindow(ICSInputShell, "ICSInputBoxPopDown");
5523 edit = XtNameToWidget(ICSInputShell, "*form.text");
5525 XtSetArg(args[j], XtNstring, ""); j++;
5526 XtSetValues(edit, args, j);
5528 XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;
5529 XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;
5530 XtSetValues(ICSInputShell, args, j);
5533 XtPopup(ICSInputShell, XtGrabNone);
5534 XtSetKeyboardFocus(ICSInputShell, edit);
5536 ICSInputBoxUp = True;
5538 XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;
5539 XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),
5543 void ICSInputSendText()
5550 edit = XtNameToWidget(ICSInputShell, "*form.text");
5552 XtSetArg(args[j], XtNstring, &val); j++;
5553 XtGetValues(edit, args, j);
5554 SendMultiLineToICS(val);
5555 XtCallActionProc(edit, "select-all", NULL, NULL, 0);
5556 XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
5559 void ICSInputBoxPopDown()
5564 if (!ICSInputBoxUp) return;
5566 XtPopdown(ICSInputShell);
5567 ICSInputBoxUp = False;
5569 XtSetArg(args[j], XtNleftBitmap, None); j++;
5570 XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.ICS Input Box"),
5574 void CommentPopUp(title, text)
5581 if (commentShell == NULL) {
5583 CommentCreate(title, text, False, CommentCallback, 4);
5584 XtRealizeWidget(commentShell);
5585 CatchDeleteWindow(commentShell, "CommentPopDown");
5587 edit = XtNameToWidget(commentShell, "*form.text");
5589 XtSetArg(args[j], XtNstring, text); j++;
5590 XtSetValues(edit, args, j);
5592 XtSetArg(args[j], XtNiconName, (XtArgVal) title); j++;
5593 XtSetArg(args[j], XtNtitle, (XtArgVal) title); j++;
5594 XtSetValues(commentShell, args, j);
5597 XtPopup(commentShell, XtGrabNone);
5598 XSync(xDisplay, False);
5603 void CommentCallback(w, client_data, call_data)
5605 XtPointer client_data, call_data;
5612 XtSetArg(args[j], XtNlabel, &name); j++;
5613 XtGetValues(w, args, j);
5615 if (strcmp(name, _("close")) == 0) {
5617 } else if (strcmp(name, _("edit")) == 0) {
5624 void CommentPopDown()
5629 if (!commentUp) return;
5631 XtSetArg(args[j], XtNx, &commentX); j++;
5632 XtSetArg(args[j], XtNy, &commentY); j++;
5633 XtSetArg(args[j], XtNwidth, &commentW); j++;
5634 XtSetArg(args[j], XtNheight, &commentH); j++;
5635 XtGetValues(commentShell, args, j);
5636 XtPopdown(commentShell);
5637 XSync(xDisplay, False);
5641 void FileNamePopUp(label, def, proc, openMode)
5648 Widget popup, layout, dialog, edit;
5654 fileProc = proc; /* I can't see a way not */
5655 fileOpenMode = openMode; /* to use globals here */
5658 XtSetArg(args[i], XtNresizable, True); i++;
5659 XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
5660 XtSetArg(args[i], XtNtitle, XtNewString(_("File name prompt"))); i++;
5661 fileNameShell = popup =
5662 XtCreatePopupShell("File name prompt", transientShellWidgetClass,
5663 shellWidget, args, i);
5666 XtCreateManagedWidget(layoutName, formWidgetClass, popup,
5667 layoutArgs, XtNumber(layoutArgs));
5670 XtSetArg(args[i], XtNlabel, label); i++;
5671 XtSetArg(args[i], XtNvalue, def); i++;
5672 XtSetArg(args[i], XtNborderWidth, 0); i++;
5673 dialog = XtCreateManagedWidget("fileName", dialogWidgetClass,
5676 XawDialogAddButton(dialog, _("ok"), FileNameCallback, (XtPointer) dialog);
5677 XawDialogAddButton(dialog, _("cancel"), FileNameCallback,
5678 (XtPointer) dialog);
5680 XtRealizeWidget(popup);
5681 CatchDeleteWindow(popup, "FileNamePopDown");
5683 XQueryPointer(xDisplay, xBoardWindow, &root, &child,
5684 &x, &y, &win_x, &win_y, &mask);
5686 XtSetArg(args[0], XtNx, x - 10);
5687 XtSetArg(args[1], XtNy, y - 30);
5688 XtSetValues(popup, args, 2);
5690 XtPopup(popup, XtGrabExclusive);
5693 edit = XtNameToWidget(dialog, "*value");
5694 XtSetKeyboardFocus(popup, edit);
5697 void FileNamePopDown()
5699 if (!filenameUp) return;
5700 XtPopdown(fileNameShell);
5701 XtDestroyWidget(fileNameShell);
5706 void FileNameCallback(w, client_data, call_data)
5708 XtPointer client_data, call_data;
5713 XtSetArg(args[0], XtNlabel, &name);
5714 XtGetValues(w, args, 1);
5716 if (strcmp(name, _("cancel")) == 0) {
5721 FileNameAction(w, NULL, NULL, NULL);
5724 void FileNameAction(w, event, prms, nprms)
5736 name = XawDialogGetValueString(w = XtParent(w));
5738 if ((name != NULL) && (*name != NULLCHAR)) {
5740 XtPopdown(w = XtParent(XtParent(w)));
5744 p = strrchr(buf, ' ');
5751 fullname = ExpandPathName(buf);
5753 ErrorPopUp(_("Error"), _("Can't open file"), FALSE);
5756 f = fopen(fullname, fileOpenMode);
5758 DisplayError(_("Failed to open file"), errno);
5760 (void) (*fileProc)(f, index, buf);
5767 XtPopdown(w = XtParent(XtParent(w)));
5773 void PromotionPopUp()
5776 Widget dialog, layout;
5778 Dimension bw_width, pw_width;
5782 XtSetArg(args[j], XtNwidth, &bw_width); j++;
5783 XtGetValues(boardWidget, args, j);
5786 XtSetArg(args[j], XtNresizable, True); j++;
5787 XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
5789 XtCreatePopupShell("Promotion", transientShellWidgetClass,
5790 shellWidget, args, j);
5792 XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
5793 layoutArgs, XtNumber(layoutArgs));
5796 XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
5797 XtSetArg(args[j], XtNborderWidth, 0); j++;
5798 dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
5801 if(gameInfo.variant != VariantShogi) {
5802 XawDialogAddButton(dialog, _("Queen"), PromotionCallback,
5803 (XtPointer) dialog);
5804 XawDialogAddButton(dialog, _("Rook"), PromotionCallback,
5805 (XtPointer) dialog);
5806 XawDialogAddButton(dialog, _("Bishop"), PromotionCallback,
5807 (XtPointer) dialog);
5808 XawDialogAddButton(dialog, _("Knight"), PromotionCallback,
5809 (XtPointer) dialog);
5810 if (!appData.testLegality || gameInfo.variant == VariantSuicide ||
5811 gameInfo.variant == VariantGiveaway) {
5812 XawDialogAddButton(dialog, _("King"), PromotionCallback,
5813 (XtPointer) dialog);
5815 if(gameInfo.variant == VariantCapablanca ||
5816 gameInfo.variant == VariantGothic ||
5817 gameInfo.variant == VariantCapaRandom) {
5818 XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback,
5819 (XtPointer) dialog);
5820 XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback,
5821 (XtPointer) dialog);
5823 } else // [HGM] shogi
5825 XawDialogAddButton(dialog, _("Promote"), PromotionCallback,
5826 (XtPointer) dialog);
5827 XawDialogAddButton(dialog, _("Defer"), PromotionCallback,
5828 (XtPointer) dialog);
5830 XawDialogAddButton(dialog, _("cancel"), PromotionCallback,
5831 (XtPointer) dialog);
5833 XtRealizeWidget(promotionShell);
5834 CatchDeleteWindow(promotionShell, "PromotionPopDown");
5837 XtSetArg(args[j], XtNwidth, &pw_width); j++;
5838 XtGetValues(promotionShell, args, j);
5840 XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
5841 lineGap + squareSize/3 +
5842 ((toY == BOARD_HEIGHT-1) ^ (flipView) ?
5843 0 : 6*(squareSize + lineGap)), &x, &y);
5846 XtSetArg(args[j], XtNx, x); j++;
5847 XtSetArg(args[j], XtNy, y); j++;
5848 XtSetValues(promotionShell, args, j);
5850 XtPopup(promotionShell, XtGrabNone);
5855 void PromotionPopDown()
5857 if (!promotionUp) return;
5858 XtPopdown(promotionShell);
5859 XtDestroyWidget(promotionShell);
5860 promotionUp = False;
5863 void PromotionCallback(w, client_data, call_data)
5865 XtPointer client_data, call_data;
5871 XtSetArg(args[0], XtNlabel, &name);
5872 XtGetValues(w, args, 1);
5876 if (fromX == -1) return;
5878 if (strcmp(name, _("cancel")) == 0) {
5882 } else if (strcmp(name, _("Knight")) == 0) {
5884 } else if (strcmp(name, _("Promote")) == 0) {
5886 } else if (strcmp(name, _("Defer")) == 0) {
5889 promoChar = ToLower(name[0]);
5892 UserMoveEvent(fromX, fromY, toX, toY, promoChar);
5894 if (!appData.highlightLastMove || gotPremove) ClearHighlights();
5895 if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
5900 void ErrorCallback(w, client_data, call_data)
5902 XtPointer client_data, call_data;
5905 XtPopdown(w = XtParent(XtParent(XtParent(w))));
5907 if (errorExitStatus != -1) ExitEvent(errorExitStatus);
5913 if (!errorUp) return;
5915 XtPopdown(errorShell);
5916 XtDestroyWidget(errorShell);
5917 if (errorExitStatus != -1) ExitEvent(errorExitStatus);
5920 void ErrorPopUp(title, label, modal)
5921 char *title, *label;
5925 Widget dialog, layout;
5929 Dimension bw_width, pw_width;
5930 Dimension pw_height;
5934 XtSetArg(args[i], XtNresizable, True); i++;
5935 XtSetArg(args[i], XtNtitle, title); i++;
5937 XtCreatePopupShell("errorpopup", transientShellWidgetClass,
5938 shellWidget, args, i);
5940 XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
5941 layoutArgs, XtNumber(layoutArgs));
5944 XtSetArg(args[i], XtNlabel, label); i++;
5945 XtSetArg(args[i], XtNborderWidth, 0); i++;
5946 dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
5949 XawDialogAddButton(dialog, _("ok"), ErrorCallback, (XtPointer) dialog);
5951 XtRealizeWidget(errorShell);
5952 CatchDeleteWindow(errorShell, "ErrorPopDown");
5955 XtSetArg(args[i], XtNwidth, &bw_width); i++;
5956 XtGetValues(boardWidget, args, i);
5958 XtSetArg(args[i], XtNwidth, &pw_width); i++;
5959 XtSetArg(args[i], XtNheight, &pw_height); i++;
5960 XtGetValues(errorShell, args, i);
5963 /* This code seems to tickle an X bug if it is executed too soon
5964 after xboard starts up. The coordinates get transformed as if
5965 the main window was positioned at (0, 0).
5967 XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
5968 0 - pw_height + squareSize / 3, &x, &y);
5970 XTranslateCoordinates(xDisplay, XtWindow(boardWidget),
5971 RootWindowOfScreen(XtScreen(boardWidget)),
5972 (bw_width - pw_width) / 2,
5973 0 - pw_height + squareSize / 3, &xx, &yy, &junk);
5977 if (y < 0) y = 0; /*avoid positioning top offscreen*/
5980 XtSetArg(args[i], XtNx, x); i++;
5981 XtSetArg(args[i], XtNy, y); i++;
5982 XtSetValues(errorShell, args, i);
5985 XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);
5988 /* Disable all user input other than deleting the window */
5989 static int frozen = 0;
5993 /* Grab by a widget that doesn't accept input */
5994 XtAddGrab(messageWidget, TRUE, FALSE);
5998 /* Undo a FreezeUI */
6001 if (!frozen) return;
6002 XtRemoveGrab(messageWidget);
6006 char *ModeToWidgetName(mode)
6010 case BeginningOfGame:
6011 if (appData.icsActive)
6012 return "menuMode.ICS Client";
6013 else if (appData.noChessProgram ||
6014 *appData.cmailGameName != NULLCHAR)
6015 return "menuMode.Edit Game";
6017 return "menuMode.Machine Black";
6018 case MachinePlaysBlack:
6019 return "menuMode.Machine Black";
6020 case MachinePlaysWhite:
6021 return "menuMode.Machine White";
6023 return "menuMode.Analysis Mode";
6025 return "menuMode.Analyze File";
6026 case TwoMachinesPlay:
6027 return "menuMode.Two Machines";
6029 return "menuMode.Edit Game";
6030 case PlayFromGameFile:
6031 return "menuFile.Load Game";
6033 return "menuMode.Edit Position";
6035 return "menuMode.Training";
6036 case IcsPlayingWhite:
6037 case IcsPlayingBlack:
6041 return "menuMode.ICS Client";
6048 void ModeHighlight()
6051 static int oldPausing = FALSE;
6052 static GameMode oldmode = (GameMode) -1;
6055 if (!boardWidget || !XtIsRealized(boardWidget)) return;
6057 if (pausing != oldPausing) {
6058 oldPausing = pausing;
6060 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6062 XtSetArg(args[0], XtNleftBitmap, None);
6064 XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Pause"),
6067 if (appData.showButtonBar) {
6068 /* Always toggle, don't set. Previous code messes up when
6069 invoked while the button is pressed, as releasing it
6070 toggles the state again. */
6073 XtSetArg(args[0], XtNbackground, &oldbg);
6074 XtSetArg(args[1], XtNforeground, &oldfg);
6075 XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),
6077 XtSetArg(args[0], XtNbackground, oldfg);
6078 XtSetArg(args[1], XtNforeground, oldbg);
6080 XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
6084 wname = ModeToWidgetName(oldmode);
6085 if (wname != NULL) {
6086 XtSetArg(args[0], XtNleftBitmap, None);
6087 XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
6089 wname = ModeToWidgetName(gameMode);
6090 if (wname != NULL) {
6091 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6092 XtSetValues(XtNameToWidget(menuBarWidget, wname), args, 1);
6096 /* Maybe all the enables should be handled here, not just this one */
6097 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Training"),
6098 gameMode == Training || gameMode == PlayFromGameFile);
6103 * Button/menu procedures
6105 void ResetProc(w, event, prms, nprms)
6114 int LoadGamePopUp(f, gameNumber, title)
6119 cmailMsgLoaded = FALSE;
6120 if (gameNumber == 0) {
6121 int error = GameListBuild(f);
6123 DisplayError(_("Cannot build game list"), error);
6124 } else if (!ListEmpty(&gameList) &&
6125 ((ListGame *) gameList.tailPred)->number > 1) {
6126 GameListPopUp(f, title);
6132 return LoadGame(f, gameNumber, title, FALSE);
6135 void LoadGameProc(w, event, prms, nprms)
6141 if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
6144 FileNamePopUp(_("Load game file name?"), "", LoadGamePopUp, "rb");
6147 void LoadNextGameProc(w, event, prms, nprms)
6156 void LoadPrevGameProc(w, event, prms, nprms)
6165 void ReloadGameProc(w, event, prms, nprms)
6174 void LoadNextPositionProc(w, event, prms, nprms)
6183 void LoadPrevPositionProc(w, event, prms, nprms)
6192 void ReloadPositionProc(w, event, prms, nprms)
6201 void LoadPositionProc(w, event, prms, nprms)
6207 if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
6210 FileNamePopUp(_("Load position file name?"), "", LoadPosition, "rb");
6213 void SaveGameProc(w, event, prms, nprms)
6219 FileNamePopUp(_("Save game file name?"),
6220 DefaultFileName(appData.oldSaveStyle ? "game" : "pgn"),
6224 void SavePositionProc(w, event, prms, nprms)
6230 FileNamePopUp(_("Save position file name?"),
6231 DefaultFileName(appData.oldSaveStyle ? "pos" : "fen"),
6235 void ReloadCmailMsgProc(w, event, prms, nprms)
6241 ReloadCmailMsgEvent(FALSE);
6244 void MailMoveProc(w, event, prms, nprms)
6253 /* this variable is shared between CopyPositionProc and SendPositionSelection */
6254 static char *selected_fen_position=NULL;
6257 SendPositionSelection(Widget w, Atom *selection, Atom *target,
6258 Atom *type_return, XtPointer *value_return,
6259 unsigned long *length_return, int *format_return)
6261 char *selection_tmp;
6263 if (!selected_fen_position) return False; /* should never happen */
6264 if (*target == XA_STRING){
6265 /* note: since no XtSelectionDoneProc was registered, Xt will
6266 * automatically call XtFree on the value returned. So have to
6267 * make a copy of it allocated with XtMalloc */
6268 selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
6269 strcpy(selection_tmp, selected_fen_position);
6271 *value_return=selection_tmp;
6272 *length_return=strlen(selection_tmp);
6273 *type_return=XA_STRING;
6274 *format_return = 8; /* bits per byte */
6281 /* note: when called from menu all parameters are NULL, so no clue what the
6282 * Widget which was clicked on was, or what the click event was
6284 void CopyPositionProc(w, event, prms, nprms)
6293 * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
6294 * have a notion of a position that is selected but not copied.
6295 * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
6297 if (selected_fen_position) free(selected_fen_position);
6298 selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
6299 if (!selected_fen_position) return;
6300 XtOwnSelection(menuBarWidget, XA_PRIMARY,
6302 SendPositionSelection,
6303 NULL/* lose_ownership_proc */ ,
6304 NULL/* transfer_done_proc */);
6305 XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
6307 SendPositionSelection,
6308 NULL/* lose_ownership_proc */ ,
6309 NULL/* transfer_done_proc */);
6312 /* function called when the data to Paste is ready */
6314 PastePositionCB(Widget w, XtPointer client_data, Atom *selection,
6315 Atom *type, XtPointer value, unsigned long *len, int *format)
6318 if (value==NULL || *len==0) return; /* nothing had been selected to copy */
6319 fenstr[*len]='\0'; /* normally this string is terminated, but be safe */
6320 EditPositionPasteFEN(fenstr);
6324 /* called when Paste Position button is pressed,
6325 * all parameters will be NULL */
6326 void PastePositionProc(w, event, prms, nprms)
6332 XtGetSelectionValue(menuBarWidget,
6333 appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
6334 /* (XtSelectionCallbackProc) */ PastePositionCB,
6335 NULL, /* client_data passed to PastePositionCB */
6337 /* better to use the time field from the event that triggered the
6338 * call to this function, but that isn't trivial to get
6346 SendGameSelection(Widget w, Atom *selection, Atom *target,
6347 Atom *type_return, XtPointer *value_return,
6348 unsigned long *length_return, int *format_return)
6350 char *selection_tmp;
6352 if (*target == XA_STRING){
6353 FILE* f = fopen(gameCopyFilename, "r");
6356 if (f == NULL) return False;
6360 selection_tmp = XtMalloc(len + 1);
6361 count = fread(selection_tmp, 1, len, f);
6363 XtFree(selection_tmp);
6366 selection_tmp[len] = NULLCHAR;
6367 *value_return = selection_tmp;
6368 *length_return = len;
6369 *type_return = XA_STRING;
6370 *format_return = 8; /* bits per byte */
6377 /* note: when called from menu all parameters are NULL, so no clue what the
6378 * Widget which was clicked on was, or what the click event was
6380 void CopyGameProc(w, event, prms, nprms)
6388 ret = SaveGameToFile(gameCopyFilename, FALSE);
6392 * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
6393 * have a notion of a game that is selected but not copied.
6394 * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
6396 XtOwnSelection(menuBarWidget, XA_PRIMARY,
6399 NULL/* lose_ownership_proc */ ,
6400 NULL/* transfer_done_proc */);
6401 XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
6404 NULL/* lose_ownership_proc */ ,
6405 NULL/* transfer_done_proc */);
6408 /* function called when the data to Paste is ready */
6410 PasteGameCB(Widget w, XtPointer client_data, Atom *selection,
6411 Atom *type, XtPointer value, unsigned long *len, int *format)
6414 if (value == NULL || *len == 0) {
6415 return; /* nothing had been selected to copy */
6417 f = fopen(gamePasteFilename, "w");
6419 DisplayError(_("Can't open temp file"), errno);
6422 fwrite(value, 1, *len, f);
6425 LoadGameFromFile(gamePasteFilename, 0, gamePasteFilename, TRUE);
6428 /* called when Paste Game button is pressed,
6429 * all parameters will be NULL */
6430 void PasteGameProc(w, event, prms, nprms)
6436 XtGetSelectionValue(menuBarWidget,
6437 appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
6438 /* (XtSelectionCallbackProc) */ PasteGameCB,
6439 NULL, /* client_data passed to PasteGameCB */
6441 /* better to use the time field from the event that triggered the
6442 * call to this function, but that isn't trivial to get
6452 SaveGameProc(NULL, NULL, NULL, NULL);
6456 void QuitProc(w, event, prms, nprms)
6465 void PauseProc(w, event, prms, nprms)
6475 void MachineBlackProc(w, event, prms, nprms)
6481 MachineBlackEvent();
6484 void MachineWhiteProc(w, event, prms, nprms)
6490 MachineWhiteEvent();
6493 void AnalyzeModeProc(w, event, prms, nprms)
6501 if (!first.analysisSupport) {
6502 snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
6503 DisplayError(buf, 0);
6506 /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
6507 if (appData.icsActive) {
6508 if (gameMode != IcsObserving) {
6509 sprintf(buf,_("You are not observing a game"));
6510 DisplayError(buf, 0);
6512 if (appData.icsEngineAnalyze) {
6513 if (appData.debugMode)
6514 fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
6520 /* if enable, use want disable icsEngineAnalyze */
6521 if (appData.icsEngineAnalyze) {
6526 appData.icsEngineAnalyze = TRUE;
6527 if (appData.debugMode)
6528 fprintf(debugFP, _("ICS engine analyze starting... \n"));
6530 if (!appData.showThinking)
6531 ShowThinkingProc(w,event,prms,nprms);
6536 void AnalyzeFileProc(w, event, prms, nprms)
6542 if (!first.analysisSupport) {
6544 snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
6545 DisplayError(buf, 0);
6550 if (!appData.showThinking)
6551 ShowThinkingProc(w,event,prms,nprms);
6554 FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
6555 AnalysisPeriodicEvent(1);
6558 void TwoMachinesProc(w, event, prms, nprms)
6567 void IcsClientProc(w, event, prms, nprms)
6576 void EditGameProc(w, event, prms, nprms)
6585 void EditPositionProc(w, event, prms, nprms)
6591 EditPositionEvent();
6594 void TrainingProc(w, event, prms, nprms)
6603 void EditCommentProc(w, event, prms, nprms)
6610 EditCommentPopDown();
6616 void IcsInputBoxProc(w, event, prms, nprms)
6622 if (ICSInputBoxUp) {
6623 ICSInputBoxPopDown();
6629 void AcceptProc(w, event, prms, nprms)
6638 void DeclineProc(w, event, prms, nprms)
6647 void RematchProc(w, event, prms, nprms)
6656 void CallFlagProc(w, event, prms, nprms)
6665 void DrawProc(w, event, prms, nprms)
6674 void AbortProc(w, event, prms, nprms)
6683 void AdjournProc(w, event, prms, nprms)
6692 void ResignProc(w, event, prms, nprms)
6701 void AdjuWhiteProc(w, event, prms, nprms)
6707 UserAdjudicationEvent(+1);
6710 void AdjuBlackProc(w, event, prms, nprms)
6716 UserAdjudicationEvent(-1);
6719 void AdjuDrawProc(w, event, prms, nprms)
6725 UserAdjudicationEvent(0);
6728 void EnterKeyProc(w, event, prms, nprms)
6734 if (ICSInputBoxUp == True)
6738 void StopObservingProc(w, event, prms, nprms)
6744 StopObservingEvent();
6747 void StopExaminingProc(w, event, prms, nprms)
6753 StopExaminingEvent();
6757 void ForwardProc(w, event, prms, nprms)
6767 void BackwardProc(w, event, prms, nprms)
6776 void ToStartProc(w, event, prms, nprms)
6785 void ToEndProc(w, event, prms, nprms)
6794 void RevertProc(w, event, prms, nprms)
6803 void TruncateGameProc(w, event, prms, nprms)
6809 TruncateGameEvent();
6811 void RetractMoveProc(w, event, prms, nprms)
6820 void MoveNowProc(w, event, prms, nprms)
6830 void AlwaysQueenProc(w, event, prms, nprms)
6838 appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;
6840 if (appData.alwaysPromoteToQueen) {
6841 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6843 XtSetArg(args[0], XtNleftBitmap, None);
6845 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
6849 void AnimateDraggingProc(w, event, prms, nprms)
6857 appData.animateDragging = !appData.animateDragging;
6859 if (appData.animateDragging) {
6860 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6863 XtSetArg(args[0], XtNleftBitmap, None);
6865 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Dragging"),
6869 void AnimateMovingProc(w, event, prms, nprms)
6877 appData.animate = !appData.animate;
6879 if (appData.animate) {
6880 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6883 XtSetArg(args[0], XtNleftBitmap, None);
6885 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
6889 void AutocommProc(w, event, prms, nprms)
6897 appData.autoComment = !appData.autoComment;
6899 if (appData.autoComment) {
6900 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6902 XtSetArg(args[0], XtNleftBitmap, None);
6904 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
6909 void AutoflagProc(w, event, prms, nprms)
6917 appData.autoCallFlag = !appData.autoCallFlag;
6919 if (appData.autoCallFlag) {
6920 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6922 XtSetArg(args[0], XtNleftBitmap, None);
6924 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
6928 void AutoflipProc(w, event, prms, nprms)
6936 appData.autoFlipView = !appData.autoFlipView;
6938 if (appData.autoFlipView) {
6939 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6941 XtSetArg(args[0], XtNleftBitmap, None);
6943 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),
6947 void AutobsProc(w, event, prms, nprms)
6955 appData.autoObserve = !appData.autoObserve;
6957 if (appData.autoObserve) {
6958 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6960 XtSetArg(args[0], XtNleftBitmap, None);
6962 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
6966 void AutoraiseProc(w, event, prms, nprms)
6974 appData.autoRaiseBoard = !appData.autoRaiseBoard;
6976 if (appData.autoRaiseBoard) {
6977 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6979 XtSetArg(args[0], XtNleftBitmap, None);
6981 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Raise Board"),
6985 void AutosaveProc(w, event, prms, nprms)
6993 appData.autoSaveGames = !appData.autoSaveGames;
6995 if (appData.autoSaveGames) {
6996 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6998 XtSetArg(args[0], XtNleftBitmap, None);
7000 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
7004 void BlindfoldProc(w, event, prms, nprms)
7012 appData.blindfold = !appData.blindfold;
7014 if (appData.blindfold) {
7015 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7017 XtSetArg(args[0], XtNleftBitmap, None);
7019 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Blindfold"),
7022 DrawPosition(True, NULL);
7025 void TestLegalityProc(w, event, prms, nprms)
7033 appData.testLegality = !appData.testLegality;
7035 if (appData.testLegality) {
7036 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7038 XtSetArg(args[0], XtNleftBitmap, None);
7040 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Test Legality"),
7045 void FlashMovesProc(w, event, prms, nprms)
7053 if (appData.flashCount == 0) {
7054 appData.flashCount = 3;
7056 appData.flashCount = -appData.flashCount;
7059 if (appData.flashCount > 0) {
7060 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7062 XtSetArg(args[0], XtNleftBitmap, None);
7064 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flash Moves"),
7068 void FlipViewProc(w, event, prms, nprms)
7074 flipView = !flipView;
7075 DrawPosition(True, NULL);
7078 void GetMoveListProc(w, event, prms, nprms)
7086 appData.getMoveList = !appData.getMoveList;
7088 if (appData.getMoveList) {
7089 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7092 XtSetArg(args[0], XtNleftBitmap, None);
7094 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
7099 void HighlightDraggingProc(w, event, prms, nprms)
7107 appData.highlightDragging = !appData.highlightDragging;
7109 if (appData.highlightDragging) {
7110 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7112 XtSetArg(args[0], XtNleftBitmap, None);
7114 XtSetValues(XtNameToWidget(menuBarWidget,
7115 "menuOptions.Highlight Dragging"), args, 1);
7119 void HighlightLastMoveProc(w, event, prms, nprms)
7127 appData.highlightLastMove = !appData.highlightLastMove;
7129 if (appData.highlightLastMove) {
7130 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7132 XtSetArg(args[0], XtNleftBitmap, None);
7134 XtSetValues(XtNameToWidget(menuBarWidget,
7135 "menuOptions.Highlight Last Move"), args, 1);
7138 void IcsAlarmProc(w, event, prms, nprms)
7146 appData.icsAlarm = !appData.icsAlarm;
7148 if (appData.icsAlarm) {
7149 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7151 XtSetArg(args[0], XtNleftBitmap, None);
7153 XtSetValues(XtNameToWidget(menuBarWidget,
7154 "menuOptions.ICS Alarm"), args, 1);
7157 void MoveSoundProc(w, event, prms, nprms)
7165 appData.ringBellAfterMoves = !appData.ringBellAfterMoves;
7167 if (appData.ringBellAfterMoves) {
7168 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7170 XtSetArg(args[0], XtNleftBitmap, None);
7172 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
7177 void OldSaveStyleProc(w, event, prms, nprms)
7185 appData.oldSaveStyle = !appData.oldSaveStyle;
7187 if (appData.oldSaveStyle) {
7188 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7190 XtSetArg(args[0], XtNleftBitmap, None);
7192 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Old Save Style"),
7196 void PeriodicUpdatesProc(w, event, prms, nprms)
7204 PeriodicUpdatesEvent(!appData.periodicUpdates);
7206 if (appData.periodicUpdates) {
7207 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7209 XtSetArg(args[0], XtNleftBitmap, None);
7211 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Periodic Updates"),
7215 void PonderNextMoveProc(w, event, prms, nprms)
7223 PonderNextMoveEvent(!appData.ponderNextMove);
7225 if (appData.ponderNextMove) {
7226 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7228 XtSetArg(args[0], XtNleftBitmap, None);
7230 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Ponder Next Move"),
7234 void PopupExitMessageProc(w, event, prms, nprms)
7242 appData.popupExitMessage = !appData.popupExitMessage;
7244 if (appData.popupExitMessage) {
7245 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7247 XtSetArg(args[0], XtNleftBitmap, None);
7249 XtSetValues(XtNameToWidget(menuBarWidget,
7250 "menuOptions.Popup Exit Message"), args, 1);
7253 void PopupMoveErrorsProc(w, event, prms, nprms)
7261 appData.popupMoveErrors = !appData.popupMoveErrors;
7263 if (appData.popupMoveErrors) {
7264 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7266 XtSetArg(args[0], XtNleftBitmap, None);
7268 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Popup Move Errors"),
7272 void PremoveProc(w, event, prms, nprms)
7280 appData.premove = !appData.premove;
7282 if (appData.premove) {
7283 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7285 XtSetArg(args[0], XtNleftBitmap, None);
7287 XtSetValues(XtNameToWidget(menuBarWidget,
7288 "menuOptions.Premove"), args, 1);
7291 void QuietPlayProc(w, event, prms, nprms)
7299 appData.quietPlay = !appData.quietPlay;
7301 if (appData.quietPlay) {
7302 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7304 XtSetArg(args[0], XtNleftBitmap, None);
7306 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Quiet Play"),
7310 void ShowCoordsProc(w, event, prms, nprms)
7318 appData.showCoords = !appData.showCoords;
7320 if (appData.showCoords) {
7321 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7323 XtSetArg(args[0], XtNleftBitmap, None);
7325 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
7328 DrawPosition(True, NULL);
7331 void ShowThinkingProc(w, event, prms, nprms)
7339 appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
7340 ShowThinkingEvent();
7343 void HideThinkingProc(w, event, prms, nprms)
7351 appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
7352 ShowThinkingEvent();
7354 if (appData.hideThinkingFromHuman) {
7355 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7357 XtSetArg(args[0], XtNleftBitmap, None);
7359 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
7363 void InfoProc(w, event, prms, nprms)
7370 snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
7375 void ManProc(w, event, prms, nprms)
7383 if (nprms && *nprms > 0)
7387 snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
7391 void HintProc(w, event, prms, nprms)
7400 void BookProc(w, event, prms, nprms)
7409 void AboutProc(w, event, prms, nprms)
7417 char *zippy = " (with Zippy code)";
7421 snprintf(buf, sizeof(buf), "%s%s\n\n%s\n%s\n%s\n\n%s%s\n%s",
7422 programVersion, zippy,
7423 "Copyright 1991 Digital Equipment Corporation",
7424 "Enhancements Copyright 1992-2009 Free Software Foundation",
7425 "Enhancements Copyright 2005 Alessandro Scotti",
7426 PACKAGE, " is free software and carries NO WARRANTY;",
7427 "see the file COPYING for more information.");
7428 ErrorPopUp(_("About XBoard"), buf, FALSE);
7431 void DebugProc(w, event, prms, nprms)
7437 appData.debugMode = !appData.debugMode;
7440 void AboutGameProc(w, event, prms, nprms)
7449 void NothingProc(w, event, prms, nprms)
7458 void Iconify(w, event, prms, nprms)
7467 XtSetArg(args[0], XtNiconic, True);
7468 XtSetValues(shellWidget, args, 1);
7471 void DisplayMessage(message, extMessage)
7472 char *message, *extMessage;
7474 /* display a message in the message widget */
7483 snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
7488 message = extMessage;
7492 /* need to test if messageWidget already exists, since this function
7493 can also be called during the startup, if for example a Xresource
7494 is not set up correctly */
7497 XtSetArg(arg, XtNlabel, message);
7498 XtSetValues(messageWidget, &arg, 1);
7504 void DisplayTitle(text)
7509 char title[MSG_SIZ];
7512 if (text == NULL) text = "";
7514 if (appData.titleInWindow) {
7516 XtSetArg(args[i], XtNlabel, text); i++;
7517 XtSetValues(titleWidget, args, i);
7520 if (*text != NULLCHAR) {
7522 strcpy(title, text);
7523 } else if (appData.icsActive) {
7524 snprintf(icon, sizeof(icon), "%s", appData.icsHost);
7525 snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
7526 } else if (appData.cmailGameName[0] != NULLCHAR) {
7527 snprintf(icon, sizeof(icon), "%s", "CMail");
7528 snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
7530 // [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
7531 } else if (gameInfo.variant == VariantGothic) {
7532 strcpy(icon, programName);
7533 strcpy(title, GOTHIC);
7536 } else if (gameInfo.variant == VariantFalcon) {
7537 strcpy(icon, programName);
7538 strcpy(title, FALCON);
7540 } else if (appData.noChessProgram) {
7541 strcpy(icon, programName);
7542 strcpy(title, programName);
7544 strcpy(icon, first.tidy);
7545 snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
7548 XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
7549 XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;
7550 XtSetValues(shellWidget, args, i);
7554 void DisplayError(message, error)
7561 if (appData.debugMode || appData.matchMode) {
7562 fprintf(stderr, "%s: %s\n", programName, message);
7565 if (appData.debugMode || appData.matchMode) {
7566 fprintf(stderr, "%s: %s: %s\n",
7567 programName, message, strerror(error));
7569 snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
7572 ErrorPopUp(_("Error"), message, FALSE);
7576 void DisplayMoveError(message)
7581 DrawPosition(FALSE, NULL);
7582 if (appData.debugMode || appData.matchMode) {
7583 fprintf(stderr, "%s: %s\n", programName, message);
7585 if (appData.popupMoveErrors) {
7586 ErrorPopUp(_("Error"), message, FALSE);
7588 DisplayMessage(message, "");
7593 void DisplayFatalError(message, error, status)
7599 errorExitStatus = status;
7601 fprintf(stderr, "%s: %s\n", programName, message);
7603 fprintf(stderr, "%s: %s: %s\n",
7604 programName, message, strerror(error));
7605 snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
7608 if (appData.popupExitMessage && boardWidget && XtIsRealized(boardWidget)) {
7609 ErrorPopUp(status ? _("Fatal Error") : _("Exiting"), message, TRUE);
7615 void DisplayInformation(message)
7619 ErrorPopUp(_("Information"), message, TRUE);
7622 void DisplayNote(message)
7626 ErrorPopUp(_("Note"), message, FALSE);
7630 NullXErrorCheck(dpy, error_event)
7632 XErrorEvent *error_event;
7637 void DisplayIcsInteractionTitle(message)
7640 if (oldICSInteractionTitle == NULL) {
7641 /* Magic to find the old window title, adapted from vim */
7642 char *wina = getenv("WINDOWID");
7644 Window win = (Window) atoi(wina);
7645 Window root, parent, *children;
7646 unsigned int nchildren;
7647 int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
7649 if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
7650 if (!XQueryTree(xDisplay, win, &root, &parent,
7651 &children, &nchildren)) break;
7652 if (children) XFree((void *)children);
7653 if (parent == root || parent == 0) break;
7656 XSetErrorHandler(oldHandler);
7658 if (oldICSInteractionTitle == NULL) {
7659 oldICSInteractionTitle = "xterm";
7662 printf("\033]0;%s\007", message);
7666 char pendingReplyPrefix[MSG_SIZ];
7667 ProcRef pendingReplyPR;
7669 void AskQuestionProc(w, event, prms, nprms)
7676 fprintf(stderr, _("AskQuestionProc needed 4 parameters, got %d\n"),
7680 AskQuestionEvent(prms[0], prms[1], prms[2], prms[3]);
7683 void AskQuestionPopDown()
7685 if (!askQuestionUp) return;
7686 XtPopdown(askQuestionShell);
7687 XtDestroyWidget(askQuestionShell);
7688 askQuestionUp = False;
7691 void AskQuestionReplyAction(w, event, prms, nprms)
7701 reply = XawDialogGetValueString(w = XtParent(w));
7702 strcpy(buf, pendingReplyPrefix);
7703 if (*buf) strcat(buf, " ");
7706 OutputToProcess(pendingReplyPR, buf, strlen(buf), &err);
7707 AskQuestionPopDown();
7709 if (err) DisplayFatalError(_("Error writing to chess program"), err, 0);
7712 void AskQuestionCallback(w, client_data, call_data)
7714 XtPointer client_data, call_data;
7719 XtSetArg(args[0], XtNlabel, &name);
7720 XtGetValues(w, args, 1);
7722 if (strcmp(name, _("cancel")) == 0) {
7723 AskQuestionPopDown();
7725 AskQuestionReplyAction(w, NULL, NULL, NULL);
7729 void AskQuestion(title, question, replyPrefix, pr)
7730 char *title, *question, *replyPrefix;
7734 Widget popup, layout, dialog, edit;
7740 strcpy(pendingReplyPrefix, replyPrefix);
7741 pendingReplyPR = pr;
7744 XtSetArg(args[i], XtNresizable, True); i++;
7745 XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
7746 askQuestionShell = popup =
7747 XtCreatePopupShell(title, transientShellWidgetClass,
7748 shellWidget, args, i);
7751 XtCreateManagedWidget(layoutName, formWidgetClass, popup,
7752 layoutArgs, XtNumber(layoutArgs));
7755 XtSetArg(args[i], XtNlabel, question); i++;
7756 XtSetArg(args[i], XtNvalue, ""); i++;
7757 XtSetArg(args[i], XtNborderWidth, 0); i++;
7758 dialog = XtCreateManagedWidget("question", dialogWidgetClass,
7761 XawDialogAddButton(dialog, _("enter"), AskQuestionCallback,
7762 (XtPointer) dialog);
7763 XawDialogAddButton(dialog, _("cancel"), AskQuestionCallback,
7764 (XtPointer) dialog);
7766 XtRealizeWidget(popup);
7767 CatchDeleteWindow(popup, "AskQuestionPopDown");
7769 XQueryPointer(xDisplay, xBoardWindow, &root, &child,
7770 &x, &y, &win_x, &win_y, &mask);
7772 XtSetArg(args[0], XtNx, x - 10);
7773 XtSetArg(args[1], XtNy, y - 30);
7774 XtSetValues(popup, args, 2);
7776 XtPopup(popup, XtGrabExclusive);
7777 askQuestionUp = True;
7779 edit = XtNameToWidget(dialog, "*value");
7780 XtSetKeyboardFocus(popup, edit);
7788 if (*name == NULLCHAR) {
7790 } else if (strcmp(name, "$") == 0) {
7791 putc(BELLCHAR, stderr);
7794 snprintf(buf, sizeof(buf), "%s '%s' &", appData.soundProgram, name);
7802 PlaySound(appData.soundMove);
7808 PlaySound(appData.soundIcsWin);
7814 PlaySound(appData.soundIcsLoss);
7820 PlaySound(appData.soundIcsDraw);
7824 PlayIcsUnfinishedSound()
7826 PlaySound(appData.soundIcsUnfinished);
7832 PlaySound(appData.soundIcsAlarm);
7838 system("stty echo");
7844 system("stty -echo");
7848 Colorize(cc, continuation)
7853 int count, outCount, error;
7855 if (textColors[(int)cc].bg > 0) {
7856 if (textColors[(int)cc].fg > 0) {
7857 sprintf(buf, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
7858 textColors[(int)cc].fg, textColors[(int)cc].bg);
7860 sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
7861 textColors[(int)cc].bg);
7864 if (textColors[(int)cc].fg > 0) {
7865 sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
7866 textColors[(int)cc].fg);
7868 sprintf(buf, "\033[0;%dm", textColors[(int)cc].attr);
7871 count = strlen(buf);
7872 outCount = OutputToProcess(NoProc, buf, count, &error);
7873 if (outCount < count) {
7874 DisplayFatalError(_("Error writing to display"), error, 1);
7877 if (continuation) return;
7880 PlaySound(appData.soundShout);
7883 PlaySound(appData.soundSShout);
7886 PlaySound(appData.soundChannel1);
7889 PlaySound(appData.soundChannel);
7892 PlaySound(appData.soundKibitz);
7895 PlaySound(appData.soundTell);
7897 case ColorChallenge:
7898 PlaySound(appData.soundChallenge);
7901 PlaySound(appData.soundRequest);
7904 PlaySound(appData.soundSeek);
7915 return getpwuid(getuid())->pw_name;
7918 static char *ExpandPathName(path)
7921 static char static_buf[2000];
7922 char *d, *s, buf[2000];
7928 while (*s && isspace(*s))
7937 if (*(s+1) == '/') {
7938 strcpy(d, getpwuid(getuid())->pw_dir);
7943 *strchr(buf, '/') = 0;
7944 pwd = getpwnam(buf);
7947 fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
7951 strcpy(d, pwd->pw_dir);
7952 strcat(d, strchr(s+1, '/'));
7963 static char host_name[MSG_SIZ];
7965 #if HAVE_GETHOSTNAME
7966 gethostname(host_name, MSG_SIZ);
7968 #else /* not HAVE_GETHOSTNAME */
7969 # if HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H
7970 sysinfo(SI_HOSTNAME, host_name, MSG_SIZ);
7972 # else /* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */
7974 # endif/* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */
7975 #endif /* not HAVE_GETHOSTNAME */
7978 XtIntervalId delayedEventTimerXID = 0;
7979 DelayedEventCallback delayedEventCallback = 0;
7984 delayedEventTimerXID = 0;
7985 delayedEventCallback();
7989 ScheduleDelayedEvent(cb, millisec)
7990 DelayedEventCallback cb; long millisec;
7992 if(delayedEventTimerXID && delayedEventCallback == cb)
7993 // [HGM] alive: replace, rather than add or flush identical event
7994 XtRemoveTimeOut(delayedEventTimerXID);
7995 delayedEventCallback = cb;
7996 delayedEventTimerXID =
7997 XtAppAddTimeOut(appContext, millisec,
7998 (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
8001 DelayedEventCallback
8004 if (delayedEventTimerXID) {
8005 return delayedEventCallback;
8012 CancelDelayedEvent()
8014 if (delayedEventTimerXID) {
8015 XtRemoveTimeOut(delayedEventTimerXID);
8016 delayedEventTimerXID = 0;
8020 XtIntervalId loadGameTimerXID = 0;
8022 int LoadGameTimerRunning()
8024 return loadGameTimerXID != 0;
8027 int StopLoadGameTimer()
8029 if (loadGameTimerXID != 0) {
8030 XtRemoveTimeOut(loadGameTimerXID);
8031 loadGameTimerXID = 0;
8039 LoadGameTimerCallback(arg, id)
8043 loadGameTimerXID = 0;
8048 StartLoadGameTimer(millisec)
8052 XtAppAddTimeOut(appContext, millisec,
8053 (XtTimerCallbackProc) LoadGameTimerCallback,
8057 XtIntervalId analysisClockXID = 0;
8060 AnalysisClockCallback(arg, id)
8064 if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
8065 || appData.icsEngineAnalyze) { // [DM]
8066 AnalysisPeriodicEvent(0);
8067 StartAnalysisClock();
8072 StartAnalysisClock()
8075 XtAppAddTimeOut(appContext, 2000,
8076 (XtTimerCallbackProc) AnalysisClockCallback,
8080 XtIntervalId clockTimerXID = 0;
8082 int ClockTimerRunning()
8084 return clockTimerXID != 0;
8087 int StopClockTimer()
8089 if (clockTimerXID != 0) {
8090 XtRemoveTimeOut(clockTimerXID);
8099 ClockTimerCallback(arg, id)
8108 StartClockTimer(millisec)
8112 XtAppAddTimeOut(appContext, millisec,
8113 (XtTimerCallbackProc) ClockTimerCallback,
8118 DisplayTimerLabel(w, color, timer, highlight)
8127 /* check for low time warning */
8128 Pixel foregroundOrWarningColor = timerForegroundPixel;
8131 appData.lowTimeWarning &&
8132 (timer / 1000) < appData.icsAlarmTime)
8133 foregroundOrWarningColor = lowTimeWarningColor;
8135 if (appData.clockMode) {
8136 sprintf(buf, "%s: %s", color, TimeString(timer));
8137 XtSetArg(args[0], XtNlabel, buf);
8139 sprintf(buf, "%s ", color);
8140 XtSetArg(args[0], XtNlabel, buf);
8145 XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
8146 XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
8148 XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
8149 XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
8152 XtSetValues(w, args, 3);
8156 DisplayWhiteClock(timeRemaining, highlight)
8162 if(appData.noGUI) return;
8163 DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
8164 if (highlight && iconPixmap == bIconPixmap) {
8165 iconPixmap = wIconPixmap;
8166 XtSetArg(args[0], XtNiconPixmap, iconPixmap);
8167 XtSetValues(shellWidget, args, 1);
8172 DisplayBlackClock(timeRemaining, highlight)
8178 if(appData.noGUI) return;
8179 DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
8180 if (highlight && iconPixmap == wIconPixmap) {
8181 iconPixmap = bIconPixmap;
8182 XtSetArg(args[0], XtNiconPixmap, iconPixmap);
8183 XtSetValues(shellWidget, args, 1);
8201 int StartChildProcess(cmdLine, dir, pr)
8208 int to_prog[2], from_prog[2];
8212 if (appData.debugMode) {
8213 fprintf(stderr, "StartChildProcess (dir=\"%s\") %s\n",dir, cmdLine);
8216 /* We do NOT feed the cmdLine to the shell; we just
8217 parse it into blank-separated arguments in the
8218 most simple-minded way possible.
8221 strcpy(buf, cmdLine);
8226 if (p == NULL) break;
8231 SetUpChildIO(to_prog, from_prog);
8233 if ((pid = fork()) == 0) {
8235 // [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
8236 close(to_prog[1]); // first close the unused pipe ends
8237 close(from_prog[0]);
8238 dup2(to_prog[0], 0); // to_prog was created first, nd is the only one to use 0 or 1
8239 dup2(from_prog[1], 1);
8240 if(to_prog[0] >= 2) close(to_prog[0]); // if 0 or 1, the dup2 already cosed the original
8241 close(from_prog[1]); // and closing again loses one of the pipes!
8242 if(fileno(stderr) >= 2) // better safe than sorry...
8243 dup2(1, fileno(stderr)); /* force stderr to the pipe */
8245 if (dir[0] != NULLCHAR && chdir(dir) != 0) {
8250 nice(appData.niceEngines); // [HGM] nice: adjust priority of engine proc
8252 execvp(argv[0], argv);
8254 /* If we get here, exec failed */
8259 /* Parent process */
8261 close(from_prog[1]);
8263 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8266 cp->fdFrom = from_prog[0];
8267 cp->fdTo = to_prog[1];
8272 // [HGM] kill: implement the 'hard killing' of AS's Winboard_x
8273 static RETSIGTYPE AlarmCallBack(int n)
8279 DestroyChildProcess(pr, signalType)
8283 ChildProc *cp = (ChildProc *) pr;
8285 if (cp->kind != CPReal) return;
8287 if (signalType == 10) { // [HGM] kill: if it does not terminate in 3 sec, kill
8288 signal(SIGALRM, AlarmCallBack);
8290 if(wait((int *) 0) == -1) { // process does not terminate on its own accord
8291 kill(cp->pid, SIGKILL); // kill it forcefully
8292 wait((int *) 0); // and wait again
8296 kill(cp->pid, signalType == 9 ? SIGKILL : SIGTERM); // [HGM] kill: use hard kill if so requested
8298 /* Process is exiting either because of the kill or because of
8299 a quit command sent by the backend; either way, wait for it to die.
8308 InterruptChildProcess(pr)
8311 ChildProc *cp = (ChildProc *) pr;
8313 if (cp->kind != CPReal) return;
8314 (void) kill(cp->pid, SIGINT); /* stop it thinking */
8317 int OpenTelnet(host, port, pr)
8322 char cmdLine[MSG_SIZ];
8324 if (port[0] == NULLCHAR) {
8325 snprintf(cmdLine, sizeof(cmdLine), "%s %s", appData.telnetProgram, host);
8327 snprintf(cmdLine, sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
8329 return StartChildProcess(cmdLine, "", pr);
8332 int OpenTCP(host, port, pr)
8338 DisplayFatalError(_("Socket support is not configured in"), 0, 2);
8339 #else /* !OMIT_SOCKETS */
8341 struct sockaddr_in sa;
8343 unsigned short uport;
8346 if ((s = socket(AF_INET, SOCK_STREAM, 6)) < 0) {
8350 memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));
8351 sa.sin_family = AF_INET;
8352 sa.sin_addr.s_addr = INADDR_ANY;
8353 uport = (unsigned short) 0;
8354 sa.sin_port = htons(uport);
8355 if (bind(s, (struct sockaddr *) &sa, sizeof(struct sockaddr_in)) < 0) {
8359 memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));
8360 if (!(hp = gethostbyname(host))) {
8362 if (sscanf(host, "%d.%d.%d.%d", &b0, &b1, &b2, &b3) == 4) {
8363 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
8364 hp->h_addrtype = AF_INET;
8366 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
8367 hp->h_addr_list[0] = (char *) malloc(4);
8368 hp->h_addr_list[0][0] = b0;
8369 hp->h_addr_list[0][1] = b1;
8370 hp->h_addr_list[0][2] = b2;
8371 hp->h_addr_list[0][3] = b3;
8376 sa.sin_family = hp->h_addrtype;
8377 uport = (unsigned short) atoi(port);
8378 sa.sin_port = htons(uport);
8379 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
8381 if (connect(s, (struct sockaddr *) &sa,
8382 sizeof(struct sockaddr_in)) < 0) {
8386 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8393 #endif /* !OMIT_SOCKETS */
8398 int OpenCommPort(name, pr)
8405 fd = open(name, 2, 0);
8406 if (fd < 0) return errno;
8408 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8418 int OpenLoopback(pr)
8424 SetUpChildIO(to, from);
8426 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8429 cp->fdFrom = to[0]; /* note not from[0]; we are doing a loopback */
8436 int OpenRcmd(host, user, cmd, pr)
8437 char *host, *user, *cmd;
8440 DisplayFatalError(_("internal rcmd not implemented for Unix"), 0, 1);
8444 #define INPUT_SOURCE_BUF_SIZE 8192
8453 char buf[INPUT_SOURCE_BUF_SIZE];
8458 DoInputCallback(closure, source, xid)
8463 InputSource *is = (InputSource *) closure;
8468 if (is->lineByLine) {
8469 count = read(is->fd, is->unused,
8470 INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
8472 (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
8475 is->unused += count;
8477 while (p < is->unused) {
8478 q = memchr(p, '\n', is->unused - p);
8479 if (q == NULL) break;
8481 (is->func)(is, is->closure, p, q - p, 0);
8485 while (p < is->unused) {
8490 count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
8495 (is->func)(is, is->closure, is->buf, count, error);
8499 InputSourceRef AddInputSource(pr, lineByLine, func, closure)
8506 ChildProc *cp = (ChildProc *) pr;
8508 is = (InputSource *) calloc(1, sizeof(InputSource));
8509 is->lineByLine = lineByLine;
8513 is->fd = fileno(stdin);
8515 is->kind = cp->kind;
8516 is->fd = cp->fdFrom;
8519 is->unused = is->buf;
8522 is->xid = XtAppAddInput(appContext, is->fd,
8523 (XtPointer) (XtInputReadMask),
8524 (XtInputCallbackProc) DoInputCallback,
8526 is->closure = closure;
8527 return (InputSourceRef) is;
8531 RemoveInputSource(isr)
8534 InputSource *is = (InputSource *) isr;
8536 if (is->xid == 0) return;
8537 XtRemoveInput(is->xid);
8541 int OutputToProcess(pr, message, count, outError)
8547 static int line = 0;
8548 ChildProc *cp = (ChildProc *) pr;
8553 if (appData.noJoin || !appData.useInternalWrap)
8554 outCount = fwrite(message, 1, count, stdout);
8557 int width = get_term_width();
8558 int len = wrap(NULL, message, count, width, &line);
8559 char *msg = malloc(len);
8563 outCount = fwrite(message, 1, count, stdout);
8566 dbgchk = wrap(msg, message, count, width, &line);
8567 if (dbgchk != len && appData.debugMode)
8568 fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
8569 outCount = fwrite(msg, 1, dbgchk, stdout);
8575 outCount = write(cp->fdTo, message, count);
8585 /* Output message to process, with "ms" milliseconds of delay
8586 between each character. This is needed when sending the logon
8587 script to ICC, which for some reason doesn't like the
8588 instantaneous send. */
8589 int OutputToProcessDelayed(pr, message, count, outError, msdelay)
8596 ChildProc *cp = (ChildProc *) pr;
8601 r = write(cp->fdTo, message++, 1);
8614 /**** Animation code by Hugh Fisher, DCS, ANU.
8616 Known problem: if a window overlapping the board is
8617 moved away while a piece is being animated underneath,
8618 the newly exposed area won't be updated properly.
8619 I can live with this.
8621 Known problem: if you look carefully at the animation
8622 of pieces in mono mode, they are being drawn as solid
8623 shapes without interior detail while moving. Fixing
8624 this would be a major complication for minimal return.
8627 /* Masks for XPM pieces. Black and white pieces can have
8628 different shapes, but in the interest of retaining my
8629 sanity pieces must have the same outline on both light
8630 and dark squares, and all pieces must use the same
8631 background square colors/images. */
8633 static int xpmDone = 0;
8636 CreateAnimMasks (pieceDepth)
8643 unsigned long plane;
8646 /* Need a bitmap just to get a GC with right depth */
8647 buf = XCreatePixmap(xDisplay, xBoardWindow,
8649 values.foreground = 1;
8650 values.background = 0;
8651 /* Don't use XtGetGC, not read only */
8652 maskGC = XCreateGC(xDisplay, buf,
8653 GCForeground | GCBackground, &values);
8654 XFreePixmap(xDisplay, buf);
8656 buf = XCreatePixmap(xDisplay, xBoardWindow,
8657 squareSize, squareSize, pieceDepth);
8658 values.foreground = XBlackPixel(xDisplay, xScreen);
8659 values.background = XWhitePixel(xDisplay, xScreen);
8660 bufGC = XCreateGC(xDisplay, buf,
8661 GCForeground | GCBackground, &values);
8663 for (piece = WhitePawn; piece <= BlackKing; piece++) {
8664 /* Begin with empty mask */
8665 if(!xpmDone) // [HGM] pieces: keep using existing
8666 xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
8667 squareSize, squareSize, 1);
8668 XSetFunction(xDisplay, maskGC, GXclear);
8669 XFillRectangle(xDisplay, xpmMask[piece], maskGC,
8670 0, 0, squareSize, squareSize);
8672 /* Take a copy of the piece */
8677 XSetFunction(xDisplay, bufGC, GXcopy);
8678 XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
8680 0, 0, squareSize, squareSize, 0, 0);
8682 /* XOR the background (light) over the piece */
8683 XSetFunction(xDisplay, bufGC, GXxor);
8685 XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
8686 0, 0, squareSize, squareSize, 0, 0);
8688 XSetForeground(xDisplay, bufGC, lightSquareColor);
8689 XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
8692 /* We now have an inverted piece image with the background
8693 erased. Construct mask by just selecting all the non-zero
8694 pixels - no need to reconstruct the original image. */
8695 XSetFunction(xDisplay, maskGC, GXor);
8697 /* Might be quicker to download an XImage and create bitmap
8698 data from it rather than this N copies per piece, but it
8699 only takes a fraction of a second and there is a much
8700 longer delay for loading the pieces. */
8701 for (n = 0; n < pieceDepth; n ++) {
8702 XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
8703 0, 0, squareSize, squareSize,
8709 XFreePixmap(xDisplay, buf);
8710 XFreeGC(xDisplay, bufGC);
8711 XFreeGC(xDisplay, maskGC);
8715 InitAnimState (anim, info)
8717 XWindowAttributes * info;
8722 /* Each buffer is square size, same depth as window */
8723 anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
8724 squareSize, squareSize, info->depth);
8725 anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
8726 squareSize, squareSize, info->depth);
8728 /* Create a plain GC for blitting */
8729 mask = GCForeground | GCBackground | GCFunction |
8730 GCPlaneMask | GCGraphicsExposures;
8731 values.foreground = XBlackPixel(xDisplay, xScreen);
8732 values.background = XWhitePixel(xDisplay, xScreen);
8733 values.function = GXcopy;
8734 values.plane_mask = AllPlanes;
8735 values.graphics_exposures = False;
8736 anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
8738 /* Piece will be copied from an existing context at
8739 the start of each new animation/drag. */
8740 anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
8742 /* Outline will be a read-only copy of an existing */
8743 anim->outlineGC = None;
8749 static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
8750 XWindowAttributes info;
8752 if (xpmDone && gameInfo.variant == old) return;
8753 if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
8754 XGetWindowAttributes(xDisplay, xBoardWindow, &info);
8756 InitAnimState(&game, &info);
8757 InitAnimState(&player, &info);
8759 /* For XPM pieces, we need bitmaps to use as masks. */
8761 CreateAnimMasks(info.depth);
8767 static Boolean frameWaiting;
8769 static RETSIGTYPE FrameAlarm (sig)
8772 frameWaiting = False;
8773 /* In case System-V style signals. Needed?? */
8774 signal(SIGALRM, FrameAlarm);
8781 struct itimerval delay;
8783 XSync(xDisplay, False);
8786 frameWaiting = True;
8787 signal(SIGALRM, FrameAlarm);
8788 delay.it_interval.tv_sec =
8789 delay.it_value.tv_sec = time / 1000;
8790 delay.it_interval.tv_usec =
8791 delay.it_value.tv_usec = (time % 1000) * 1000;
8792 setitimer(ITIMER_REAL, &delay, NULL);
8793 while (frameWaiting) pause();
8794 delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;
8795 delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;
8796 setitimer(ITIMER_REAL, &delay, NULL);
8806 XSync(xDisplay, False);
8808 usleep(time * 1000);
8813 /* Convert board position to corner of screen rect and color */
8816 ScreenSquare(column, row, pt, color)
8817 int column; int row; XPoint * pt; int * color;
8820 pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
8821 pt->y = lineGap + row * (squareSize + lineGap);
8823 pt->x = lineGap + column * (squareSize + lineGap);
8824 pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
8826 *color = SquareColor(row, column);
8829 /* Convert window coords to square */
8832 BoardSquare(x, y, column, row)
8833 int x; int y; int * column; int * row;
8835 *column = EventToSquare(x, BOARD_WIDTH);
8836 if (flipView && *column >= 0)
8837 *column = BOARD_WIDTH - 1 - *column;
8838 *row = EventToSquare(y, BOARD_HEIGHT);
8839 if (!flipView && *row >= 0)
8840 *row = BOARD_HEIGHT - 1 - *row;
8845 #undef Max /* just in case */
8847 #define Max(a, b) ((a) > (b) ? (a) : (b))
8848 #define Min(a, b) ((a) < (b) ? (a) : (b))
8851 SetRect(rect, x, y, width, height)
8852 XRectangle * rect; int x; int y; int width; int height;
8856 rect->width = width;
8857 rect->height = height;
8860 /* Test if two frames overlap. If they do, return
8861 intersection rect within old and location of
8862 that rect within new. */
8865 Intersect(old, new, size, area, pt)
8866 XPoint * old; XPoint * new;
8867 int size; XRectangle * area; XPoint * pt;
8869 if (old->x > new->x + size || new->x > old->x + size ||
8870 old->y > new->y + size || new->y > old->y + size) {
8873 SetRect(area, Max(new->x - old->x, 0), Max(new->y - old->y, 0),
8874 size - abs(old->x - new->x), size - abs(old->y - new->y));
8875 pt->x = Max(old->x - new->x, 0);
8876 pt->y = Max(old->y - new->y, 0);
8881 /* For two overlapping frames, return the rect(s)
8882 in the old that do not intersect with the new. */
8885 CalcUpdateRects(old, new, size, update, nUpdates)
8886 XPoint * old; XPoint * new; int size;
8887 XRectangle update[]; int * nUpdates;
8891 /* If old = new (shouldn't happen) then nothing to draw */
8892 if (old->x == new->x && old->y == new->y) {
8896 /* Work out what bits overlap. Since we know the rects
8897 are the same size we don't need a full intersect calc. */
8899 /* Top or bottom edge? */
8900 if (new->y > old->y) {
8901 SetRect(&(update[count]), old->x, old->y, size, new->y - old->y);
8903 } else if (old->y > new->y) {
8904 SetRect(&(update[count]), old->x, old->y + size - (old->y - new->y),
8905 size, old->y - new->y);
8908 /* Left or right edge - don't overlap any update calculated above. */
8909 if (new->x > old->x) {
8910 SetRect(&(update[count]), old->x, Max(new->y, old->y),
8911 new->x - old->x, size - abs(new->y - old->y));
8913 } else if (old->x > new->x) {
8914 SetRect(&(update[count]), new->x + size, Max(new->y, old->y),
8915 old->x - new->x, size - abs(new->y - old->y));
8922 /* Generate a series of frame coords from start->mid->finish.
8923 The movement rate doubles until the half way point is
8924 reached, then halves back down to the final destination,
8925 which gives a nice slow in/out effect. The algorithmn
8926 may seem to generate too many intermediates for short
8927 moves, but remember that the purpose is to attract the
8928 viewers attention to the piece about to be moved and
8929 then to where it ends up. Too few frames would be less
8933 Tween(start, mid, finish, factor, frames, nFrames)
8934 XPoint * start; XPoint * mid;
8935 XPoint * finish; int factor;
8936 XPoint frames[]; int * nFrames;
8938 int fraction, n, count;
8942 /* Slow in, stepping 1/16th, then 1/8th, ... */
8944 for (n = 0; n < factor; n++)
8946 for (n = 0; n < factor; n++) {
8947 frames[count].x = start->x + (mid->x - start->x) / fraction;
8948 frames[count].y = start->y + (mid->y - start->y) / fraction;
8950 fraction = fraction / 2;
8954 frames[count] = *mid;
8957 /* Slow out, stepping 1/2, then 1/4, ... */
8959 for (n = 0; n < factor; n++) {
8960 frames[count].x = finish->x - (finish->x - mid->x) / fraction;
8961 frames[count].y = finish->y - (finish->y - mid->y) / fraction;
8963 fraction = fraction * 2;
8968 /* Draw a piece on the screen without disturbing what's there */
8971 SelectGCMask(piece, clip, outline, mask)
8972 ChessSquare piece; GC * clip; GC * outline; Pixmap * mask;
8976 /* Bitmap for piece being moved. */
8977 if (appData.monoMode) {
8978 *mask = *pieceToSolid(piece);
8979 } else if (useImages) {
8981 *mask = xpmMask[piece];
8983 *mask = ximMaskPm[piece];
8986 *mask = *pieceToSolid(piece);
8989 /* GC for piece being moved. Square color doesn't matter, but
8990 since it gets modified we make a copy of the original. */
8992 if (appData.monoMode)
8997 if (appData.monoMode)
9002 XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
9004 /* Outline only used in mono mode and is not modified */
9006 *outline = bwPieceGC;
9008 *outline = wbPieceGC;
9012 OverlayPiece(piece, clip, outline, dest)
9013 ChessSquare piece; GC clip; GC outline; Drawable dest;
9018 /* Draw solid rectangle which will be clipped to shape of piece */
9019 XFillRectangle(xDisplay, dest, clip,
9020 0, 0, squareSize, squareSize);
9021 if (appData.monoMode)
9022 /* Also draw outline in contrasting color for black
9023 on black / white on white cases */
9024 XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
9025 0, 0, squareSize, squareSize, 0, 0, 1);
9027 /* Copy the piece */
9032 XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
9034 0, 0, squareSize, squareSize,
9039 /* Animate the movement of a single piece */
9042 BeginAnimation(anim, piece, startColor, start)
9050 /* The old buffer is initialised with the start square (empty) */
9051 BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
9052 anim->prevFrame = *start;
9054 /* The piece will be drawn using its own bitmap as a matte */
9055 SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
9056 XSetClipMask(xDisplay, anim->pieceGC, mask);
9060 AnimationFrame(anim, frame, piece)
9065 XRectangle updates[4];
9070 /* Save what we are about to draw into the new buffer */
9071 XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
9072 frame->x, frame->y, squareSize, squareSize,
9075 /* Erase bits of the previous frame */
9076 if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
9077 /* Where the new frame overlapped the previous,
9078 the contents in newBuf are wrong. */
9079 XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
9080 overlap.x, overlap.y,
9081 overlap.width, overlap.height,
9083 /* Repaint the areas in the old that don't overlap new */
9084 CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);
9085 for (i = 0; i < count; i++)
9086 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9087 updates[i].x - anim->prevFrame.x,
9088 updates[i].y - anim->prevFrame.y,
9089 updates[i].width, updates[i].height,
9090 updates[i].x, updates[i].y);
9092 /* Easy when no overlap */
9093 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9094 0, 0, squareSize, squareSize,
9095 anim->prevFrame.x, anim->prevFrame.y);
9098 /* Save this frame for next time round */
9099 XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
9100 0, 0, squareSize, squareSize,
9102 anim->prevFrame = *frame;
9104 /* Draw piece over original screen contents, not current,
9105 and copy entire rect. Wipes out overlapping piece images. */
9106 OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);
9107 XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
9108 0, 0, squareSize, squareSize,
9109 frame->x, frame->y);
9113 EndAnimation (anim, finish)
9117 XRectangle updates[4];
9122 /* The main code will redraw the final square, so we
9123 only need to erase the bits that don't overlap. */
9124 if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {
9125 CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);
9126 for (i = 0; i < count; i++)
9127 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9128 updates[i].x - anim->prevFrame.x,
9129 updates[i].y - anim->prevFrame.y,
9130 updates[i].width, updates[i].height,
9131 updates[i].x, updates[i].y);
9133 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9134 0, 0, squareSize, squareSize,
9135 anim->prevFrame.x, anim->prevFrame.y);
9140 FrameSequence(anim, piece, startColor, start, finish, frames, nFrames)
9142 ChessSquare piece; int startColor;
9143 XPoint * start; XPoint * finish;
9144 XPoint frames[]; int nFrames;
9148 BeginAnimation(anim, piece, startColor, start);
9149 for (n = 0; n < nFrames; n++) {
9150 AnimationFrame(anim, &(frames[n]), piece);
9151 FrameDelay(appData.animSpeed);
9153 EndAnimation(anim, finish);
9156 /* Main control logic for deciding what to animate and how */
9159 AnimateMove(board, fromX, fromY, toX, toY)
9168 XPoint start, finish, mid;
9169 XPoint frames[kFactor * 2 + 1];
9170 int nFrames, startColor, endColor;
9172 /* Are we animating? */
9173 if (!appData.animate || appData.blindfold)
9176 if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
9177 board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
9178 return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
9180 if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
9181 piece = board[fromY][fromX];
9182 if (piece >= EmptySquare) return;
9187 hop = (piece == WhiteKnight || piece == BlackKnight);
9190 if (appData.debugMode) {
9191 fprintf(debugFP, hop ? _("AnimateMove: piece %d hops from %d,%d to %d,%d \n") :
9192 _("AnimateMove: piece %d slides from %d,%d to %d,%d \n"),
9193 piece, fromX, fromY, toX, toY); }
9195 ScreenSquare(fromX, fromY, &start, &startColor);
9196 ScreenSquare(toX, toY, &finish, &endColor);
9199 /* Knight: make diagonal movement then straight */
9200 if (abs(toY - fromY) < abs(toX - fromX)) {
9201 mid.x = start.x + (finish.x - start.x) / 2;
9205 mid.y = start.y + (finish.y - start.y) / 2;
9208 mid.x = start.x + (finish.x - start.x) / 2;
9209 mid.y = start.y + (finish.y - start.y) / 2;
9212 /* Don't use as many frames for very short moves */
9213 if (abs(toY - fromY) + abs(toX - fromX) <= 2)
9214 Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
9216 Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
9217 FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
9219 /* Be sure end square is redrawn */
9220 damage[toY][toX] = True;
9224 DragPieceBegin(x, y)
9227 int boardX, boardY, color;
9230 /* Are we animating? */
9231 if (!appData.animateDragging || appData.blindfold)
9234 /* Figure out which square we start in and the
9235 mouse position relative to top left corner. */
9236 BoardSquare(x, y, &boardX, &boardY);
9237 player.startBoardX = boardX;
9238 player.startBoardY = boardY;
9239 ScreenSquare(boardX, boardY, &corner, &color);
9240 player.startSquare = corner;
9241 player.startColor = color;
9242 /* As soon as we start dragging, the piece will jump slightly to
9243 be centered over the mouse pointer. */
9244 player.mouseDelta.x = squareSize/2;
9245 player.mouseDelta.y = squareSize/2;
9246 /* Initialise animation */
9247 player.dragPiece = PieceForSquare(boardX, boardY);
9249 if (player.dragPiece >= 0 && player.dragPiece < EmptySquare) {
9250 player.dragActive = True;
9251 BeginAnimation(&player, player.dragPiece, color, &corner);
9252 /* Mark this square as needing to be redrawn. Note that
9253 we don't remove the piece though, since logically (ie
9254 as seen by opponent) the move hasn't been made yet. */
9255 if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
9256 boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
9257 XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
9258 corner.x, corner.y, squareSize, squareSize,
9259 0, 0); // [HGM] zh: unstack in stead of grab
9260 damage[boardY][boardX] = True;
9262 player.dragActive = False;
9272 /* Are we animating? */
9273 if (!appData.animateDragging || appData.blindfold)
9277 if (! player.dragActive)
9279 /* Move piece, maintaining same relative position
9280 of mouse within square */
9281 corner.x = x - player.mouseDelta.x;
9282 corner.y = y - player.mouseDelta.y;
9283 AnimationFrame(&player, &corner, player.dragPiece);
9285 if (appData.highlightDragging) {
9287 BoardSquare(x, y, &boardX, &boardY);
9288 SetHighlights(fromX, fromY, boardX, boardY);
9297 int boardX, boardY, color;
9300 /* Are we animating? */
9301 if (!appData.animateDragging || appData.blindfold)
9305 if (! player.dragActive)
9307 /* Last frame in sequence is square piece is
9308 placed on, which may not match mouse exactly. */
9309 BoardSquare(x, y, &boardX, &boardY);
9310 ScreenSquare(boardX, boardY, &corner, &color);
9311 EndAnimation(&player, &corner);
9313 /* Be sure end square is redrawn */
9314 damage[boardY][boardX] = True;
9316 /* This prevents weird things happening with fast successive
9317 clicks which on my Sun at least can cause motion events
9318 without corresponding press/release. */
9319 player.dragActive = False;
9322 /* Handle expose event while piece being dragged */
9327 if (!player.dragActive || appData.blindfold)
9330 /* What we're doing: logically, the move hasn't been made yet,
9331 so the piece is still in it's original square. But visually
9332 it's being dragged around the board. So we erase the square
9333 that the piece is on and draw it at the last known drag point. */
9334 BlankSquare(player.startSquare.x, player.startSquare.y,
9335 player.startColor, EmptySquare, xBoardWindow);
9336 AnimationFrame(&player, &player.prevFrame, player.dragPiece);
9337 damage[player.startBoardY][player.startBoardX] = TRUE;
9341 SetProgramStats( FrontEndProgramStats * stats )
9344 // [HGM] done, but perhaps backend should call this directly?
9345 EngineOutputUpdate( stats );
9348 #include <sys/ioctl.h>
9349 int get_term_width()
9351 int fd, default_width;
9354 default_width = 79; // this is FICS default anyway...
9356 #if !defined(TIOCGWINSZ) && defined(TIOCGSIZE)
9358 if (!ioctl(fd, TIOCGSIZE, &win))
9359 default_width = win.ts_cols;
9360 #elif defined(TIOCGWINSZ)
9362 if (!ioctl(fd, TIOCGWINSZ, &win))
9363 default_width = win.ws_col;
9365 return default_width;
9368 void update_ics_width()
9370 static int old_width = 0;
9371 int new_width = get_term_width();
9373 if (old_width != new_width)
9374 ics_printf("set width %d\n", new_width);
9375 old_width = new_width;
9378 void NotifyFrontendLogin()