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_RANKS + BOARD_FILES + 2];
471 XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
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_FILES ||
2515 appData.NrRanks > BOARD_RANKS )
2516 DisplayFatalError(_("Recompile with larger BOARD_RANKS or BOARD_FILES 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_RANKS][BOARD_FILES];
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 || *target == XA_UTF8_STRING(xDisplay)){
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=*target;
6274 *format_return = 8; /* bits per byte */
6276 } else if (*target == XA_TARGETS(xDisplay)) {
6277 Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
6278 targets_tmp[0] = XA_UTF8_STRING(xDisplay);
6279 targets_tmp[1] = XA_STRING;
6280 *value_return = targets_tmp;
6281 *type_return = XA_ATOM;
6283 *format_return = 8 * sizeof(Atom);
6284 if (*format_return > 32) {
6285 *length_return *= *format_return / 32;
6286 *format_return = 32;
6294 /* note: when called from menu all parameters are NULL, so no clue what the
6295 * Widget which was clicked on was, or what the click event was
6297 void CopyPositionProc(w, event, prms, nprms)
6304 * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
6305 * have a notion of a position that is selected but not copied.
6306 * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
6308 if (selected_fen_position) free(selected_fen_position);
6309 selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
6310 if (!selected_fen_position) return;
6311 XtOwnSelection(menuBarWidget, XA_PRIMARY,
6313 SendPositionSelection,
6314 NULL/* lose_ownership_proc */ ,
6315 NULL/* transfer_done_proc */);
6316 XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
6318 SendPositionSelection,
6319 NULL/* lose_ownership_proc */ ,
6320 NULL/* transfer_done_proc */);
6323 /* function called when the data to Paste is ready */
6325 PastePositionCB(Widget w, XtPointer client_data, Atom *selection,
6326 Atom *type, XtPointer value, unsigned long *len, int *format)
6329 if (value==NULL || *len==0) return; /* nothing had been selected to copy */
6330 fenstr[*len]='\0'; /* normally this string is terminated, but be safe */
6331 EditPositionPasteFEN(fenstr);
6335 /* called when Paste Position button is pressed,
6336 * all parameters will be NULL */
6337 void PastePositionProc(w, event, prms, nprms)
6343 XtGetSelectionValue(menuBarWidget,
6344 appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
6345 /* (XtSelectionCallbackProc) */ PastePositionCB,
6346 NULL, /* client_data passed to PastePositionCB */
6348 /* better to use the time field from the event that triggered the
6349 * call to this function, but that isn't trivial to get
6357 SendGameSelection(Widget w, Atom *selection, Atom *target,
6358 Atom *type_return, XtPointer *value_return,
6359 unsigned long *length_return, int *format_return)
6361 char *selection_tmp;
6363 if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
6364 FILE* f = fopen(gameCopyFilename, "r");
6367 if (f == NULL) return False;
6371 selection_tmp = XtMalloc(len + 1);
6372 count = fread(selection_tmp, 1, len, f);
6374 XtFree(selection_tmp);
6377 selection_tmp[len] = NULLCHAR;
6378 *value_return = selection_tmp;
6379 *length_return = len;
6380 *type_return = *target;
6381 *format_return = 8; /* bits per byte */
6383 } else if (*target == XA_TARGETS(xDisplay)) {
6384 Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
6385 targets_tmp[0] = XA_UTF8_STRING(xDisplay);
6386 targets_tmp[1] = XA_STRING;
6387 *value_return = targets_tmp;
6388 *type_return = XA_ATOM;
6390 *format_return = 8 * sizeof(Atom);
6391 if (*format_return > 32) {
6392 *length_return *= *format_return / 32;
6393 *format_return = 32;
6401 /* note: when called from menu all parameters are NULL, so no clue what the
6402 * Widget which was clicked on was, or what the click event was
6404 void CopyGameProc(w, event, prms, nprms)
6412 ret = SaveGameToFile(gameCopyFilename, FALSE);
6416 * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
6417 * have a notion of a game that is selected but not copied.
6418 * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
6420 XtOwnSelection(menuBarWidget, XA_PRIMARY,
6423 NULL/* lose_ownership_proc */ ,
6424 NULL/* transfer_done_proc */);
6425 XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
6428 NULL/* lose_ownership_proc */ ,
6429 NULL/* transfer_done_proc */);
6432 /* function called when the data to Paste is ready */
6434 PasteGameCB(Widget w, XtPointer client_data, Atom *selection,
6435 Atom *type, XtPointer value, unsigned long *len, int *format)
6438 if (value == NULL || *len == 0) {
6439 return; /* nothing had been selected to copy */
6441 f = fopen(gamePasteFilename, "w");
6443 DisplayError(_("Can't open temp file"), errno);
6446 fwrite(value, 1, *len, f);
6449 LoadGameFromFile(gamePasteFilename, 0, gamePasteFilename, TRUE);
6452 /* called when Paste Game button is pressed,
6453 * all parameters will be NULL */
6454 void PasteGameProc(w, event, prms, nprms)
6460 XtGetSelectionValue(menuBarWidget,
6461 appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
6462 /* (XtSelectionCallbackProc) */ PasteGameCB,
6463 NULL, /* client_data passed to PasteGameCB */
6465 /* better to use the time field from the event that triggered the
6466 * call to this function, but that isn't trivial to get
6476 SaveGameProc(NULL, NULL, NULL, NULL);
6480 void QuitProc(w, event, prms, nprms)
6489 void PauseProc(w, event, prms, nprms)
6499 void MachineBlackProc(w, event, prms, nprms)
6505 MachineBlackEvent();
6508 void MachineWhiteProc(w, event, prms, nprms)
6514 MachineWhiteEvent();
6517 void AnalyzeModeProc(w, event, prms, nprms)
6525 if (!first.analysisSupport) {
6526 snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
6527 DisplayError(buf, 0);
6530 /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
6531 if (appData.icsActive) {
6532 if (gameMode != IcsObserving) {
6533 sprintf(buf,_("You are not observing a game"));
6534 DisplayError(buf, 0);
6536 if (appData.icsEngineAnalyze) {
6537 if (appData.debugMode)
6538 fprintf(debugFP, _("Found unexpected active ICS engine analyze \n"));
6544 /* if enable, use want disable icsEngineAnalyze */
6545 if (appData.icsEngineAnalyze) {
6550 appData.icsEngineAnalyze = TRUE;
6551 if (appData.debugMode)
6552 fprintf(debugFP, _("ICS engine analyze starting... \n"));
6554 if (!appData.showThinking)
6555 ShowThinkingProc(w,event,prms,nprms);
6560 void AnalyzeFileProc(w, event, prms, nprms)
6566 if (!first.analysisSupport) {
6568 snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
6569 DisplayError(buf, 0);
6574 if (!appData.showThinking)
6575 ShowThinkingProc(w,event,prms,nprms);
6578 FileNamePopUp(_("File to analyze"), "", LoadGamePopUp, "rb");
6579 AnalysisPeriodicEvent(1);
6582 void TwoMachinesProc(w, event, prms, nprms)
6591 void IcsClientProc(w, event, prms, nprms)
6600 void EditGameProc(w, event, prms, nprms)
6609 void EditPositionProc(w, event, prms, nprms)
6615 EditPositionEvent();
6618 void TrainingProc(w, event, prms, nprms)
6627 void EditCommentProc(w, event, prms, nprms)
6634 EditCommentPopDown();
6640 void IcsInputBoxProc(w, event, prms, nprms)
6646 if (ICSInputBoxUp) {
6647 ICSInputBoxPopDown();
6653 void AcceptProc(w, event, prms, nprms)
6662 void DeclineProc(w, event, prms, nprms)
6671 void RematchProc(w, event, prms, nprms)
6680 void CallFlagProc(w, event, prms, nprms)
6689 void DrawProc(w, event, prms, nprms)
6698 void AbortProc(w, event, prms, nprms)
6707 void AdjournProc(w, event, prms, nprms)
6716 void ResignProc(w, event, prms, nprms)
6725 void AdjuWhiteProc(w, event, prms, nprms)
6731 UserAdjudicationEvent(+1);
6734 void AdjuBlackProc(w, event, prms, nprms)
6740 UserAdjudicationEvent(-1);
6743 void AdjuDrawProc(w, event, prms, nprms)
6749 UserAdjudicationEvent(0);
6752 void EnterKeyProc(w, event, prms, nprms)
6758 if (ICSInputBoxUp == True)
6762 void StopObservingProc(w, event, prms, nprms)
6768 StopObservingEvent();
6771 void StopExaminingProc(w, event, prms, nprms)
6777 StopExaminingEvent();
6781 void ForwardProc(w, event, prms, nprms)
6791 void BackwardProc(w, event, prms, nprms)
6800 void ToStartProc(w, event, prms, nprms)
6809 void ToEndProc(w, event, prms, nprms)
6818 void RevertProc(w, event, prms, nprms)
6827 void TruncateGameProc(w, event, prms, nprms)
6833 TruncateGameEvent();
6835 void RetractMoveProc(w, event, prms, nprms)
6844 void MoveNowProc(w, event, prms, nprms)
6854 void AlwaysQueenProc(w, event, prms, nprms)
6862 appData.alwaysPromoteToQueen = !appData.alwaysPromoteToQueen;
6864 if (appData.alwaysPromoteToQueen) {
6865 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6867 XtSetArg(args[0], XtNleftBitmap, None);
6869 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
6873 void AnimateDraggingProc(w, event, prms, nprms)
6881 appData.animateDragging = !appData.animateDragging;
6883 if (appData.animateDragging) {
6884 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6887 XtSetArg(args[0], XtNleftBitmap, None);
6889 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Dragging"),
6893 void AnimateMovingProc(w, event, prms, nprms)
6901 appData.animate = !appData.animate;
6903 if (appData.animate) {
6904 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6907 XtSetArg(args[0], XtNleftBitmap, None);
6909 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
6913 void AutocommProc(w, event, prms, nprms)
6921 appData.autoComment = !appData.autoComment;
6923 if (appData.autoComment) {
6924 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6926 XtSetArg(args[0], XtNleftBitmap, None);
6928 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
6933 void AutoflagProc(w, event, prms, nprms)
6941 appData.autoCallFlag = !appData.autoCallFlag;
6943 if (appData.autoCallFlag) {
6944 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6946 XtSetArg(args[0], XtNleftBitmap, None);
6948 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
6952 void AutoflipProc(w, event, prms, nprms)
6960 appData.autoFlipView = !appData.autoFlipView;
6962 if (appData.autoFlipView) {
6963 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6965 XtSetArg(args[0], XtNleftBitmap, None);
6967 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flip View"),
6971 void AutobsProc(w, event, prms, nprms)
6979 appData.autoObserve = !appData.autoObserve;
6981 if (appData.autoObserve) {
6982 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
6984 XtSetArg(args[0], XtNleftBitmap, None);
6986 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
6990 void AutoraiseProc(w, event, prms, nprms)
6998 appData.autoRaiseBoard = !appData.autoRaiseBoard;
7000 if (appData.autoRaiseBoard) {
7001 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7003 XtSetArg(args[0], XtNleftBitmap, None);
7005 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Raise Board"),
7009 void AutosaveProc(w, event, prms, nprms)
7017 appData.autoSaveGames = !appData.autoSaveGames;
7019 if (appData.autoSaveGames) {
7020 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7022 XtSetArg(args[0], XtNleftBitmap, None);
7024 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
7028 void BlindfoldProc(w, event, prms, nprms)
7036 appData.blindfold = !appData.blindfold;
7038 if (appData.blindfold) {
7039 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7041 XtSetArg(args[0], XtNleftBitmap, None);
7043 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Blindfold"),
7046 DrawPosition(True, NULL);
7049 void TestLegalityProc(w, event, prms, nprms)
7057 appData.testLegality = !appData.testLegality;
7059 if (appData.testLegality) {
7060 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7062 XtSetArg(args[0], XtNleftBitmap, None);
7064 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Test Legality"),
7069 void FlashMovesProc(w, event, prms, nprms)
7077 if (appData.flashCount == 0) {
7078 appData.flashCount = 3;
7080 appData.flashCount = -appData.flashCount;
7083 if (appData.flashCount > 0) {
7084 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7086 XtSetArg(args[0], XtNleftBitmap, None);
7088 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Flash Moves"),
7092 void FlipViewProc(w, event, prms, nprms)
7098 flipView = !flipView;
7099 DrawPosition(True, NULL);
7102 void GetMoveListProc(w, event, prms, nprms)
7110 appData.getMoveList = !appData.getMoveList;
7112 if (appData.getMoveList) {
7113 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7116 XtSetArg(args[0], XtNleftBitmap, None);
7118 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
7123 void HighlightDraggingProc(w, event, prms, nprms)
7131 appData.highlightDragging = !appData.highlightDragging;
7133 if (appData.highlightDragging) {
7134 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7136 XtSetArg(args[0], XtNleftBitmap, None);
7138 XtSetValues(XtNameToWidget(menuBarWidget,
7139 "menuOptions.Highlight Dragging"), args, 1);
7143 void HighlightLastMoveProc(w, event, prms, nprms)
7151 appData.highlightLastMove = !appData.highlightLastMove;
7153 if (appData.highlightLastMove) {
7154 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7156 XtSetArg(args[0], XtNleftBitmap, None);
7158 XtSetValues(XtNameToWidget(menuBarWidget,
7159 "menuOptions.Highlight Last Move"), args, 1);
7162 void IcsAlarmProc(w, event, prms, nprms)
7170 appData.icsAlarm = !appData.icsAlarm;
7172 if (appData.icsAlarm) {
7173 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7175 XtSetArg(args[0], XtNleftBitmap, None);
7177 XtSetValues(XtNameToWidget(menuBarWidget,
7178 "menuOptions.ICS Alarm"), args, 1);
7181 void MoveSoundProc(w, event, prms, nprms)
7189 appData.ringBellAfterMoves = !appData.ringBellAfterMoves;
7191 if (appData.ringBellAfterMoves) {
7192 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7194 XtSetArg(args[0], XtNleftBitmap, None);
7196 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
7201 void OldSaveStyleProc(w, event, prms, nprms)
7209 appData.oldSaveStyle = !appData.oldSaveStyle;
7211 if (appData.oldSaveStyle) {
7212 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7214 XtSetArg(args[0], XtNleftBitmap, None);
7216 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Old Save Style"),
7220 void PeriodicUpdatesProc(w, event, prms, nprms)
7228 PeriodicUpdatesEvent(!appData.periodicUpdates);
7230 if (appData.periodicUpdates) {
7231 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7233 XtSetArg(args[0], XtNleftBitmap, None);
7235 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Periodic Updates"),
7239 void PonderNextMoveProc(w, event, prms, nprms)
7247 PonderNextMoveEvent(!appData.ponderNextMove);
7249 if (appData.ponderNextMove) {
7250 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7252 XtSetArg(args[0], XtNleftBitmap, None);
7254 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Ponder Next Move"),
7258 void PopupExitMessageProc(w, event, prms, nprms)
7266 appData.popupExitMessage = !appData.popupExitMessage;
7268 if (appData.popupExitMessage) {
7269 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7271 XtSetArg(args[0], XtNleftBitmap, None);
7273 XtSetValues(XtNameToWidget(menuBarWidget,
7274 "menuOptions.Popup Exit Message"), args, 1);
7277 void PopupMoveErrorsProc(w, event, prms, nprms)
7285 appData.popupMoveErrors = !appData.popupMoveErrors;
7287 if (appData.popupMoveErrors) {
7288 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7290 XtSetArg(args[0], XtNleftBitmap, None);
7292 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Popup Move Errors"),
7296 void PremoveProc(w, event, prms, nprms)
7304 appData.premove = !appData.premove;
7306 if (appData.premove) {
7307 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7309 XtSetArg(args[0], XtNleftBitmap, None);
7311 XtSetValues(XtNameToWidget(menuBarWidget,
7312 "menuOptions.Premove"), args, 1);
7315 void QuietPlayProc(w, event, prms, nprms)
7323 appData.quietPlay = !appData.quietPlay;
7325 if (appData.quietPlay) {
7326 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7328 XtSetArg(args[0], XtNleftBitmap, None);
7330 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Quiet Play"),
7334 void ShowCoordsProc(w, event, prms, nprms)
7342 appData.showCoords = !appData.showCoords;
7344 if (appData.showCoords) {
7345 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7347 XtSetArg(args[0], XtNleftBitmap, None);
7349 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
7352 DrawPosition(True, NULL);
7355 void ShowThinkingProc(w, event, prms, nprms)
7361 appData.showThinking = !appData.showThinking; // [HGM] thinking: tken out of ShowThinkingEvent
7362 ShowThinkingEvent();
7365 void HideThinkingProc(w, event, prms, nprms)
7373 appData.hideThinkingFromHuman = !appData.hideThinkingFromHuman; // [HGM] thinking: tken out of ShowThinkingEvent
7374 ShowThinkingEvent();
7376 if (appData.hideThinkingFromHuman) {
7377 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
7379 XtSetArg(args[0], XtNleftBitmap, None);
7381 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Hide Thinking"),
7385 void InfoProc(w, event, prms, nprms)
7392 snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
7397 void ManProc(w, event, prms, nprms)
7405 if (nprms && *nprms > 0)
7409 snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
7413 void HintProc(w, event, prms, nprms)
7422 void BookProc(w, event, prms, nprms)
7431 void AboutProc(w, event, prms, nprms)
7439 char *zippy = " (with Zippy code)";
7443 snprintf(buf, sizeof(buf), "%s%s\n\n%s\n%s\n%s\n\n%s%s\n%s",
7444 programVersion, zippy,
7445 "Copyright 1991 Digital Equipment Corporation",
7446 "Enhancements Copyright 1992-2009 Free Software Foundation",
7447 "Enhancements Copyright 2005 Alessandro Scotti",
7448 PACKAGE, " is free software and carries NO WARRANTY;",
7449 "see the file COPYING for more information.");
7450 ErrorPopUp(_("About XBoard"), buf, FALSE);
7453 void DebugProc(w, event, prms, nprms)
7459 appData.debugMode = !appData.debugMode;
7462 void AboutGameProc(w, event, prms, nprms)
7471 void NothingProc(w, event, prms, nprms)
7480 void Iconify(w, event, prms, nprms)
7489 XtSetArg(args[0], XtNiconic, True);
7490 XtSetValues(shellWidget, args, 1);
7493 void DisplayMessage(message, extMessage)
7494 char *message, *extMessage;
7496 /* display a message in the message widget */
7505 snprintf(buf, sizeof(buf), "%s %s", message, extMessage);
7510 message = extMessage;
7514 /* need to test if messageWidget already exists, since this function
7515 can also be called during the startup, if for example a Xresource
7516 is not set up correctly */
7519 XtSetArg(arg, XtNlabel, message);
7520 XtSetValues(messageWidget, &arg, 1);
7526 void DisplayTitle(text)
7531 char title[MSG_SIZ];
7534 if (text == NULL) text = "";
7536 if (appData.titleInWindow) {
7538 XtSetArg(args[i], XtNlabel, text); i++;
7539 XtSetValues(titleWidget, args, i);
7542 if (*text != NULLCHAR) {
7544 strcpy(title, text);
7545 } else if (appData.icsActive) {
7546 snprintf(icon, sizeof(icon), "%s", appData.icsHost);
7547 snprintf(title, sizeof(title), "%s: %s", programName, appData.icsHost);
7548 } else if (appData.cmailGameName[0] != NULLCHAR) {
7549 snprintf(icon, sizeof(icon), "%s", "CMail");
7550 snprintf(title,sizeof(title), "%s: %s", programName, "CMail");
7552 // [HGM] license: This stuff should really be done in back-end, but WinBoard already had a pop-up for it
7553 } else if (gameInfo.variant == VariantGothic) {
7554 strcpy(icon, programName);
7555 strcpy(title, GOTHIC);
7558 } else if (gameInfo.variant == VariantFalcon) {
7559 strcpy(icon, programName);
7560 strcpy(title, FALCON);
7562 } else if (appData.noChessProgram) {
7563 strcpy(icon, programName);
7564 strcpy(title, programName);
7566 strcpy(icon, first.tidy);
7567 snprintf(title,sizeof(title), "%s: %s", programName, first.tidy);
7570 XtSetArg(args[i], XtNiconName, (XtArgVal) icon); i++;
7571 XtSetArg(args[i], XtNtitle, (XtArgVal) title); i++;
7572 XtSetValues(shellWidget, args, i);
7576 void DisplayError(message, error)
7583 if (appData.debugMode || appData.matchMode) {
7584 fprintf(stderr, "%s: %s\n", programName, message);
7587 if (appData.debugMode || appData.matchMode) {
7588 fprintf(stderr, "%s: %s: %s\n",
7589 programName, message, strerror(error));
7591 snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
7594 ErrorPopUp(_("Error"), message, FALSE);
7598 void DisplayMoveError(message)
7603 DrawPosition(FALSE, NULL);
7604 if (appData.debugMode || appData.matchMode) {
7605 fprintf(stderr, "%s: %s\n", programName, message);
7607 if (appData.popupMoveErrors) {
7608 ErrorPopUp(_("Error"), message, FALSE);
7610 DisplayMessage(message, "");
7615 void DisplayFatalError(message, error, status)
7621 errorExitStatus = status;
7623 fprintf(stderr, "%s: %s\n", programName, message);
7625 fprintf(stderr, "%s: %s: %s\n",
7626 programName, message, strerror(error));
7627 snprintf(buf, sizeof(buf), "%s: %s", message, strerror(error));
7630 if (appData.popupExitMessage && boardWidget && XtIsRealized(boardWidget)) {
7631 ErrorPopUp(status ? _("Fatal Error") : _("Exiting"), message, TRUE);
7637 void DisplayInformation(message)
7641 ErrorPopUp(_("Information"), message, TRUE);
7644 void DisplayNote(message)
7648 ErrorPopUp(_("Note"), message, FALSE);
7652 NullXErrorCheck(dpy, error_event)
7654 XErrorEvent *error_event;
7659 void DisplayIcsInteractionTitle(message)
7662 if (oldICSInteractionTitle == NULL) {
7663 /* Magic to find the old window title, adapted from vim */
7664 char *wina = getenv("WINDOWID");
7666 Window win = (Window) atoi(wina);
7667 Window root, parent, *children;
7668 unsigned int nchildren;
7669 int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
7671 if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
7672 if (!XQueryTree(xDisplay, win, &root, &parent,
7673 &children, &nchildren)) break;
7674 if (children) XFree((void *)children);
7675 if (parent == root || parent == 0) break;
7678 XSetErrorHandler(oldHandler);
7680 if (oldICSInteractionTitle == NULL) {
7681 oldICSInteractionTitle = "xterm";
7684 printf("\033]0;%s\007", message);
7688 char pendingReplyPrefix[MSG_SIZ];
7689 ProcRef pendingReplyPR;
7691 void AskQuestionProc(w, event, prms, nprms)
7698 fprintf(stderr, _("AskQuestionProc needed 4 parameters, got %d\n"),
7702 AskQuestionEvent(prms[0], prms[1], prms[2], prms[3]);
7705 void AskQuestionPopDown()
7707 if (!askQuestionUp) return;
7708 XtPopdown(askQuestionShell);
7709 XtDestroyWidget(askQuestionShell);
7710 askQuestionUp = False;
7713 void AskQuestionReplyAction(w, event, prms, nprms)
7723 reply = XawDialogGetValueString(w = XtParent(w));
7724 strcpy(buf, pendingReplyPrefix);
7725 if (*buf) strcat(buf, " ");
7728 OutputToProcess(pendingReplyPR, buf, strlen(buf), &err);
7729 AskQuestionPopDown();
7731 if (err) DisplayFatalError(_("Error writing to chess program"), err, 0);
7734 void AskQuestionCallback(w, client_data, call_data)
7736 XtPointer client_data, call_data;
7741 XtSetArg(args[0], XtNlabel, &name);
7742 XtGetValues(w, args, 1);
7744 if (strcmp(name, _("cancel")) == 0) {
7745 AskQuestionPopDown();
7747 AskQuestionReplyAction(w, NULL, NULL, NULL);
7751 void AskQuestion(title, question, replyPrefix, pr)
7752 char *title, *question, *replyPrefix;
7756 Widget popup, layout, dialog, edit;
7762 strcpy(pendingReplyPrefix, replyPrefix);
7763 pendingReplyPR = pr;
7766 XtSetArg(args[i], XtNresizable, True); i++;
7767 XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
7768 askQuestionShell = popup =
7769 XtCreatePopupShell(title, transientShellWidgetClass,
7770 shellWidget, args, i);
7773 XtCreateManagedWidget(layoutName, formWidgetClass, popup,
7774 layoutArgs, XtNumber(layoutArgs));
7777 XtSetArg(args[i], XtNlabel, question); i++;
7778 XtSetArg(args[i], XtNvalue, ""); i++;
7779 XtSetArg(args[i], XtNborderWidth, 0); i++;
7780 dialog = XtCreateManagedWidget("question", dialogWidgetClass,
7783 XawDialogAddButton(dialog, _("enter"), AskQuestionCallback,
7784 (XtPointer) dialog);
7785 XawDialogAddButton(dialog, _("cancel"), AskQuestionCallback,
7786 (XtPointer) dialog);
7788 XtRealizeWidget(popup);
7789 CatchDeleteWindow(popup, "AskQuestionPopDown");
7791 XQueryPointer(xDisplay, xBoardWindow, &root, &child,
7792 &x, &y, &win_x, &win_y, &mask);
7794 XtSetArg(args[0], XtNx, x - 10);
7795 XtSetArg(args[1], XtNy, y - 30);
7796 XtSetValues(popup, args, 2);
7798 XtPopup(popup, XtGrabExclusive);
7799 askQuestionUp = True;
7801 edit = XtNameToWidget(dialog, "*value");
7802 XtSetKeyboardFocus(popup, edit);
7810 if (*name == NULLCHAR) {
7812 } else if (strcmp(name, "$") == 0) {
7813 putc(BELLCHAR, stderr);
7816 snprintf(buf, sizeof(buf), "%s '%s' &", appData.soundProgram, name);
7824 PlaySound(appData.soundMove);
7830 PlaySound(appData.soundIcsWin);
7836 PlaySound(appData.soundIcsLoss);
7842 PlaySound(appData.soundIcsDraw);
7846 PlayIcsUnfinishedSound()
7848 PlaySound(appData.soundIcsUnfinished);
7854 PlaySound(appData.soundIcsAlarm);
7860 system("stty echo");
7866 system("stty -echo");
7870 Colorize(cc, continuation)
7875 int count, outCount, error;
7877 if (textColors[(int)cc].bg > 0) {
7878 if (textColors[(int)cc].fg > 0) {
7879 sprintf(buf, "\033[0;%d;%d;%dm", textColors[(int)cc].attr,
7880 textColors[(int)cc].fg, textColors[(int)cc].bg);
7882 sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
7883 textColors[(int)cc].bg);
7886 if (textColors[(int)cc].fg > 0) {
7887 sprintf(buf, "\033[0;%d;%dm", textColors[(int)cc].attr,
7888 textColors[(int)cc].fg);
7890 sprintf(buf, "\033[0;%dm", textColors[(int)cc].attr);
7893 count = strlen(buf);
7894 outCount = OutputToProcess(NoProc, buf, count, &error);
7895 if (outCount < count) {
7896 DisplayFatalError(_("Error writing to display"), error, 1);
7899 if (continuation) return;
7902 PlaySound(appData.soundShout);
7905 PlaySound(appData.soundSShout);
7908 PlaySound(appData.soundChannel1);
7911 PlaySound(appData.soundChannel);
7914 PlaySound(appData.soundKibitz);
7917 PlaySound(appData.soundTell);
7919 case ColorChallenge:
7920 PlaySound(appData.soundChallenge);
7923 PlaySound(appData.soundRequest);
7926 PlaySound(appData.soundSeek);
7937 return getpwuid(getuid())->pw_name;
7940 static char *ExpandPathName(path)
7943 static char static_buf[2000];
7944 char *d, *s, buf[2000];
7950 while (*s && isspace(*s))
7959 if (*(s+1) == '/') {
7960 strcpy(d, getpwuid(getuid())->pw_dir);
7965 *strchr(buf, '/') = 0;
7966 pwd = getpwnam(buf);
7969 fprintf(stderr, _("ERROR: Unknown user %s (in path %s)\n"),
7973 strcpy(d, pwd->pw_dir);
7974 strcat(d, strchr(s+1, '/'));
7985 static char host_name[MSG_SIZ];
7987 #if HAVE_GETHOSTNAME
7988 gethostname(host_name, MSG_SIZ);
7990 #else /* not HAVE_GETHOSTNAME */
7991 # if HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H
7992 sysinfo(SI_HOSTNAME, host_name, MSG_SIZ);
7994 # else /* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */
7996 # endif/* not (HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H) */
7997 #endif /* not HAVE_GETHOSTNAME */
8000 XtIntervalId delayedEventTimerXID = 0;
8001 DelayedEventCallback delayedEventCallback = 0;
8006 delayedEventTimerXID = 0;
8007 delayedEventCallback();
8011 ScheduleDelayedEvent(cb, millisec)
8012 DelayedEventCallback cb; long millisec;
8014 if(delayedEventTimerXID && delayedEventCallback == cb)
8015 // [HGM] alive: replace, rather than add or flush identical event
8016 XtRemoveTimeOut(delayedEventTimerXID);
8017 delayedEventCallback = cb;
8018 delayedEventTimerXID =
8019 XtAppAddTimeOut(appContext, millisec,
8020 (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
8023 DelayedEventCallback
8026 if (delayedEventTimerXID) {
8027 return delayedEventCallback;
8034 CancelDelayedEvent()
8036 if (delayedEventTimerXID) {
8037 XtRemoveTimeOut(delayedEventTimerXID);
8038 delayedEventTimerXID = 0;
8042 XtIntervalId loadGameTimerXID = 0;
8044 int LoadGameTimerRunning()
8046 return loadGameTimerXID != 0;
8049 int StopLoadGameTimer()
8051 if (loadGameTimerXID != 0) {
8052 XtRemoveTimeOut(loadGameTimerXID);
8053 loadGameTimerXID = 0;
8061 LoadGameTimerCallback(arg, id)
8065 loadGameTimerXID = 0;
8070 StartLoadGameTimer(millisec)
8074 XtAppAddTimeOut(appContext, millisec,
8075 (XtTimerCallbackProc) LoadGameTimerCallback,
8079 XtIntervalId analysisClockXID = 0;
8082 AnalysisClockCallback(arg, id)
8086 if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
8087 || appData.icsEngineAnalyze) { // [DM]
8088 AnalysisPeriodicEvent(0);
8089 StartAnalysisClock();
8094 StartAnalysisClock()
8097 XtAppAddTimeOut(appContext, 2000,
8098 (XtTimerCallbackProc) AnalysisClockCallback,
8102 XtIntervalId clockTimerXID = 0;
8104 int ClockTimerRunning()
8106 return clockTimerXID != 0;
8109 int StopClockTimer()
8111 if (clockTimerXID != 0) {
8112 XtRemoveTimeOut(clockTimerXID);
8121 ClockTimerCallback(arg, id)
8130 StartClockTimer(millisec)
8134 XtAppAddTimeOut(appContext, millisec,
8135 (XtTimerCallbackProc) ClockTimerCallback,
8140 DisplayTimerLabel(w, color, timer, highlight)
8149 /* check for low time warning */
8150 Pixel foregroundOrWarningColor = timerForegroundPixel;
8153 appData.lowTimeWarning &&
8154 (timer / 1000) < appData.icsAlarmTime)
8155 foregroundOrWarningColor = lowTimeWarningColor;
8157 if (appData.clockMode) {
8158 sprintf(buf, "%s: %s", color, TimeString(timer));
8159 XtSetArg(args[0], XtNlabel, buf);
8161 sprintf(buf, "%s ", color);
8162 XtSetArg(args[0], XtNlabel, buf);
8167 XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
8168 XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
8170 XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
8171 XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
8174 XtSetValues(w, args, 3);
8178 DisplayWhiteClock(timeRemaining, highlight)
8184 if(appData.noGUI) return;
8185 DisplayTimerLabel(whiteTimerWidget, _("White"), timeRemaining, highlight);
8186 if (highlight && iconPixmap == bIconPixmap) {
8187 iconPixmap = wIconPixmap;
8188 XtSetArg(args[0], XtNiconPixmap, iconPixmap);
8189 XtSetValues(shellWidget, args, 1);
8194 DisplayBlackClock(timeRemaining, highlight)
8200 if(appData.noGUI) return;
8201 DisplayTimerLabel(blackTimerWidget, _("Black"), timeRemaining, highlight);
8202 if (highlight && iconPixmap == wIconPixmap) {
8203 iconPixmap = bIconPixmap;
8204 XtSetArg(args[0], XtNiconPixmap, iconPixmap);
8205 XtSetValues(shellWidget, args, 1);
8223 int StartChildProcess(cmdLine, dir, pr)
8230 int to_prog[2], from_prog[2];
8234 if (appData.debugMode) {
8235 fprintf(stderr, "StartChildProcess (dir=\"%s\") %s\n",dir, cmdLine);
8238 /* We do NOT feed the cmdLine to the shell; we just
8239 parse it into blank-separated arguments in the
8240 most simple-minded way possible.
8243 strcpy(buf, cmdLine);
8248 if (p == NULL) break;
8253 SetUpChildIO(to_prog, from_prog);
8255 if ((pid = fork()) == 0) {
8257 // [HGM] PSWBTM: made order resistant against case where fd of created pipe was 0 or 1
8258 close(to_prog[1]); // first close the unused pipe ends
8259 close(from_prog[0]);
8260 dup2(to_prog[0], 0); // to_prog was created first, nd is the only one to use 0 or 1
8261 dup2(from_prog[1], 1);
8262 if(to_prog[0] >= 2) close(to_prog[0]); // if 0 or 1, the dup2 already cosed the original
8263 close(from_prog[1]); // and closing again loses one of the pipes!
8264 if(fileno(stderr) >= 2) // better safe than sorry...
8265 dup2(1, fileno(stderr)); /* force stderr to the pipe */
8267 if (dir[0] != NULLCHAR && chdir(dir) != 0) {
8272 nice(appData.niceEngines); // [HGM] nice: adjust priority of engine proc
8274 execvp(argv[0], argv);
8276 /* If we get here, exec failed */
8281 /* Parent process */
8283 close(from_prog[1]);
8285 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8288 cp->fdFrom = from_prog[0];
8289 cp->fdTo = to_prog[1];
8294 // [HGM] kill: implement the 'hard killing' of AS's Winboard_x
8295 static RETSIGTYPE AlarmCallBack(int n)
8301 DestroyChildProcess(pr, signalType)
8305 ChildProc *cp = (ChildProc *) pr;
8307 if (cp->kind != CPReal) return;
8309 if (signalType == 10) { // [HGM] kill: if it does not terminate in 3 sec, kill
8310 signal(SIGALRM, AlarmCallBack);
8312 if(wait((int *) 0) == -1) { // process does not terminate on its own accord
8313 kill(cp->pid, SIGKILL); // kill it forcefully
8314 wait((int *) 0); // and wait again
8318 kill(cp->pid, signalType == 9 ? SIGKILL : SIGTERM); // [HGM] kill: use hard kill if so requested
8320 /* Process is exiting either because of the kill or because of
8321 a quit command sent by the backend; either way, wait for it to die.
8330 InterruptChildProcess(pr)
8333 ChildProc *cp = (ChildProc *) pr;
8335 if (cp->kind != CPReal) return;
8336 (void) kill(cp->pid, SIGINT); /* stop it thinking */
8339 int OpenTelnet(host, port, pr)
8344 char cmdLine[MSG_SIZ];
8346 if (port[0] == NULLCHAR) {
8347 snprintf(cmdLine, sizeof(cmdLine), "%s %s", appData.telnetProgram, host);
8349 snprintf(cmdLine, sizeof(cmdLine), "%s %s %s", appData.telnetProgram, host, port);
8351 return StartChildProcess(cmdLine, "", pr);
8354 int OpenTCP(host, port, pr)
8360 DisplayFatalError(_("Socket support is not configured in"), 0, 2);
8361 #else /* !OMIT_SOCKETS */
8363 struct sockaddr_in sa;
8365 unsigned short uport;
8368 if ((s = socket(AF_INET, SOCK_STREAM, 6)) < 0) {
8372 memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));
8373 sa.sin_family = AF_INET;
8374 sa.sin_addr.s_addr = INADDR_ANY;
8375 uport = (unsigned short) 0;
8376 sa.sin_port = htons(uport);
8377 if (bind(s, (struct sockaddr *) &sa, sizeof(struct sockaddr_in)) < 0) {
8381 memset((char *) &sa, (int)0, sizeof(struct sockaddr_in));
8382 if (!(hp = gethostbyname(host))) {
8384 if (sscanf(host, "%d.%d.%d.%d", &b0, &b1, &b2, &b3) == 4) {
8385 hp = (struct hostent *) calloc(1, sizeof(struct hostent));
8386 hp->h_addrtype = AF_INET;
8388 hp->h_addr_list = (char **) calloc(2, sizeof(char *));
8389 hp->h_addr_list[0] = (char *) malloc(4);
8390 hp->h_addr_list[0][0] = b0;
8391 hp->h_addr_list[0][1] = b1;
8392 hp->h_addr_list[0][2] = b2;
8393 hp->h_addr_list[0][3] = b3;
8398 sa.sin_family = hp->h_addrtype;
8399 uport = (unsigned short) atoi(port);
8400 sa.sin_port = htons(uport);
8401 memcpy((char *) &sa.sin_addr, hp->h_addr, hp->h_length);
8403 if (connect(s, (struct sockaddr *) &sa,
8404 sizeof(struct sockaddr_in)) < 0) {
8408 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8415 #endif /* !OMIT_SOCKETS */
8420 int OpenCommPort(name, pr)
8427 fd = open(name, 2, 0);
8428 if (fd < 0) return errno;
8430 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8440 int OpenLoopback(pr)
8446 SetUpChildIO(to, from);
8448 cp = (ChildProc *) calloc(1, sizeof(ChildProc));
8451 cp->fdFrom = to[0]; /* note not from[0]; we are doing a loopback */
8458 int OpenRcmd(host, user, cmd, pr)
8459 char *host, *user, *cmd;
8462 DisplayFatalError(_("internal rcmd not implemented for Unix"), 0, 1);
8466 #define INPUT_SOURCE_BUF_SIZE 8192
8475 char buf[INPUT_SOURCE_BUF_SIZE];
8480 DoInputCallback(closure, source, xid)
8485 InputSource *is = (InputSource *) closure;
8490 if (is->lineByLine) {
8491 count = read(is->fd, is->unused,
8492 INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
8494 (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
8497 is->unused += count;
8499 while (p < is->unused) {
8500 q = memchr(p, '\n', is->unused - p);
8501 if (q == NULL) break;
8503 (is->func)(is, is->closure, p, q - p, 0);
8507 while (p < is->unused) {
8512 count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
8517 (is->func)(is, is->closure, is->buf, count, error);
8521 InputSourceRef AddInputSource(pr, lineByLine, func, closure)
8528 ChildProc *cp = (ChildProc *) pr;
8530 is = (InputSource *) calloc(1, sizeof(InputSource));
8531 is->lineByLine = lineByLine;
8535 is->fd = fileno(stdin);
8537 is->kind = cp->kind;
8538 is->fd = cp->fdFrom;
8541 is->unused = is->buf;
8544 is->xid = XtAppAddInput(appContext, is->fd,
8545 (XtPointer) (XtInputReadMask),
8546 (XtInputCallbackProc) DoInputCallback,
8548 is->closure = closure;
8549 return (InputSourceRef) is;
8553 RemoveInputSource(isr)
8556 InputSource *is = (InputSource *) isr;
8558 if (is->xid == 0) return;
8559 XtRemoveInput(is->xid);
8563 int OutputToProcess(pr, message, count, outError)
8569 static int line = 0;
8570 ChildProc *cp = (ChildProc *) pr;
8575 if (appData.noJoin || !appData.useInternalWrap)
8576 outCount = fwrite(message, 1, count, stdout);
8579 int width = get_term_width();
8580 int len = wrap(NULL, message, count, width, &line);
8581 char *msg = malloc(len);
8585 outCount = fwrite(message, 1, count, stdout);
8588 dbgchk = wrap(msg, message, count, width, &line);
8589 if (dbgchk != len && appData.debugMode)
8590 fprintf(debugFP, "wrap(): dbgchk(%d) != len(%d)\n", dbgchk, len);
8591 outCount = fwrite(msg, 1, dbgchk, stdout);
8597 outCount = write(cp->fdTo, message, count);
8607 /* Output message to process, with "ms" milliseconds of delay
8608 between each character. This is needed when sending the logon
8609 script to ICC, which for some reason doesn't like the
8610 instantaneous send. */
8611 int OutputToProcessDelayed(pr, message, count, outError, msdelay)
8618 ChildProc *cp = (ChildProc *) pr;
8623 r = write(cp->fdTo, message++, 1);
8636 /**** Animation code by Hugh Fisher, DCS, ANU.
8638 Known problem: if a window overlapping the board is
8639 moved away while a piece is being animated underneath,
8640 the newly exposed area won't be updated properly.
8641 I can live with this.
8643 Known problem: if you look carefully at the animation
8644 of pieces in mono mode, they are being drawn as solid
8645 shapes without interior detail while moving. Fixing
8646 this would be a major complication for minimal return.
8649 /* Masks for XPM pieces. Black and white pieces can have
8650 different shapes, but in the interest of retaining my
8651 sanity pieces must have the same outline on both light
8652 and dark squares, and all pieces must use the same
8653 background square colors/images. */
8655 static int xpmDone = 0;
8658 CreateAnimMasks (pieceDepth)
8665 unsigned long plane;
8668 /* Need a bitmap just to get a GC with right depth */
8669 buf = XCreatePixmap(xDisplay, xBoardWindow,
8671 values.foreground = 1;
8672 values.background = 0;
8673 /* Don't use XtGetGC, not read only */
8674 maskGC = XCreateGC(xDisplay, buf,
8675 GCForeground | GCBackground, &values);
8676 XFreePixmap(xDisplay, buf);
8678 buf = XCreatePixmap(xDisplay, xBoardWindow,
8679 squareSize, squareSize, pieceDepth);
8680 values.foreground = XBlackPixel(xDisplay, xScreen);
8681 values.background = XWhitePixel(xDisplay, xScreen);
8682 bufGC = XCreateGC(xDisplay, buf,
8683 GCForeground | GCBackground, &values);
8685 for (piece = WhitePawn; piece <= BlackKing; piece++) {
8686 /* Begin with empty mask */
8687 if(!xpmDone) // [HGM] pieces: keep using existing
8688 xpmMask[piece] = XCreatePixmap(xDisplay, xBoardWindow,
8689 squareSize, squareSize, 1);
8690 XSetFunction(xDisplay, maskGC, GXclear);
8691 XFillRectangle(xDisplay, xpmMask[piece], maskGC,
8692 0, 0, squareSize, squareSize);
8694 /* Take a copy of the piece */
8699 XSetFunction(xDisplay, bufGC, GXcopy);
8700 XCopyArea(xDisplay, xpmPieceBitmap[kind][((int)piece) % (int)BlackPawn],
8702 0, 0, squareSize, squareSize, 0, 0);
8704 /* XOR the background (light) over the piece */
8705 XSetFunction(xDisplay, bufGC, GXxor);
8707 XCopyArea(xDisplay, xpmLightSquare, buf, bufGC,
8708 0, 0, squareSize, squareSize, 0, 0);
8710 XSetForeground(xDisplay, bufGC, lightSquareColor);
8711 XFillRectangle(xDisplay, buf, bufGC, 0, 0, squareSize, squareSize);
8714 /* We now have an inverted piece image with the background
8715 erased. Construct mask by just selecting all the non-zero
8716 pixels - no need to reconstruct the original image. */
8717 XSetFunction(xDisplay, maskGC, GXor);
8719 /* Might be quicker to download an XImage and create bitmap
8720 data from it rather than this N copies per piece, but it
8721 only takes a fraction of a second and there is a much
8722 longer delay for loading the pieces. */
8723 for (n = 0; n < pieceDepth; n ++) {
8724 XCopyPlane(xDisplay, buf, xpmMask[piece], maskGC,
8725 0, 0, squareSize, squareSize,
8731 XFreePixmap(xDisplay, buf);
8732 XFreeGC(xDisplay, bufGC);
8733 XFreeGC(xDisplay, maskGC);
8737 InitAnimState (anim, info)
8739 XWindowAttributes * info;
8744 /* Each buffer is square size, same depth as window */
8745 anim->saveBuf = XCreatePixmap(xDisplay, xBoardWindow,
8746 squareSize, squareSize, info->depth);
8747 anim->newBuf = XCreatePixmap(xDisplay, xBoardWindow,
8748 squareSize, squareSize, info->depth);
8750 /* Create a plain GC for blitting */
8751 mask = GCForeground | GCBackground | GCFunction |
8752 GCPlaneMask | GCGraphicsExposures;
8753 values.foreground = XBlackPixel(xDisplay, xScreen);
8754 values.background = XWhitePixel(xDisplay, xScreen);
8755 values.function = GXcopy;
8756 values.plane_mask = AllPlanes;
8757 values.graphics_exposures = False;
8758 anim->blitGC = XCreateGC(xDisplay, xBoardWindow, mask, &values);
8760 /* Piece will be copied from an existing context at
8761 the start of each new animation/drag. */
8762 anim->pieceGC = XCreateGC(xDisplay, xBoardWindow, 0, &values);
8764 /* Outline will be a read-only copy of an existing */
8765 anim->outlineGC = None;
8771 static VariantClass old = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
8772 XWindowAttributes info;
8774 if (xpmDone && gameInfo.variant == old) return;
8775 if(xpmDone) old = gameInfo.variant; // first time pieces might not be created yet
8776 XGetWindowAttributes(xDisplay, xBoardWindow, &info);
8778 InitAnimState(&game, &info);
8779 InitAnimState(&player, &info);
8781 /* For XPM pieces, we need bitmaps to use as masks. */
8783 CreateAnimMasks(info.depth);
8789 static Boolean frameWaiting;
8791 static RETSIGTYPE FrameAlarm (sig)
8794 frameWaiting = False;
8795 /* In case System-V style signals. Needed?? */
8796 signal(SIGALRM, FrameAlarm);
8803 struct itimerval delay;
8805 XSync(xDisplay, False);
8808 frameWaiting = True;
8809 signal(SIGALRM, FrameAlarm);
8810 delay.it_interval.tv_sec =
8811 delay.it_value.tv_sec = time / 1000;
8812 delay.it_interval.tv_usec =
8813 delay.it_value.tv_usec = (time % 1000) * 1000;
8814 setitimer(ITIMER_REAL, &delay, NULL);
8815 while (frameWaiting) pause();
8816 delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;
8817 delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;
8818 setitimer(ITIMER_REAL, &delay, NULL);
8828 XSync(xDisplay, False);
8830 usleep(time * 1000);
8835 /* Convert board position to corner of screen rect and color */
8838 ScreenSquare(column, row, pt, color)
8839 int column; int row; XPoint * pt; int * color;
8842 pt->x = lineGap + ((BOARD_WIDTH-1)-column) * (squareSize + lineGap);
8843 pt->y = lineGap + row * (squareSize + lineGap);
8845 pt->x = lineGap + column * (squareSize + lineGap);
8846 pt->y = lineGap + ((BOARD_HEIGHT-1)-row) * (squareSize + lineGap);
8848 *color = SquareColor(row, column);
8851 /* Convert window coords to square */
8854 BoardSquare(x, y, column, row)
8855 int x; int y; int * column; int * row;
8857 *column = EventToSquare(x, BOARD_WIDTH);
8858 if (flipView && *column >= 0)
8859 *column = BOARD_WIDTH - 1 - *column;
8860 *row = EventToSquare(y, BOARD_HEIGHT);
8861 if (!flipView && *row >= 0)
8862 *row = BOARD_HEIGHT - 1 - *row;
8867 #undef Max /* just in case */
8869 #define Max(a, b) ((a) > (b) ? (a) : (b))
8870 #define Min(a, b) ((a) < (b) ? (a) : (b))
8873 SetRect(rect, x, y, width, height)
8874 XRectangle * rect; int x; int y; int width; int height;
8878 rect->width = width;
8879 rect->height = height;
8882 /* Test if two frames overlap. If they do, return
8883 intersection rect within old and location of
8884 that rect within new. */
8887 Intersect(old, new, size, area, pt)
8888 XPoint * old; XPoint * new;
8889 int size; XRectangle * area; XPoint * pt;
8891 if (old->x > new->x + size || new->x > old->x + size ||
8892 old->y > new->y + size || new->y > old->y + size) {
8895 SetRect(area, Max(new->x - old->x, 0), Max(new->y - old->y, 0),
8896 size - abs(old->x - new->x), size - abs(old->y - new->y));
8897 pt->x = Max(old->x - new->x, 0);
8898 pt->y = Max(old->y - new->y, 0);
8903 /* For two overlapping frames, return the rect(s)
8904 in the old that do not intersect with the new. */
8907 CalcUpdateRects(old, new, size, update, nUpdates)
8908 XPoint * old; XPoint * new; int size;
8909 XRectangle update[]; int * nUpdates;
8913 /* If old = new (shouldn't happen) then nothing to draw */
8914 if (old->x == new->x && old->y == new->y) {
8918 /* Work out what bits overlap. Since we know the rects
8919 are the same size we don't need a full intersect calc. */
8921 /* Top or bottom edge? */
8922 if (new->y > old->y) {
8923 SetRect(&(update[count]), old->x, old->y, size, new->y - old->y);
8925 } else if (old->y > new->y) {
8926 SetRect(&(update[count]), old->x, old->y + size - (old->y - new->y),
8927 size, old->y - new->y);
8930 /* Left or right edge - don't overlap any update calculated above. */
8931 if (new->x > old->x) {
8932 SetRect(&(update[count]), old->x, Max(new->y, old->y),
8933 new->x - old->x, size - abs(new->y - old->y));
8935 } else if (old->x > new->x) {
8936 SetRect(&(update[count]), new->x + size, Max(new->y, old->y),
8937 old->x - new->x, size - abs(new->y - old->y));
8944 /* Generate a series of frame coords from start->mid->finish.
8945 The movement rate doubles until the half way point is
8946 reached, then halves back down to the final destination,
8947 which gives a nice slow in/out effect. The algorithmn
8948 may seem to generate too many intermediates for short
8949 moves, but remember that the purpose is to attract the
8950 viewers attention to the piece about to be moved and
8951 then to where it ends up. Too few frames would be less
8955 Tween(start, mid, finish, factor, frames, nFrames)
8956 XPoint * start; XPoint * mid;
8957 XPoint * finish; int factor;
8958 XPoint frames[]; int * nFrames;
8960 int fraction, n, count;
8964 /* Slow in, stepping 1/16th, then 1/8th, ... */
8966 for (n = 0; n < factor; n++)
8968 for (n = 0; n < factor; n++) {
8969 frames[count].x = start->x + (mid->x - start->x) / fraction;
8970 frames[count].y = start->y + (mid->y - start->y) / fraction;
8972 fraction = fraction / 2;
8976 frames[count] = *mid;
8979 /* Slow out, stepping 1/2, then 1/4, ... */
8981 for (n = 0; n < factor; n++) {
8982 frames[count].x = finish->x - (finish->x - mid->x) / fraction;
8983 frames[count].y = finish->y - (finish->y - mid->y) / fraction;
8985 fraction = fraction * 2;
8990 /* Draw a piece on the screen without disturbing what's there */
8993 SelectGCMask(piece, clip, outline, mask)
8994 ChessSquare piece; GC * clip; GC * outline; Pixmap * mask;
8998 /* Bitmap for piece being moved. */
8999 if (appData.monoMode) {
9000 *mask = *pieceToSolid(piece);
9001 } else if (useImages) {
9003 *mask = xpmMask[piece];
9005 *mask = ximMaskPm[piece];
9008 *mask = *pieceToSolid(piece);
9011 /* GC for piece being moved. Square color doesn't matter, but
9012 since it gets modified we make a copy of the original. */
9014 if (appData.monoMode)
9019 if (appData.monoMode)
9024 XCopyGC(xDisplay, source, 0xFFFFFFFF, *clip);
9026 /* Outline only used in mono mode and is not modified */
9028 *outline = bwPieceGC;
9030 *outline = wbPieceGC;
9034 OverlayPiece(piece, clip, outline, dest)
9035 ChessSquare piece; GC clip; GC outline; Drawable dest;
9040 /* Draw solid rectangle which will be clipped to shape of piece */
9041 XFillRectangle(xDisplay, dest, clip,
9042 0, 0, squareSize, squareSize);
9043 if (appData.monoMode)
9044 /* Also draw outline in contrasting color for black
9045 on black / white on white cases */
9046 XCopyPlane(xDisplay, *pieceToOutline(piece), dest, outline,
9047 0, 0, squareSize, squareSize, 0, 0, 1);
9049 /* Copy the piece */
9054 XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
9056 0, 0, squareSize, squareSize,
9061 /* Animate the movement of a single piece */
9064 BeginAnimation(anim, piece, startColor, start)
9072 /* The old buffer is initialised with the start square (empty) */
9073 BlankSquare(0, 0, startColor, EmptySquare, anim->saveBuf);
9074 anim->prevFrame = *start;
9076 /* The piece will be drawn using its own bitmap as a matte */
9077 SelectGCMask(piece, &anim->pieceGC, &anim->outlineGC, &mask);
9078 XSetClipMask(xDisplay, anim->pieceGC, mask);
9082 AnimationFrame(anim, frame, piece)
9087 XRectangle updates[4];
9092 /* Save what we are about to draw into the new buffer */
9093 XCopyArea(xDisplay, xBoardWindow, anim->newBuf, anim->blitGC,
9094 frame->x, frame->y, squareSize, squareSize,
9097 /* Erase bits of the previous frame */
9098 if (Intersect(&anim->prevFrame, frame, squareSize, &overlap, &pt)) {
9099 /* Where the new frame overlapped the previous,
9100 the contents in newBuf are wrong. */
9101 XCopyArea(xDisplay, anim->saveBuf, anim->newBuf, anim->blitGC,
9102 overlap.x, overlap.y,
9103 overlap.width, overlap.height,
9105 /* Repaint the areas in the old that don't overlap new */
9106 CalcUpdateRects(&anim->prevFrame, frame, squareSize, updates, &count);
9107 for (i = 0; i < count; i++)
9108 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9109 updates[i].x - anim->prevFrame.x,
9110 updates[i].y - anim->prevFrame.y,
9111 updates[i].width, updates[i].height,
9112 updates[i].x, updates[i].y);
9114 /* Easy when no overlap */
9115 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9116 0, 0, squareSize, squareSize,
9117 anim->prevFrame.x, anim->prevFrame.y);
9120 /* Save this frame for next time round */
9121 XCopyArea(xDisplay, anim->newBuf, anim->saveBuf, anim->blitGC,
9122 0, 0, squareSize, squareSize,
9124 anim->prevFrame = *frame;
9126 /* Draw piece over original screen contents, not current,
9127 and copy entire rect. Wipes out overlapping piece images. */
9128 OverlayPiece(piece, anim->pieceGC, anim->outlineGC, anim->newBuf);
9129 XCopyArea(xDisplay, anim->newBuf, xBoardWindow, anim->blitGC,
9130 0, 0, squareSize, squareSize,
9131 frame->x, frame->y);
9135 EndAnimation (anim, finish)
9139 XRectangle updates[4];
9144 /* The main code will redraw the final square, so we
9145 only need to erase the bits that don't overlap. */
9146 if (Intersect(&anim->prevFrame, finish, squareSize, &overlap, &pt)) {
9147 CalcUpdateRects(&anim->prevFrame, finish, squareSize, updates, &count);
9148 for (i = 0; i < count; i++)
9149 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9150 updates[i].x - anim->prevFrame.x,
9151 updates[i].y - anim->prevFrame.y,
9152 updates[i].width, updates[i].height,
9153 updates[i].x, updates[i].y);
9155 XCopyArea(xDisplay, anim->saveBuf, xBoardWindow, anim->blitGC,
9156 0, 0, squareSize, squareSize,
9157 anim->prevFrame.x, anim->prevFrame.y);
9162 FrameSequence(anim, piece, startColor, start, finish, frames, nFrames)
9164 ChessSquare piece; int startColor;
9165 XPoint * start; XPoint * finish;
9166 XPoint frames[]; int nFrames;
9170 BeginAnimation(anim, piece, startColor, start);
9171 for (n = 0; n < nFrames; n++) {
9172 AnimationFrame(anim, &(frames[n]), piece);
9173 FrameDelay(appData.animSpeed);
9175 EndAnimation(anim, finish);
9178 /* Main control logic for deciding what to animate and how */
9181 AnimateMove(board, fromX, fromY, toX, toY)
9190 XPoint start, finish, mid;
9191 XPoint frames[kFactor * 2 + 1];
9192 int nFrames, startColor, endColor;
9194 /* Are we animating? */
9195 if (!appData.animate || appData.blindfold)
9198 if(board[toY][toX] == WhiteRook && board[fromY][fromX] == WhiteKing ||
9199 board[toY][toX] == BlackRook && board[fromY][fromX] == BlackKing)
9200 return; // [HGM] FRC: no animtion of FRC castlings, as to-square is not true to-square
9202 if (fromY < 0 || fromX < 0 || toX < 0 || toY < 0) return;
9203 piece = board[fromY][fromX];
9204 if (piece >= EmptySquare) return;
9209 hop = (piece == WhiteKnight || piece == BlackKnight);
9212 if (appData.debugMode) {
9213 fprintf(debugFP, hop ? _("AnimateMove: piece %d hops from %d,%d to %d,%d \n") :
9214 _("AnimateMove: piece %d slides from %d,%d to %d,%d \n"),
9215 piece, fromX, fromY, toX, toY); }
9217 ScreenSquare(fromX, fromY, &start, &startColor);
9218 ScreenSquare(toX, toY, &finish, &endColor);
9221 /* Knight: make diagonal movement then straight */
9222 if (abs(toY - fromY) < abs(toX - fromX)) {
9223 mid.x = start.x + (finish.x - start.x) / 2;
9227 mid.y = start.y + (finish.y - start.y) / 2;
9230 mid.x = start.x + (finish.x - start.x) / 2;
9231 mid.y = start.y + (finish.y - start.y) / 2;
9234 /* Don't use as many frames for very short moves */
9235 if (abs(toY - fromY) + abs(toX - fromX) <= 2)
9236 Tween(&start, &mid, &finish, kFactor - 1, frames, &nFrames);
9238 Tween(&start, &mid, &finish, kFactor, frames, &nFrames);
9239 FrameSequence(&game, piece, startColor, &start, &finish, frames, nFrames);
9241 /* Be sure end square is redrawn */
9242 damage[toY][toX] = True;
9246 DragPieceBegin(x, y)
9249 int boardX, boardY, color;
9252 /* Are we animating? */
9253 if (!appData.animateDragging || appData.blindfold)
9256 /* Figure out which square we start in and the
9257 mouse position relative to top left corner. */
9258 BoardSquare(x, y, &boardX, &boardY);
9259 player.startBoardX = boardX;
9260 player.startBoardY = boardY;
9261 ScreenSquare(boardX, boardY, &corner, &color);
9262 player.startSquare = corner;
9263 player.startColor = color;
9264 /* As soon as we start dragging, the piece will jump slightly to
9265 be centered over the mouse pointer. */
9266 player.mouseDelta.x = squareSize/2;
9267 player.mouseDelta.y = squareSize/2;
9268 /* Initialise animation */
9269 player.dragPiece = PieceForSquare(boardX, boardY);
9271 if (player.dragPiece >= 0 && player.dragPiece < EmptySquare) {
9272 player.dragActive = True;
9273 BeginAnimation(&player, player.dragPiece, color, &corner);
9274 /* Mark this square as needing to be redrawn. Note that
9275 we don't remove the piece though, since logically (ie
9276 as seen by opponent) the move hasn't been made yet. */
9277 if(boardX == BOARD_RGHT+1 && PieceForSquare(boardX-1, boardY) > 1 ||
9278 boardX == BOARD_LEFT-2 && PieceForSquare(boardX+1, boardY) > 1)
9279 XCopyArea(xDisplay, xBoardWindow, player.saveBuf, player.blitGC,
9280 corner.x, corner.y, squareSize, squareSize,
9281 0, 0); // [HGM] zh: unstack in stead of grab
9282 damage[boardY][boardX] = True;
9284 player.dragActive = False;
9294 /* Are we animating? */
9295 if (!appData.animateDragging || appData.blindfold)
9299 if (! player.dragActive)
9301 /* Move piece, maintaining same relative position
9302 of mouse within square */
9303 corner.x = x - player.mouseDelta.x;
9304 corner.y = y - player.mouseDelta.y;
9305 AnimationFrame(&player, &corner, player.dragPiece);
9307 if (appData.highlightDragging) {
9309 BoardSquare(x, y, &boardX, &boardY);
9310 SetHighlights(fromX, fromY, boardX, boardY);
9319 int boardX, boardY, color;
9322 /* Are we animating? */
9323 if (!appData.animateDragging || appData.blindfold)
9327 if (! player.dragActive)
9329 /* Last frame in sequence is square piece is
9330 placed on, which may not match mouse exactly. */
9331 BoardSquare(x, y, &boardX, &boardY);
9332 ScreenSquare(boardX, boardY, &corner, &color);
9333 EndAnimation(&player, &corner);
9335 /* Be sure end square is redrawn */
9336 damage[boardY][boardX] = True;
9338 /* This prevents weird things happening with fast successive
9339 clicks which on my Sun at least can cause motion events
9340 without corresponding press/release. */
9341 player.dragActive = False;
9344 /* Handle expose event while piece being dragged */
9349 if (!player.dragActive || appData.blindfold)
9352 /* What we're doing: logically, the move hasn't been made yet,
9353 so the piece is still in it's original square. But visually
9354 it's being dragged around the board. So we erase the square
9355 that the piece is on and draw it at the last known drag point. */
9356 BlankSquare(player.startSquare.x, player.startSquare.y,
9357 player.startColor, EmptySquare, xBoardWindow);
9358 AnimationFrame(&player, &player.prevFrame, player.dragPiece);
9359 damage[player.startBoardY][player.startBoardX] = TRUE;
9363 SetProgramStats( FrontEndProgramStats * stats )
9366 // [HGM] done, but perhaps backend should call this directly?
9367 EngineOutputUpdate( stats );
9370 #include <sys/ioctl.h>
9371 int get_term_width()
9373 int fd, default_width;
9376 default_width = 79; // this is FICS default anyway...
9378 #if !defined(TIOCGWINSZ) && defined(TIOCGSIZE)
9380 if (!ioctl(fd, TIOCGSIZE, &win))
9381 default_width = win.ts_cols;
9382 #elif defined(TIOCGWINSZ)
9384 if (!ioctl(fd, TIOCGWINSZ, &win))
9385 default_width = win.ws_col;
9387 return default_width;
9390 void update_ics_width()
9392 static int old_width = 0;
9393 int new_width = get_term_width();
9395 if (old_width != new_width)
9396 ics_printf("set width %d\n", new_width);
9397 old_width = new_width;
9400 void NotifyFrontendLogin()