2 * xboard.c -- X front end for XBoard
5 * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
6 * Enhancements Copyright 1992-2001 Free Software Foundation, Inc.
8 * The following terms apply to Digital Equipment Corporation's copyright
10 * ------------------------------------------------------------------------
13 * Permission to use, copy, modify, and distribute this software and its
14 * documentation for any purpose and without fee is hereby granted,
15 * provided that the above copyright notice appear in all copies and that
16 * both that copyright notice and this permission notice appear in
17 * supporting documentation, and that the name of Digital not be
18 * used in advertising or publicity pertaining to distribution of the
19 * software without specific, written prior permission.
21 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
22 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
23 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
24 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
25 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
26 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
28 * ------------------------------------------------------------------------
30 * The following terms apply to the enhanced version of XBoard distributed
31 * by the Free Software Foundation:
32 * ------------------------------------------------------------------------
33 * This program is free software; you can redistribute it and/or modify
34 * it under the terms of the GNU General Public License as published by
35 * the Free Software Foundation; either version 2 of the License, or
36 * (at your option) any later version.
38 * This program is distributed in the hope that it will be useful,
39 * but WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
41 * GNU General Public License for more details.
43 * You should have received a copy of the GNU General Public License
44 * along with this program; if not, write to the Free Software
45 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
46 * ------------------------------------------------------------------------
48 * See the file ChangeLog for a revision history.
57 #include <sys/types.h>
62 # if HAVE_SYS_SOCKET_H
63 # include <sys/socket.h>
64 # include <netinet/in.h>
66 # else /* not HAVE_SYS_SOCKET_H */
67 # if HAVE_LAN_SOCKET_H
68 # include <lan/socket.h>
70 # include <lan/netdb.h>
71 # else /* not HAVE_LAN_SOCKET_H */
72 # define OMIT_SOCKETS 1
73 # endif /* not HAVE_LAN_SOCKET_H */
74 # endif /* not HAVE_SYS_SOCKET_H */
75 #endif /* !OMIT_SOCKETS */
80 #else /* not STDC_HEADERS */
81 extern char *getenv();
84 # else /* not HAVE_STRING_H */
86 # endif /* not HAVE_STRING_H */
87 #endif /* not STDC_HEADERS */
90 # include <sys/fcntl.h>
91 #else /* not HAVE_SYS_FCNTL_H */
94 # endif /* HAVE_FCNTL_H */
95 #endif /* not HAVE_SYS_FCNTL_H */
97 #if HAVE_SYS_SYSTEMINFO_H
98 # include <sys/systeminfo.h>
99 #endif /* HAVE_SYS_SYSTEMINFO_H */
101 #if TIME_WITH_SYS_TIME
102 # include <sys/time.h>
106 # include <sys/time.h>
117 # include <sys/wait.h>
122 # define NAMLEN(dirent) strlen((dirent)->d_name)
123 # define HAVE_DIR_STRUCT
125 # define dirent direct
126 # define NAMLEN(dirent) (dirent)->d_namlen
128 # include <sys/ndir.h>
129 # define HAVE_DIR_STRUCT
132 # include <sys/dir.h>
133 # define HAVE_DIR_STRUCT
137 # define HAVE_DIR_STRUCT
141 #include <X11/Intrinsic.h>
142 #include <X11/StringDefs.h>
143 #include <X11/Shell.h>
144 #include <X11/cursorfont.h>
145 #include <X11/Xatom.h>
147 #include <X11/Xaw3d/Dialog.h>
148 #include <X11/Xaw3d/Form.h>
149 #include <X11/Xaw3d/List.h>
150 #include <X11/Xaw3d/Label.h>
151 #include <X11/Xaw3d/SimpleMenu.h>
152 #include <X11/Xaw3d/SmeBSB.h>
153 #include <X11/Xaw3d/SmeLine.h>
154 #include <X11/Xaw3d/Box.h>
155 #include <X11/Xaw3d/MenuButton.h>
156 #include <X11/Xaw3d/Text.h>
157 #include <X11/Xaw3d/AsciiText.h>
159 #include <X11/Xaw/Dialog.h>
160 #include <X11/Xaw/Form.h>
161 #include <X11/Xaw/List.h>
162 #include <X11/Xaw/Label.h>
163 #include <X11/Xaw/SimpleMenu.h>
164 #include <X11/Xaw/SmeBSB.h>
165 #include <X11/Xaw/SmeLine.h>
166 #include <X11/Xaw/Box.h>
167 #include <X11/Xaw/MenuButton.h>
168 #include <X11/Xaw/Text.h>
169 #include <X11/Xaw/AsciiText.h>
174 #include "pixmaps/pixmaps.h"
175 #define IMAGE_EXT "xpm"
177 #define IMAGE_EXT "xim"
178 #include "bitmaps/bitmaps.h"
181 #include "bitmaps/icon_white.bm"
182 #include "bitmaps/icon_black.bm"
183 #include "bitmaps/checkmark.bm"
186 #include "frontend.h"
191 #include "xgamelist.h"
192 #include "xhistory.h"
193 #include "xedittags.h"
200 #define usleep(t) _sleep2(((t)+500)/1000)
204 # define _(s) gettext (s)
205 # define N_(s) gettext_noop (s)
221 int main P((int argc, char **argv));
222 RETSIGTYPE CmailSigHandler P((int sig));
223 RETSIGTYPE IntSigHandler P((int sig));
224 void CreateGCs P((void));
225 void CreateXIMPieces P((void));
226 void CreateXPMPieces P((void));
227 void CreatePieces P((void));
228 void CreatePieceMenus P((void));
229 Widget CreateMenuBar P((Menu *mb));
230 Widget CreateButtonBar P ((MenuItem *mi));
231 char *FindFont P((char *pattern, int targetPxlSize));
232 void PieceMenuPopup P((Widget w, XEvent *event,
233 String *params, Cardinal *num_params));
234 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
235 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
236 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
237 u_int wreq, u_int hreq));
238 void CreateGrid P((void));
239 int EventToSquare P((int x, int limit));
240 void DrawSquare P((int row, int column, ChessSquare piece, int do_flash));
241 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
242 void HandleUserMove P((Widget w, XEvent *event,
243 String *prms, Cardinal *nprms));
244 void AnimateUserMove P((Widget w, XEvent * event,
245 String * params, Cardinal * nParams));
246 void WhiteClock P((Widget w, XEvent *event,
247 String *prms, Cardinal *nprms));
248 void BlackClock P((Widget w, XEvent *event,
249 String *prms, Cardinal *nprms));
250 void DrawPositionProc P((Widget w, XEvent *event,
251 String *prms, Cardinal *nprms));
252 void XDrawPosition P((Widget w, /*Boolean*/int repaint,
254 void CommentPopUp P((char *title, char *label));
255 void CommentPopDown P((void));
256 void CommentCallback P((Widget w, XtPointer client_data,
257 XtPointer call_data));
258 void ICSInputBoxPopUp P((void));
259 void ICSInputBoxPopDown P((void));
260 void FileNamePopUp P((char *label, char *def,
261 FileProc proc, char *openMode));
262 void FileNamePopDown P((void));
263 void FileNameCallback P((Widget w, XtPointer client_data,
264 XtPointer call_data));
265 void FileNameAction P((Widget w, XEvent *event,
266 String *prms, Cardinal *nprms));
267 void AskQuestionReplyAction P((Widget w, XEvent *event,
268 String *prms, Cardinal *nprms));
269 void AskQuestionProc P((Widget w, XEvent *event,
270 String *prms, Cardinal *nprms));
271 void AskQuestionPopDown P((void));
272 void PromotionPopUp P((void));
273 void PromotionPopDown P((void));
274 void PromotionCallback P((Widget w, XtPointer client_data,
275 XtPointer call_data));
276 void EditCommentPopDown P((void));
277 void EditCommentCallback P((Widget w, XtPointer client_data,
278 XtPointer call_data));
279 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
280 void ResetProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
281 void LoadGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
282 void LoadNextGameProc P((Widget w, XEvent *event, String *prms,
284 void LoadPrevGameProc P((Widget w, XEvent *event, String *prms,
286 void ReloadGameProc P((Widget w, XEvent *event, String *prms,
288 void LoadPositionProc P((Widget w, XEvent *event,
289 String *prms, Cardinal *nprms));
290 void LoadNextPositionProc P((Widget w, XEvent *event, String *prms,
292 void LoadPrevPositionProc P((Widget w, XEvent *event, String *prms,
294 void ReloadPositionProc P((Widget w, XEvent *event, String *prms,
296 void CopyPositionProc P((Widget w, XEvent *event, String *prms,
298 void PastePositionProc P((Widget w, XEvent *event, String *prms,
300 void CopyGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
301 void PasteGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
302 void SaveGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
303 void SavePositionProc P((Widget w, XEvent *event,
304 String *prms, Cardinal *nprms));
305 void MailMoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
306 void ReloadCmailMsgProc P((Widget w, XEvent *event, String *prms,
308 void QuitProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
309 void PauseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
310 void MachineBlackProc P((Widget w, XEvent *event, String *prms,
312 void MachineWhiteProc P((Widget w, XEvent *event,
313 String *prms, Cardinal *nprms));
314 void AnalyzeModeProc P((Widget w, XEvent *event,
315 String *prms, Cardinal *nprms));
316 void AnalyzeFileProc P((Widget w, XEvent *event,
317 String *prms, Cardinal *nprms));
318 void TwoMachinesProc P((Widget w, XEvent *event, String *prms,
320 void IcsClientProc P((Widget w, XEvent *event, String *prms,
322 void EditGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
323 void EditPositionProc P((Widget w, XEvent *event,
324 String *prms, Cardinal *nprms));
325 void TrainingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
326 void EditCommentProc P((Widget w, XEvent *event,
327 String *prms, Cardinal *nprms));
328 void IcsInputBoxProc P((Widget w, XEvent *event,
329 String *prms, Cardinal *nprms));
330 void AcceptProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
331 void DeclineProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
332 void RematchProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
333 void CallFlagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
334 void DrawProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
335 void AbortProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
336 void AdjournProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
337 void ResignProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
338 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
339 void StopObservingProc P((Widget w, XEvent *event, String *prms,
341 void StopExaminingProc P((Widget w, XEvent *event, String *prms,
343 void BackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
344 void ForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
345 void ToStartProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
346 void ToEndProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
347 void RevertProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
348 void TruncateGameProc P((Widget w, XEvent *event, String *prms,
350 void RetractMoveProc P((Widget w, XEvent *event, String *prms,
352 void MoveNowProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
353 void AlwaysQueenProc P((Widget w, XEvent *event, String *prms,
355 void AnimateDraggingProc P((Widget w, XEvent *event, String *prms,
357 void AnimateMovingProc P((Widget w, XEvent *event, String *prms,
359 void AutocommProc P((Widget w, XEvent *event, String *prms,
361 void AutoflagProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
362 void AutoflipProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
363 void AutobsProc P((Widget w, XEvent *event, String *prms,
365 void AutoraiseProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
366 void AutosaveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
367 void BlindfoldProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
368 void FlashMovesProc P((Widget w, XEvent *event, String *prms,
370 void FlipViewProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
371 void GetMoveListProc P((Widget w, XEvent *event, String *prms,
373 void HighlightDraggingProc P((Widget w, XEvent *event, String *prms,
375 void HighlightLastMoveProc P((Widget w, XEvent *event, String *prms,
377 void MoveSoundProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
378 void IcsAlarmProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
379 void OldSaveStyleProc P((Widget w, XEvent *event, String *prms,
381 void PeriodicUpdatesProc P((Widget w, XEvent *event, String *prms,
383 void PonderNextMoveProc P((Widget w, XEvent *event, String *prms,
385 void PopupMoveErrorsProc P((Widget w, XEvent *event, String *prms,
387 void PopupExitMessageProc P((Widget w, XEvent *event, String *prms,
389 void PremoveProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
390 void QuietPlayProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
391 void ShowCoordsProc P((Widget w, XEvent *event, String *prms,
393 void ShowThinkingProc P((Widget w, XEvent *event, String *prms,
395 void TestLegalityProc P((Widget w, XEvent *event, String *prms,
397 void InfoProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
398 void ManProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
399 void HintProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
400 void BookProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
401 void AboutGameProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
402 void AboutProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
403 void DebugProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
404 void NothingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
405 void Iconify P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
406 void DisplayMove P((int moveNumber));
407 void DisplayTitle P((char *title));
408 void ICSInitScript P((void));
409 int LoadGamePopUp P((FILE *f, int gameNumber, char *title));
410 void ErrorPopUp P((char *title, char *text, int modal));
411 void ErrorPopDown P((void));
412 static char *ExpandPathName P((char *path));
413 static void CreateAnimVars P((void));
414 static void DragPieceBegin P((int x, int y));
415 static void DragPieceMove P((int x, int y));
416 static void DragPieceEnd P((int x, int y));
417 static void DrawDragPiece P((void));
418 char *ModeToWidgetName P((GameMode mode));
421 * XBoard depends on Xt R4 or higher
423 int xtVersion = XtSpecificationRelease;
428 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
429 jailSquareColor, highlightSquareColor, premoveHighlightColor;
430 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
431 bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
432 wjPieceGC, bjPieceGC, prelineGC;
433 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
434 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
435 whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
436 commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
437 menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
438 ICSInputShell, fileNameShell, askQuestionShell;
439 XSegment gridSegments[(BOARD_SIZE + 1) * 2];
440 XSegment jailGridSegments[(BOARD_SIZE + 3) * 2];
441 Font clockFontID, coordFontID;
442 XFontStruct *clockFontStruct, *coordFontStruct;
443 XtAppContext appContext;
445 char *oldICSInteractionTitle;
450 Position commentX = -1, commentY = -1;
451 Dimension commentW, commentH;
453 int squareSize, smallLayout = 0, tinyLayout = 0,
454 fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
455 ICSInputBoxUp = False, askQuestionUp = False,
456 filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
457 editUp = False, errorUp = False, errorExitStatus = -1, lineGap;
458 Pixel timerForegroundPixel, timerBackgroundPixel;
459 Pixel buttonForegroundPixel, buttonBackgroundPixel;
460 char *chessDir, *programName, *programVersion,
461 *gameCopyFilename, *gamePasteFilename;
465 Pixmap pieceBitmap[2][6];
466 Pixmap xpmPieceBitmap[4][6]; /* LL, LD, DL, DD */
467 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
468 int useImages, useImageSqs;
469 XImage *ximPieceBitmap[4][6]; /* LL, LD, DL, DD */
470 Pixmap ximMaskPm[6]; /* clipmasks, used for XIM pieces */
471 XImage *ximLightSquare, *ximDarkSquare;
474 #define pieceToSolid(piece) &pieceBitmap[SOLID][((int)(piece)) % 6]
475 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][((int)(piece)) % 6]
477 #define White(piece) ((int)(piece) < (int)BlackPawn)
479 /* Variables for doing smooth animation. This whole thing
480 would be much easier if the board was double-buffered,
481 but that would require a fairly major rewrite. */
486 GC blitGC, pieceGC, outlineGC;
487 XPoint startSquare, prevFrame, mouseDelta;
491 int startBoardX, startBoardY;
494 /* There can be two pieces being animated at once: a player
495 can begin dragging a piece before the remote opponent has moved. */
497 static AnimState game, player;
499 /* Bitmaps for use as masks when drawing XPM pieces.
500 Need one for each black and white piece. */
501 static Pixmap xpmMask[BlackKing + 1];
503 /* This magic number is the number of intermediate frames used
504 in each half of the animation. For short moves it's reduced
505 by 1. The total number of frames will be factor * 2 + 1. */
508 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
510 MenuItem fileMenu[] = {
511 {N_("Reset Game"), ResetProc},
512 {"----", NothingProc},
513 {N_("Load Game"), LoadGameProc},
514 {N_("Load Next Game"), LoadNextGameProc},
515 {N_("Load Previous Game"), LoadPrevGameProc},
516 {N_("Reload Same Game"), ReloadGameProc},
517 {N_("Save Game"), SaveGameProc},
518 {"----", NothingProc},
519 {N_("Copy Game"), CopyGameProc},
520 {N_("Paste Game"), PasteGameProc},
521 {"----", NothingProc},
522 {N_("Load Position"), LoadPositionProc},
523 {N_("Load Next Position"), LoadNextPositionProc},
524 {N_("Load Previous Position"), LoadPrevPositionProc},
525 {N_("Reload Same Position"), ReloadPositionProc},
526 {N_("Save Position"), SavePositionProc},
527 {"----", NothingProc},
528 {N_("Copy Position"), CopyPositionProc},
529 {N_("Paste Position"), PastePositionProc},
530 {"----", NothingProc},
531 {N_("Mail Move"), MailMoveProc},
532 {N_("Reload CMail Message"), ReloadCmailMsgProc},
533 {"----", NothingProc},
534 {N_("Exit"), QuitProc},
538 MenuItem modeMenu[] = {
539 {N_("Machine White"), MachineWhiteProc},
540 {N_("Machine Black"), MachineBlackProc},
541 {N_("Two Machines"), TwoMachinesProc},
542 {N_("Analysis Mode"), AnalyzeModeProc},
543 {N_("Analyze File"), AnalyzeFileProc },
544 {N_("ICS Client"), IcsClientProc},
545 {N_("Edit Game"), EditGameProc},
546 {N_("Edit Position"), EditPositionProc},
547 {N_("Training"), TrainingProc},
548 {"----", NothingProc},
549 {N_("Show Game List"), ShowGameListProc},
550 {N_("Show Move List"), HistoryShowProc},
551 {N_("Edit Tags"), EditTagsProc},
552 {N_("Edit Comment"), EditCommentProc},
553 {N_("ICS Input Box"), IcsInputBoxProc},
554 {N_("Pause"), PauseProc},
558 MenuItem actionMenu[] = {
559 {N_("Accept"), AcceptProc},
560 {N_("Decline"), DeclineProc},
561 {N_("Rematch"), RematchProc},
562 {"----", NothingProc},
563 {N_("Call Flag"), CallFlagProc},
564 {N_("Draw"), DrawProc},
565 {N_("Adjourn"), AdjournProc},
566 {N_("Abort"), AbortProc},
567 {N_("Resign"), ResignProc},
568 {"----", NothingProc},
569 {N_("Stop Observing"), StopObservingProc},
570 {N_("Stop Examining"), StopExaminingProc},
574 MenuItem stepMenu[] = {
575 {N_("Backward"), BackwardProc},
576 {N_("Forward"), ForwardProc},
577 {N_("Back to Start"), ToStartProc},
578 {N_("Forward to End"), ToEndProc},
579 {N_("Revert"), RevertProc},
580 {N_("Truncate Game"), TruncateGameProc},
581 {"----", NothingProc},
582 {N_("Move Now"), MoveNowProc},
583 {N_("Retract Move"), RetractMoveProc},
587 MenuItem optionsMenu[] = {
588 {N_("Always Queen"), AlwaysQueenProc},
589 {N_("Animate Dragging"), AnimateDraggingProc},
590 {N_("Animate Moving"), AnimateMovingProc},
591 {N_("Auto Comment"), AutocommProc},
592 {N_("Auto Flag"), AutoflagProc},
593 {N_("Auto Flip View"), AutoflipProc},
594 {N_("Auto Observe"), AutobsProc},
595 {N_("Auto Raise Board"), AutoraiseProc},
596 {N_("Auto Save"), AutosaveProc},
597 {N_("Blindfold"), BlindfoldProc},
598 {N_("Flash Moves"), FlashMovesProc},
599 {N_("Flip View"), FlipViewProc},
600 {N_("Get Move List"), GetMoveListProc},
602 {N_("Highlight Dragging"), HighlightDraggingProc},
604 {N_("Highlight Last Move"), HighlightLastMoveProc},
605 {N_("Move Sound"), MoveSoundProc},
606 {N_("ICS Alarm"), IcsAlarmProc},
607 {N_("Old Save Style"), OldSaveStyleProc},
608 {N_("Periodic Updates"), PeriodicUpdatesProc},
609 {N_("Ponder Next Move"), PonderNextMoveProc},
610 {N_("Popup Exit Message"), PopupExitMessageProc},
611 {N_("Popup Move Errors"), PopupMoveErrorsProc},
612 {N_("Premove"), PremoveProc},
613 {N_("Quiet Play"), QuietPlayProc},
614 {N_("Show Coords"), ShowCoordsProc},
615 {N_("Show Thinking"), ShowThinkingProc},
616 {N_("Test Legality"), TestLegalityProc},
620 MenuItem helpMenu[] = {
621 {N_("Info XBoard"), InfoProc},
622 {N_("Man XBoard"), ManProc},
623 {"----", NothingProc},
624 {N_("Hint"), HintProc},
625 {N_("Book"), BookProc},
626 {"----", NothingProc},
627 {N_("About XBoard"), AboutProc},
632 {N_("File"), fileMenu},
633 {N_("Mode"), modeMenu},
634 {N_("Action"), actionMenu},
635 {N_("Step"), stepMenu},
636 {N_("Options"), optionsMenu},
637 {N_("Help"), helpMenu},
642 /* Label on pause button */
643 #define PAUSE_BUTTON N_("P")
644 MenuItem buttonBar[] = {
647 {PAUSE_BUTTON, PauseProc},
653 #define PIECE_MENU_SIZE 11
654 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
655 { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
656 N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
657 { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
658 N_("Queen"), N_("King"), "----", N_("Empty square"), N_("Clear board") },
660 /* must be in same order as PieceMenuStrings! */
661 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
662 { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
663 WhiteRook, WhiteQueen, WhiteKing,
664 (ChessSquare) 0, EmptySquare, ClearBoard },
665 { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
666 BlackRook, BlackQueen, BlackKing,
667 (ChessSquare) 0, EmptySquare, ClearBoard },
670 #define DROP_MENU_SIZE 6
671 String dropMenuStrings[DROP_MENU_SIZE] = {
672 "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
674 /* must be in same order as PieceMenuStrings! */
675 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
676 (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
677 WhiteRook, WhiteQueen
685 DropMenuEnables dmEnables[] = {
703 { XtNborderWidth, 0 },
704 { XtNdefaultDistance, 0 },
708 { XtNborderWidth, 0 },
709 { XtNresizable, (XtArgVal) True },
713 { XtNborderWidth, 0 },
719 { XtNjustify, (XtArgVal) XtJustifyRight },
720 { XtNlabel, (XtArgVal) "..." },
721 { XtNresizable, (XtArgVal) True },
722 { XtNresize, (XtArgVal) False }
725 Arg messageArgs[] = {
726 { XtNjustify, (XtArgVal) XtJustifyLeft },
727 { XtNlabel, (XtArgVal) "..." },
728 { XtNresizable, (XtArgVal) True },
729 { XtNresize, (XtArgVal) False }
733 { XtNborderWidth, 0 },
734 { XtNjustify, (XtArgVal) XtJustifyLeft }
737 XtResource clientResources[] = {
738 { "whitePieceColor", "whitePieceColor", XtRString, sizeof(String),
739 XtOffset(AppDataPtr, whitePieceColor), XtRString,
741 { "blackPieceColor", "blackPieceColor", XtRString, sizeof(String),
742 XtOffset(AppDataPtr, blackPieceColor), XtRString,
744 { "lightSquareColor", "lightSquareColor", XtRString,
745 sizeof(String), XtOffset(AppDataPtr, lightSquareColor),
746 XtRString, LIGHT_SQUARE_COLOR },
747 { "darkSquareColor", "darkSquareColor", XtRString, sizeof(String),
748 XtOffset(AppDataPtr, darkSquareColor), XtRString,
750 { "highlightSquareColor", "highlightSquareColor", XtRString,
751 sizeof(String), XtOffset(AppDataPtr, highlightSquareColor),
752 XtRString, HIGHLIGHT_SQUARE_COLOR },
753 { "premoveHighlightColor", "premoveHighlightColor", XtRString,
754 sizeof(String), XtOffset(AppDataPtr, premoveHighlightColor),
755 XtRString, PREMOVE_HIGHLIGHT_COLOR },
756 { "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
757 XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
758 (XtPointer) MOVES_PER_SESSION },
759 { "timeIncrement", "timeIncrement", XtRInt, sizeof(int),
760 XtOffset(AppDataPtr, timeIncrement), XtRImmediate,
761 (XtPointer) TIME_INCREMENT },
762 { "initString", "initString", XtRString, sizeof(String),
763 XtOffset(AppDataPtr, initString), XtRString, INIT_STRING },
764 { "secondInitString", "secondInitString", XtRString, sizeof(String),
765 XtOffset(AppDataPtr, secondInitString), XtRString, INIT_STRING },
766 { "firstComputerString", "firstComputerString", XtRString,
767 sizeof(String), XtOffset(AppDataPtr, firstComputerString), XtRString,
769 { "secondComputerString", "secondComputerString", XtRString,
770 sizeof(String), XtOffset(AppDataPtr, secondComputerString), XtRString,
772 { "firstChessProgram", "firstChessProgram", XtRString,
773 sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
774 XtRString, FIRST_CHESS_PROGRAM },
775 { "secondChessProgram", "secondChessProgram", XtRString,
776 sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
777 XtRString, SECOND_CHESS_PROGRAM },
778 { "firstPlaysBlack", "firstPlaysBlack", XtRBoolean,
779 sizeof(Boolean), XtOffset(AppDataPtr, firstPlaysBlack),
780 XtRImmediate, (XtPointer) False },
781 { "noChessProgram", "noChessProgram", XtRBoolean,
782 sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
783 XtRImmediate, (XtPointer) False },
784 { "firstHost", "firstHost", XtRString, sizeof(String),
785 XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST },
786 { "secondHost", "secondHost", XtRString, sizeof(String),
787 XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST },
788 { "firstDirectory", "firstDirectory", XtRString, sizeof(String),
789 XtOffset(AppDataPtr, firstDirectory), XtRString, "" },
790 { "secondDirectory", "secondDirectory", XtRString, sizeof(String),
791 XtOffset(AppDataPtr, secondDirectory), XtRString, "" },
792 { "bitmapDirectory", "bitmapDirectory", XtRString,
793 sizeof(String), XtOffset(AppDataPtr, bitmapDirectory),
795 { "remoteShell", "remoteShell", XtRString, sizeof(String),
796 XtOffset(AppDataPtr, remoteShell), XtRString, REMOTE_SHELL },
797 { "remoteUser", "remoteUser", XtRString, sizeof(String),
798 XtOffset(AppDataPtr, remoteUser), XtRString, "" },
799 { "timeDelay", "timeDelay", XtRFloat, sizeof(float),
800 XtOffset(AppDataPtr, timeDelay), XtRString,
801 (XtPointer) TIME_DELAY_QUOTE },
802 { "timeControl", "timeControl", XtRString, sizeof(String),
803 XtOffset(AppDataPtr, timeControl), XtRString,
804 (XtPointer) TIME_CONTROL },
805 { "internetChessServerMode", "internetChessServerMode",
806 XtRBoolean, sizeof(Boolean),
807 XtOffset(AppDataPtr, icsActive), XtRImmediate,
809 { "internetChessServerHost", "internetChessServerHost",
810 XtRString, sizeof(String),
811 XtOffset(AppDataPtr, icsHost),
812 XtRString, (XtPointer) ICS_HOST },
813 { "internetChessServerPort", "internetChessServerPort",
814 XtRString, sizeof(String),
815 XtOffset(AppDataPtr, icsPort), XtRString,
816 (XtPointer) ICS_PORT },
817 { "internetChessServerCommPort", "internetChessServerCommPort",
818 XtRString, sizeof(String),
819 XtOffset(AppDataPtr, icsCommPort), XtRString,
821 { "internetChessServerLogonScript", "internetChessServerLogonScript",
822 XtRString, sizeof(String),
823 XtOffset(AppDataPtr, icsLogon), XtRString,
825 { "internetChessServerHelper", "internetChessServerHelper",
826 XtRString, sizeof(String),
827 XtOffset(AppDataPtr, icsHelper), XtRString, "" },
828 { "internetChessServerInputBox", "internetChessServerInputBox",
829 XtRBoolean, sizeof(Boolean),
830 XtOffset(AppDataPtr, icsInputBox), XtRImmediate,
832 { "icsAlarm", "icsAlarm",
833 XtRBoolean, sizeof(Boolean),
834 XtOffset(AppDataPtr, icsAlarm), XtRImmediate,
836 { "icsAlarmTime", "icsAlarmTime",
838 XtOffset(AppDataPtr, icsAlarmTime), XtRImmediate,
840 { "useTelnet", "useTelnet", XtRBoolean, sizeof(Boolean),
841 XtOffset(AppDataPtr, useTelnet), XtRImmediate,
843 { "telnetProgram", "telnetProgram", XtRString, sizeof(String),
844 XtOffset(AppDataPtr, telnetProgram), XtRString, TELNET_PROGRAM },
845 { "gateway", "gateway", XtRString, sizeof(String),
846 XtOffset(AppDataPtr, gateway), XtRString, "" },
847 { "loadGameFile", "loadGameFile", XtRString, sizeof(String),
848 XtOffset(AppDataPtr, loadGameFile), XtRString, "" },
849 { "loadGameIndex", "loadGameIndex",
851 XtOffset(AppDataPtr, loadGameIndex), XtRImmediate,
853 { "saveGameFile", "saveGameFile", XtRString, sizeof(String),
854 XtOffset(AppDataPtr, saveGameFile), XtRString, "" },
855 { "autoRaiseBoard", "autoRaiseBoard", XtRBoolean,
856 sizeof(Boolean), XtOffset(AppDataPtr, autoRaiseBoard),
857 XtRImmediate, (XtPointer) True },
858 { "autoSaveGames", "autoSaveGames", XtRBoolean,
859 sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
860 XtRImmediate, (XtPointer) False },
861 { "blindfold", "blindfold", XtRBoolean,
862 sizeof(Boolean), XtOffset(AppDataPtr, blindfold),
863 XtRImmediate, (XtPointer) False },
864 { "loadPositionFile", "loadPositionFile", XtRString,
865 sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
867 { "loadPositionIndex", "loadPositionIndex",
869 XtOffset(AppDataPtr, loadPositionIndex), XtRImmediate,
871 { "savePositionFile", "savePositionFile", XtRString,
872 sizeof(String), XtOffset(AppDataPtr, savePositionFile),
874 { "matchMode", "matchMode", XtRBoolean, sizeof(Boolean),
875 XtOffset(AppDataPtr, matchMode), XtRImmediate, (XtPointer) False },
876 { "matchGames", "matchGames", XtRInt, sizeof(int),
877 XtOffset(AppDataPtr, matchGames), XtRImmediate,
879 { "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
880 XtOffset(AppDataPtr, monoMode), XtRImmediate,
882 { "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
883 XtOffset(AppDataPtr, debugMode), XtRImmediate,
885 { "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
886 XtOffset(AppDataPtr, clockMode), XtRImmediate,
888 { "boardSize", "boardSize", XtRString, sizeof(String),
889 XtOffset(AppDataPtr, boardSize), XtRString, "" },
890 { "searchTime", "searchTime", XtRString, sizeof(String),
891 XtOffset(AppDataPtr, searchTime), XtRString,
893 { "searchDepth", "searchDepth", XtRInt, sizeof(int),
894 XtOffset(AppDataPtr, searchDepth), XtRImmediate,
896 { "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
897 XtOffset(AppDataPtr, showCoords), XtRImmediate,
899 { "showJail", "showJail", XtRInt, sizeof(int),
900 XtOffset(AppDataPtr, showJail), XtRImmediate,
902 { "showThinking", "showThinking", XtRBoolean, sizeof(Boolean),
903 XtOffset(AppDataPtr, showThinking), XtRImmediate,
905 { "ponderNextMove", "ponderNextMove", XtRBoolean, sizeof(Boolean),
906 XtOffset(AppDataPtr, ponderNextMove), XtRImmediate,
908 { "periodicUpdates", "periodicUpdates", XtRBoolean, sizeof(Boolean),
909 XtOffset(AppDataPtr, periodicUpdates), XtRImmediate,
911 { "clockFont", "clockFont", XtRString, sizeof(String),
912 XtOffset(AppDataPtr, clockFont), XtRString, CLOCK_FONT },
913 { "coordFont", "coordFont", XtRString, sizeof(String),
914 XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT },
915 { "font", "font", XtRString, sizeof(String),
916 XtOffset(AppDataPtr, font), XtRString, DEFAULT_FONT },
917 { "ringBellAfterMoves", "ringBellAfterMoves",
918 XtRBoolean, sizeof(Boolean),
919 XtOffset(AppDataPtr, ringBellAfterMoves),
920 XtRImmediate, (XtPointer) False },
921 { "autoCallFlag", "autoCallFlag", XtRBoolean,
922 sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
923 XtRImmediate, (XtPointer) False },
924 { "autoFlipView", "autoFlipView", XtRBoolean,
925 sizeof(Boolean), XtOffset(AppDataPtr, autoFlipView),
926 XtRImmediate, (XtPointer) True },
927 { "autoObserve", "autoObserve", XtRBoolean,
928 sizeof(Boolean), XtOffset(AppDataPtr, autoObserve),
929 XtRImmediate, (XtPointer) False },
930 { "autoComment", "autoComment", XtRBoolean,
931 sizeof(Boolean), XtOffset(AppDataPtr, autoComment),
932 XtRImmediate, (XtPointer) False },
933 { "getMoveList", "getMoveList", XtRBoolean,
934 sizeof(Boolean), XtOffset(AppDataPtr, getMoveList),
935 XtRImmediate, (XtPointer) True },
937 { "highlightDragging", "highlightDragging", XtRBoolean,
938 sizeof(Boolean), XtOffset(AppDataPtr, highlightDragging),
939 XtRImmediate, (XtPointer) False },
941 { "highlightLastMove", "highlightLastMove", XtRBoolean,
942 sizeof(Boolean), XtOffset(AppDataPtr, highlightLastMove),
943 XtRImmediate, (XtPointer) False },
944 { "premove", "premove", XtRBoolean,
945 sizeof(Boolean), XtOffset(AppDataPtr, premove),
946 XtRImmediate, (XtPointer) True },
947 { "testLegality", "testLegality", XtRBoolean,
948 sizeof(Boolean), XtOffset(AppDataPtr, testLegality),
949 XtRImmediate, (XtPointer) True },
950 { "flipView", "flipView", XtRBoolean,
951 sizeof(Boolean), XtOffset(AppDataPtr, flipView),
952 XtRImmediate, (XtPointer) False },
953 { "cmail", "cmailGameName", XtRString, sizeof(String),
954 XtOffset(AppDataPtr, cmailGameName), XtRString, "" },
955 { "alwaysPromoteToQueen", "alwaysPromoteToQueen", XtRBoolean,
956 sizeof(Boolean), XtOffset(AppDataPtr, alwaysPromoteToQueen),
957 XtRImmediate, (XtPointer) False },
958 { "oldSaveStyle", "oldSaveStyle", XtRBoolean,
959 sizeof(Boolean), XtOffset(AppDataPtr, oldSaveStyle),
960 XtRImmediate, (XtPointer) False },
961 { "quietPlay", "quietPlay", XtRBoolean,
962 sizeof(Boolean), XtOffset(AppDataPtr, quietPlay),
963 XtRImmediate, (XtPointer) False },
964 { "titleInWindow", "titleInWindow", XtRBoolean,
965 sizeof(Boolean), XtOffset(AppDataPtr, titleInWindow),
966 XtRImmediate, (XtPointer) False },
967 { "localLineEditing", "localLineEditing", XtRBoolean,
968 sizeof(Boolean), XtOffset(AppDataPtr, localLineEditing),
969 XtRImmediate, (XtPointer) True }, /* not implemented, must be True */
971 { "zippyTalk", "zippyTalk", XtRBoolean,
972 sizeof(Boolean), XtOffset(AppDataPtr, zippyTalk),
973 XtRImmediate, (XtPointer) ZIPPY_TALK },
974 { "zippyPlay", "zippyPlay", XtRBoolean,
975 sizeof(Boolean), XtOffset(AppDataPtr, zippyPlay),
976 XtRImmediate, (XtPointer) ZIPPY_PLAY },
977 { "zippyLines", "zippyLines", XtRString, sizeof(String),
978 XtOffset(AppDataPtr, zippyLines), XtRString, ZIPPY_LINES },
979 { "zippyPinhead", "zippyPinhead", XtRString, sizeof(String),
980 XtOffset(AppDataPtr, zippyPinhead), XtRString, ZIPPY_PINHEAD },
981 { "zippyPassword", "zippyPassword", XtRString, sizeof(String),
982 XtOffset(AppDataPtr, zippyPassword), XtRString, ZIPPY_PASSWORD },
983 { "zippyPassword2", "zippyPassword2", XtRString, sizeof(String),
984 XtOffset(AppDataPtr, zippyPassword2), XtRString, ZIPPY_PASSWORD2 },
985 { "zippyWrongPassword", "zippyWrongPassword", XtRString, sizeof(String),
986 XtOffset(AppDataPtr, zippyWrongPassword), XtRString,
987 ZIPPY_WRONG_PASSWORD },
988 { "zippyAcceptOnly", "zippyAcceptOnly", XtRString, sizeof(String),
989 XtOffset(AppDataPtr, zippyAcceptOnly), XtRString, ZIPPY_ACCEPT_ONLY },
990 { "zippyUseI", "zippyUseI", XtRBoolean,
991 sizeof(Boolean), XtOffset(AppDataPtr, zippyUseI),
992 XtRImmediate, (XtPointer) ZIPPY_USE_I },
993 { "zippyBughouse", "zippyBughouse", XtRInt,
994 sizeof(int), XtOffset(AppDataPtr, zippyBughouse),
995 XtRImmediate, (XtPointer) ZIPPY_BUGHOUSE },
996 { "zippyNoplayCrafty", "zippyNoplayCrafty", XtRBoolean,
997 sizeof(Boolean), XtOffset(AppDataPtr, zippyNoplayCrafty),
998 XtRImmediate, (XtPointer) ZIPPY_NOPLAY_CRAFTY },
999 { "zippyGameEnd", "zippyGameEnd", XtRString, sizeof(String),
1000 XtOffset(AppDataPtr, zippyGameEnd), XtRString, ZIPPY_GAME_END },
1001 { "zippyGameStart", "zippyGameStart", XtRString, sizeof(String),
1002 XtOffset(AppDataPtr, zippyGameStart), XtRString, ZIPPY_GAME_START },
1003 { "zippyAdjourn", "zippyAdjourn", XtRBoolean,
1004 sizeof(Boolean), XtOffset(AppDataPtr, zippyAdjourn),
1005 XtRImmediate, (XtPointer) ZIPPY_ADJOURN },
1006 { "zippyAbort", "zippyAbort", XtRBoolean,
1007 sizeof(Boolean), XtOffset(AppDataPtr, zippyAbort),
1008 XtRImmediate, (XtPointer) ZIPPY_ABORT },
1009 { "zippyVariants", "zippyVariants", XtRString, sizeof(String),
1010 XtOffset(AppDataPtr, zippyVariants), XtRString, ZIPPY_VARIANTS },
1011 { "zippyMaxGames", "zippyMaxGames", XtRInt, sizeof(int),
1012 XtOffset(AppDataPtr, zippyMaxGames), XtRImmediate,
1013 (XtPointer) ZIPPY_MAX_GAMES },
1014 { "zippyReplayTimeout", "zippyReplayTimeout", XtRInt, sizeof(int),
1015 XtOffset(AppDataPtr, zippyReplayTimeout), XtRImmediate,
1016 (XtPointer) ZIPPY_REPLAY_TIMEOUT },
1018 { "flashCount", "flashCount", XtRInt, sizeof(int),
1019 XtOffset(AppDataPtr, flashCount), XtRImmediate,
1020 (XtPointer) FLASH_COUNT },
1021 { "flashRate", "flashRate", XtRInt, sizeof(int),
1022 XtOffset(AppDataPtr, flashRate), XtRImmediate,
1023 (XtPointer) FLASH_RATE },
1024 { "pixmapDirectory", "pixmapDirectory", XtRString,
1025 sizeof(String), XtOffset(AppDataPtr, pixmapDirectory),
1027 { "msLoginDelay", "msLoginDelay", XtRInt, sizeof(int),
1028 XtOffset(AppDataPtr, msLoginDelay), XtRImmediate,
1029 (XtPointer) MS_LOGIN_DELAY },
1030 { "colorizeMessages", "colorizeMessages", XtRBoolean,
1031 sizeof(Boolean), XtOffset(AppDataPtr, colorize),
1032 XtRImmediate, (XtPointer) False },
1033 { "colorShout", "colorShout", XtRString,
1034 sizeof(String), XtOffset(AppDataPtr, colorShout),
1035 XtRString, COLOR_SHOUT },
1036 { "colorSShout", "colorSShout", XtRString,
1037 sizeof(String), XtOffset(AppDataPtr, colorSShout),
1038 XtRString, COLOR_SSHOUT },
1039 { "colorChannel1", "colorChannel1", XtRString,
1040 sizeof(String), XtOffset(AppDataPtr, colorChannel1),
1041 XtRString, COLOR_CHANNEL1 },
1042 { "colorChannel", "colorChannel", XtRString,
1043 sizeof(String), XtOffset(AppDataPtr, colorChannel),
1044 XtRString, COLOR_CHANNEL },
1045 { "colorKibitz", "colorKibitz", XtRString,
1046 sizeof(String), XtOffset(AppDataPtr, colorKibitz),
1047 XtRString, COLOR_KIBITZ },
1048 { "colorTell", "colorTell", XtRString,
1049 sizeof(String), XtOffset(AppDataPtr, colorTell),
1050 XtRString, COLOR_TELL },
1051 { "colorChallenge", "colorChallenge", XtRString,
1052 sizeof(String), XtOffset(AppDataPtr, colorChallenge),
1053 XtRString, COLOR_CHALLENGE },
1054 { "colorRequest", "colorRequest", XtRString,
1055 sizeof(String), XtOffset(AppDataPtr, colorRequest),
1056 XtRString, COLOR_REQUEST },
1057 { "colorSeek", "colorSeek", XtRString,
1058 sizeof(String), XtOffset(AppDataPtr, colorSeek),
1059 XtRString, COLOR_SEEK },
1060 { "colorNormal", "colorNormal", XtRString,
1061 sizeof(String), XtOffset(AppDataPtr, colorNormal),
1062 XtRString, COLOR_NORMAL },
1063 { "soundProgram", "soundProgram", XtRString,
1064 sizeof(String), XtOffset(AppDataPtr, soundProgram),
1065 XtRString, "play" },
1066 { "soundShout", "soundShout", XtRString,
1067 sizeof(String), XtOffset(AppDataPtr, soundShout),
1069 { "soundSShout", "soundSShout", XtRString,
1070 sizeof(String), XtOffset(AppDataPtr, soundSShout),
1072 { "soundChannel1", "soundChannel1", XtRString,
1073 sizeof(String), XtOffset(AppDataPtr, soundChannel1),
1075 { "soundChannel", "soundChannel", XtRString,
1076 sizeof(String), XtOffset(AppDataPtr, soundChannel),
1078 { "soundKibitz", "soundKibitz", XtRString,
1079 sizeof(String), XtOffset(AppDataPtr, soundKibitz),
1081 { "soundTell", "soundTell", XtRString,
1082 sizeof(String), XtOffset(AppDataPtr, soundTell),
1084 { "soundChallenge", "soundChallenge", XtRString,
1085 sizeof(String), XtOffset(AppDataPtr, soundChallenge),
1087 { "soundRequest", "soundRequest", XtRString,
1088 sizeof(String), XtOffset(AppDataPtr, soundRequest),
1090 { "soundSeek", "soundSeek", XtRString,
1091 sizeof(String), XtOffset(AppDataPtr, soundSeek),
1093 { "soundMove", "soundMove", XtRString,
1094 sizeof(String), XtOffset(AppDataPtr, soundMove),
1096 { "soundIcsWin", "soundIcsWin", XtRString,
1097 sizeof(String), XtOffset(AppDataPtr, soundIcsWin),
1099 { "soundIcsLoss", "soundIcsLoss", XtRString,
1100 sizeof(String), XtOffset(AppDataPtr, soundIcsLoss),
1102 { "soundIcsDraw", "soundIcsDraw", XtRString,
1103 sizeof(String), XtOffset(AppDataPtr, soundIcsDraw),
1105 { "soundIcsUnfinished", "soundIcsUnfinished", XtRString,
1106 sizeof(String), XtOffset(AppDataPtr, soundIcsUnfinished),
1108 { "soundIcsAlarm", "soundIcsAlarm", XtRString,
1109 sizeof(String), XtOffset(AppDataPtr, soundIcsAlarm),
1111 { "reuseFirst", "reuseFirst", XtRBoolean,
1112 sizeof(Boolean), XtOffset(AppDataPtr, reuseFirst),
1113 XtRImmediate, (XtPointer) True },
1114 { "reuseSecond", "reuseSecond", XtRBoolean,
1115 sizeof(Boolean), XtOffset(AppDataPtr, reuseSecond),
1116 XtRImmediate, (XtPointer) True },
1117 { "animateDragging", "animateDragging", XtRBoolean,
1118 sizeof(Boolean), XtOffset(AppDataPtr, animateDragging),
1119 XtRImmediate, (XtPointer) True },
1120 { "animateMoving", "animateMoving", XtRBoolean,
1121 sizeof(Boolean), XtOffset(AppDataPtr, animate),
1122 XtRImmediate, (XtPointer) True },
1123 { "animateSpeed", "animateSpeed", XtRInt,
1124 sizeof(int), XtOffset(AppDataPtr, animSpeed),
1125 XtRImmediate, (XtPointer)10 },
1126 { "popupExitMessage", "popupExitMessage", XtRBoolean,
1127 sizeof(Boolean), XtOffset(AppDataPtr, popupExitMessage),
1128 XtRImmediate, (XtPointer) True },
1129 { "popupMoveErrors", "popupMoveErrors", XtRBoolean,
1130 sizeof(Boolean), XtOffset(AppDataPtr, popupMoveErrors),
1131 XtRImmediate, (XtPointer) False },
1132 { "fontSizeTolerance", "fontSizeTolerance", XtRInt,
1133 sizeof(int), XtOffset(AppDataPtr, fontSizeTolerance),
1134 XtRImmediate, (XtPointer)4 },
1135 { "initialMode", "initialMode", XtRString,
1136 sizeof(String), XtOffset(AppDataPtr, initialMode),
1137 XtRImmediate, (XtPointer) "" },
1138 { "variant", "variant", XtRString,
1139 sizeof(String), XtOffset(AppDataPtr, variant),
1140 XtRImmediate, (XtPointer) "normal" },
1141 { "firstProtocolVersion", "firstProtocolVersion", XtRInt,
1142 sizeof(int), XtOffset(AppDataPtr, firstProtocolVersion),
1143 XtRImmediate, (XtPointer)PROTOVER },
1144 { "secondProtocolVersion", "secondProtocolVersion", XtRInt,
1145 sizeof(int), XtOffset(AppDataPtr, secondProtocolVersion),
1146 XtRImmediate, (XtPointer)PROTOVER },
1147 { "showButtonBar", "showButtonBar", XtRBoolean,
1148 sizeof(Boolean), XtOffset(AppDataPtr, showButtonBar),
1149 XtRImmediate, (XtPointer) True },
1152 XrmOptionDescRec shellOptions[] = {
1153 { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
1154 { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
1155 { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
1156 { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
1157 { "-highlightSquareColor", "highlightSquareColor", XrmoptionSepArg, NULL },
1158 { "-premoveHighlightColor", "premoveHighlightColor", XrmoptionSepArg,NULL},
1159 { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
1160 { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
1161 { "-timeIncrement", "timeIncrement", XrmoptionSepArg, NULL },
1162 { "-inc", "timeIncrement", XrmoptionSepArg, NULL },
1163 { "-initString", "initString", XrmoptionSepArg, NULL },
1164 { "-firstInitString", "initString", XrmoptionSepArg, NULL },
1165 { "-secondInitString", "secondInitString", XrmoptionSepArg, NULL },
1166 { "-firstComputerString", "firstComputerString", XrmoptionSepArg, NULL },
1167 { "-secondComputerString", "secondComputerString", XrmoptionSepArg, NULL },
1168 { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
1169 { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
1170 { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
1171 { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
1172 { "-firstPlaysBlack", "firstPlaysBlack", XrmoptionSepArg, NULL },
1173 { "-fb", "firstPlaysBlack", XrmoptionNoArg, "True" },
1174 { "-xfb", "firstPlaysBlack", XrmoptionNoArg, "False" },
1175 { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
1176 { "-ncp", "noChessProgram", XrmoptionNoArg, "True" },
1177 { "-xncp", "noChessProgram", XrmoptionNoArg, "False" },
1178 { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
1179 { "-fh", "firstHost", XrmoptionSepArg, NULL },
1180 { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
1181 { "-sh", "secondHost", XrmoptionSepArg, NULL },
1182 { "-firstDirectory", "firstDirectory", XrmoptionSepArg, NULL },
1183 { "-fd", "firstDirectory", XrmoptionSepArg, NULL },
1184 { "-secondDirectory", "secondDirectory", XrmoptionSepArg, NULL },
1185 { "-sd", "secondDirectory", XrmoptionSepArg, NULL },
1186 { "-bitmapDirectory", "bitmapDirectory", XrmoptionSepArg, NULL },
1187 { "-bm", "bitmapDirectory", XrmoptionSepArg, NULL },
1188 { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
1189 { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
1190 { "-remoteUser", "remoteUser", XrmoptionSepArg, NULL },
1191 { "-ruser", "remoteUser", XrmoptionSepArg, NULL },
1192 { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
1193 { "-td", "timeDelay", XrmoptionSepArg, NULL },
1194 { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
1195 { "-tc", "timeControl", XrmoptionSepArg, NULL },
1196 { "-internetChessServerMode", "internetChessServerMode",
1197 XrmoptionSepArg, NULL },
1198 { "-ics", "internetChessServerMode", XrmoptionNoArg, "True" },
1199 { "-xics", "internetChessServerMode", XrmoptionNoArg, "False" },
1200 { "-internetChessServerHost", "internetChessServerHost",
1201 XrmoptionSepArg, NULL },
1202 { "-icshost", "internetChessServerHost", XrmoptionSepArg, NULL },
1203 { "-internetChessServerPort", "internetChessServerPort",
1204 XrmoptionSepArg, NULL },
1205 { "-icsport", "internetChessServerPort", XrmoptionSepArg, NULL },
1206 { "-internetChessServerCommPort", "internetChessServerCommPort",
1207 XrmoptionSepArg, NULL },
1208 { "-icscomm", "internetChessServerCommPort", XrmoptionSepArg, NULL },
1209 { "-internetChessServerLogonScript", "internetChessServerLogonScript",
1210 XrmoptionSepArg, NULL },
1211 { "-icslogon", "internetChessServerLogonScript", XrmoptionSepArg, NULL },
1212 { "-internetChessServerHelper", "internetChessServerHelper",
1213 XrmoptionSepArg, NULL },
1214 { "-icshelper", "internetChessServerHelper", XrmoptionSepArg, NULL },
1215 { "-internetChessServerInputBox", "internetChessServerInputBox",
1216 XrmoptionSepArg, NULL },
1217 { "-icsinput", "internetChessServerInputBox", XrmoptionNoArg, "True" },
1218 { "-xicsinput", "internetChessServerInputBox", XrmoptionNoArg, "False" },
1219 { "-icsAlarm", "icsAlarm", XrmoptionSepArg, NULL },
1220 { "-alarm", "icsAlarm", XrmoptionNoArg, "True" },
1221 { "-xalarm", "icsAlarm", XrmoptionNoArg, "False" },
1222 { "-icsAlarmTime", "icsAlarmTime", XrmoptionSepArg, NULL },
1223 { "-useTelnet", "useTelnet", XrmoptionSepArg, NULL },
1224 { "-telnet", "useTelnet", XrmoptionNoArg, "True" },
1225 { "-xtelnet", "useTelnet", XrmoptionNoArg, "False" },
1226 { "-telnetProgram", "telnetProgram", XrmoptionSepArg, NULL },
1227 { "-gateway", "gateway", XrmoptionSepArg, NULL },
1228 { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
1229 { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
1230 { "-loadGameIndex", "loadGameIndex", XrmoptionSepArg, NULL },
1231 { "-lgi", "loadGameIndex", XrmoptionSepArg, NULL },
1232 { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
1233 { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
1234 { "-autoSaveGames", "autoSaveGames", XrmoptionSepArg, NULL },
1235 { "-autosave", "autoSaveGames", XrmoptionNoArg, "True" },
1236 { "-xautosave", "autoSaveGames", XrmoptionNoArg, "False" },
1237 { "-autoRaiseBoard", "autoRaiseBoard", XrmoptionSepArg, NULL },
1238 { "-autoraise", "autoRaiseBoard", XrmoptionNoArg, "True" },
1239 { "-xautoraise", "autoRaiseBoard", XrmoptionNoArg, "False" },
1240 { "-blindfold", "blindfold", XrmoptionSepArg, NULL },
1241 { "-blind", "blindfold", XrmoptionNoArg, "True" },
1242 { "-xblind", "blindfold", XrmoptionNoArg, "False" },
1243 { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
1244 { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
1245 { "-loadPositionIndex", "loadPositionIndex", XrmoptionSepArg, NULL },
1246 { "-lpi", "loadPositionIndex", XrmoptionSepArg, NULL },
1247 { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
1248 { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
1249 { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
1250 { "-mm", "matchMode", XrmoptionNoArg, "True" },
1251 { "-xmm", "matchMode", XrmoptionNoArg, "False" },
1252 { "-matchGames", "matchGames", XrmoptionSepArg, NULL },
1253 { "-mg", "matchGames", XrmoptionSepArg, NULL },
1254 { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
1255 { "-mono", "monoMode", XrmoptionNoArg, "True" },
1256 { "-xmono", "monoMode", XrmoptionNoArg, "False" },
1257 { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
1258 { "-debug", "debugMode", XrmoptionNoArg, "True" },
1259 { "-xdebug", "debugMode", XrmoptionNoArg, "False" },
1260 { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
1261 { "-clock", "clockMode", XrmoptionNoArg, "True" },
1262 { "-xclock", "clockMode", XrmoptionNoArg, "False" },
1263 { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
1264 { "-size", "boardSize", XrmoptionSepArg, NULL },
1265 { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
1266 { "-st", "searchTime", XrmoptionSepArg, NULL },
1267 { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
1268 { "-depth", "searchDepth", XrmoptionSepArg, NULL },
1269 { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
1270 { "-coords", "showCoords", XrmoptionNoArg, "True" },
1271 { "-xcoords", "showCoords", XrmoptionNoArg, "False" },
1273 { "-showJail", "showJail", XrmoptionSepArg, NULL },
1274 { "-jail", "showJail", XrmoptionNoArg, "1" },
1275 { "-sidejail", "showJail", XrmoptionNoArg, "2" },
1276 { "-xjail", "showJail", XrmoptionNoArg, "0" },
1278 { "-showThinking", "showThinking", XrmoptionSepArg, NULL },
1279 { "-thinking", "showThinking", XrmoptionNoArg, "True" },
1280 { "-xthinking", "showThinking", XrmoptionNoArg, "False" },
1281 { "-ponderNextMove", "ponderNextMove", XrmoptionSepArg, NULL },
1282 { "-ponder", "ponderNextMove", XrmoptionNoArg, "True" },
1283 { "-xponder", "ponderNextMove", XrmoptionNoArg, "False" },
1284 { "-periodicUpdates", "periodicUpdates", XrmoptionSepArg, NULL },
1285 { "-periodic", "periodicUpdates", XrmoptionNoArg, "True" },
1286 { "-xperiodic", "periodicUpdates", XrmoptionNoArg, "False" },
1287 { "-clockFont", "clockFont", XrmoptionSepArg, NULL },
1288 { "-coordFont", "coordFont", XrmoptionSepArg, NULL },
1289 { "-font", "font", XrmoptionSepArg, NULL },
1290 { "-ringBellAfterMoves", "ringBellAfterMoves", XrmoptionSepArg, NULL },
1291 { "-bell", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1292 { "-xbell", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1293 { "-movesound", "ringBellAfterMoves", XrmoptionNoArg, "True" },
1294 { "-xmovesound", "ringBellAfterMoves", XrmoptionNoArg, "False" },
1295 { "-autoCallFlag", "autoCallFlag", XrmoptionSepArg, NULL },
1296 { "-autoflag", "autoCallFlag", XrmoptionNoArg, "True" },
1297 { "-xautoflag", "autoCallFlag", XrmoptionNoArg, "False" },
1298 { "-autoFlipView", "autoFlipView", XrmoptionSepArg, NULL },
1299 { "-autoflip", "autoFlipView", XrmoptionNoArg, "True" },
1300 { "-xautoflip", "autoFlipView", XrmoptionNoArg, "False" },
1301 { "-autoObserve", "autoObserve", XrmoptionSepArg, NULL },
1302 { "-autobs", "autoObserve", XrmoptionNoArg, "True" },
1303 { "-xautobs", "autoObserve", XrmoptionNoArg, "False" },
1304 { "-autoComment", "autoComment", XrmoptionSepArg, NULL },
1305 { "-autocomm", "autoComment", XrmoptionNoArg, "True" },
1306 { "-xautocomm", "autoComment", XrmoptionNoArg, "False" },
1307 { "-getMoveList", "getMoveList", XrmoptionSepArg, NULL },
1308 { "-moves", "getMoveList", XrmoptionNoArg, "True" },
1309 { "-xmoves", "getMoveList", XrmoptionNoArg, "False" },
1311 { "-highlightDragging", "highlightDragging", XrmoptionSepArg, NULL },
1312 { "-highdrag", "highlightDragging", XrmoptionNoArg, "True" },
1313 { "-xhighdrag", "highlightDragging", XrmoptionNoArg, "False" },
1315 { "-highlightLastMove", "highlightLastMove", XrmoptionSepArg, NULL },
1316 { "-highlight", "highlightLastMove", XrmoptionNoArg, "True" },
1317 { "-xhighlight", "highlightLastMove", XrmoptionNoArg, "False" },
1318 { "-premove", "premove", XrmoptionSepArg, NULL },
1319 { "-pre", "premove", XrmoptionNoArg, "True" },
1320 { "-xpre", "premove", XrmoptionNoArg, "False" },
1321 { "-testLegality", "testLegality", XrmoptionSepArg, NULL },
1322 { "-legal", "testLegality", XrmoptionNoArg, "True" },
1323 { "-xlegal", "testLegality", XrmoptionNoArg, "False" },
1324 { "-flipView", "flipView", XrmoptionSepArg, NULL },
1325 { "-flip", "flipView", XrmoptionNoArg, "True" },
1326 { "-xflip", "flipView", XrmoptionNoArg, "False" },
1327 { "-cmail", "cmailGameName", XrmoptionSepArg, NULL },
1328 { "-alwaysPromoteToQueen", "alwaysPromoteToQueen",
1329 XrmoptionSepArg, NULL },
1330 { "-queen", "alwaysPromoteToQueen", XrmoptionNoArg, "True" },
1331 { "-xqueen", "alwaysPromoteToQueen", XrmoptionNoArg, "False" },
1332 { "-oldSaveStyle", "oldSaveStyle", XrmoptionSepArg, NULL },
1333 { "-oldsave", "oldSaveStyle", XrmoptionNoArg, "True" },
1334 { "-xoldsave", "oldSaveStyle", XrmoptionNoArg, "False" },
1335 { "-quietPlay", "quietPlay", XrmoptionSepArg, NULL },
1336 { "-quiet", "quietPlay", XrmoptionNoArg, "True" },
1337 { "-xquiet", "quietPlay", XrmoptionNoArg, "False" },
1338 { "-titleInWindow", "titleInWindow", XrmoptionSepArg, NULL },
1339 { "-title", "titleInWindow", XrmoptionNoArg, "True" },
1340 { "-xtitle", "titleInWindow", XrmoptionNoArg, "False" },
1342 { "-zippyTalk", "zippyTalk", XrmoptionSepArg, NULL },
1343 { "-zt", "zippyTalk", XrmoptionNoArg, "True" },
1344 { "-xzt", "zippyTalk", XrmoptionNoArg, "False" },
1345 { "-zippyPlay", "zippyPlay", XrmoptionSepArg, NULL },
1346 { "-zp", "zippyPlay", XrmoptionNoArg, "True" },
1347 { "-xzp", "zippyPlay", XrmoptionNoArg, "False" },
1348 { "-zippyLines", "zippyLines", XrmoptionSepArg, NULL },
1349 { "-zippyPinhead", "zippyPinhead", XrmoptionSepArg, NULL },
1350 { "-zippyPassword", "zippyPassword", XrmoptionSepArg, NULL },
1351 { "-zippyPassword2", "zippyPassword2", XrmoptionSepArg, NULL },
1352 { "-zippyWrongPassword", "zippyWrongPassword", XrmoptionSepArg, NULL },
1353 { "-zippyAcceptOnly", "zippyAcceptOnly", XrmoptionSepArg, NULL },
1354 { "-zippyUseI", "zippyUseI", XrmoptionSepArg, NULL },
1355 { "-zui", "zippyUseI", XrmoptionNoArg, "True" },
1356 { "-xzui", "zippyUseI", XrmoptionNoArg, "False" },
1357 { "-zippyBughouse", "zippyBughouse", XrmoptionSepArg, NULL },
1358 { "-zippyNoplayCrafty", "zippyNoplayCrafty", XrmoptionSepArg, NULL },
1359 { "-znc", "zippyNoplayCrafty", XrmoptionNoArg, "True" },
1360 { "-xznc", "zippyNoplayCrafty", XrmoptionNoArg, "False" },
1361 { "-zippyGameEnd", "zippyGameEnd", XrmoptionSepArg, NULL },
1362 { "-zippyGameStart", "zippyGameStart", XrmoptionSepArg, NULL },
1363 { "-zippyAdjourn", "zippyAdjourn", XrmoptionSepArg, NULL },
1364 { "-zadj", "zippyAdjourn", XrmoptionNoArg, "True" },
1365 { "-xzadj", "zippyAdjourn", XrmoptionNoArg, "False" },
1366 { "-zippyAbort", "zippyAbort", XrmoptionSepArg, NULL },
1367 { "-zab", "zippyAbort", XrmoptionNoArg, "True" },
1368 { "-xzab", "zippyAbort", XrmoptionNoArg, "False" },
1369 { "-zippyVariants", "zippyVariants", XrmoptionSepArg, NULL },
1370 { "-zippyMaxGames", "zippyMaxGames", XrmoptionSepArg, NULL },
1371 { "-zippyReplayTimeout", "zippyReplayTimeout", XrmoptionSepArg, NULL },
1373 { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
1374 { "-flash", "flashCount", XrmoptionNoArg, "3" },
1375 { "-xflash", "flashCount", XrmoptionNoArg, "0" },
1376 { "-flashRate", "flashRate", XrmoptionSepArg, NULL },
1377 { "-pixmapDirectory", "pixmapDirectory", XrmoptionSepArg, NULL },
1378 { "-msLoginDelay", "msLoginDelay", XrmoptionSepArg, NULL },
1379 { "-pixmap", "pixmapDirectory", XrmoptionSepArg, NULL },
1380 { "-colorizeMessages", "colorizeMessages", XrmoptionSepArg, NULL },
1381 { "-colorize", "colorizeMessages", XrmoptionNoArg, "True" },
1382 { "-xcolorize", "colorizeMessages", XrmoptionNoArg, "False" },
1383 { "-colorShout", "colorShout", XrmoptionSepArg, NULL },
1384 { "-colorSShout", "colorSShout", XrmoptionSepArg, NULL },
1385 { "-colorCShout", "colorSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1386 { "-colorChannel1", "colorChannel1", XrmoptionSepArg, NULL },
1387 { "-colorChannel", "colorChannel", XrmoptionSepArg, NULL },
1388 { "-colorKibitz", "colorKibitz", XrmoptionSepArg, NULL },
1389 { "-colorTell", "colorTell", XrmoptionSepArg, NULL },
1390 { "-colorChallenge", "colorChallenge", XrmoptionSepArg, NULL },
1391 { "-colorRequest", "colorRequest", XrmoptionSepArg, NULL },
1392 { "-colorSeek", "colorSeek", XrmoptionSepArg, NULL },
1393 { "-colorNormal", "colorNormal", XrmoptionSepArg, NULL },
1394 { "-soundProgram", "soundProgram", XrmoptionSepArg, NULL },
1395 { "-soundShout", "soundShout", XrmoptionSepArg, NULL },
1396 { "-soundSShout", "soundSShout", XrmoptionSepArg, NULL },
1397 { "-soundCShout", "soundSShout", XrmoptionSepArg, NULL }, /*FICS name*/
1398 { "-soundChannel1", "soundChannel1", XrmoptionSepArg, NULL },
1399 { "-soundChannel", "soundChannel", XrmoptionSepArg, NULL },
1400 { "-soundKibitz", "soundKibitz", XrmoptionSepArg, NULL },
1401 { "-soundTell", "soundTell", XrmoptionSepArg, NULL },
1402 { "-soundChallenge", "soundChallenge", XrmoptionSepArg, NULL },
1403 { "-soundRequest", "soundRequest", XrmoptionSepArg, NULL },
1404 { "-soundSeek", "soundSeek", XrmoptionSepArg, NULL },
1405 { "-soundMove", "soundMove", XrmoptionSepArg, NULL },
1406 { "-soundIcsWin", "soundIcsWin", XrmoptionSepArg, NULL },
1407 { "-soundIcsLoss", "soundIcsLoss", XrmoptionSepArg, NULL },
1408 { "-soundIcsDraw", "soundIcsDraw", XrmoptionSepArg, NULL },
1409 { "-soundIcsUnfinished", "soundIcsUnfinished", XrmoptionSepArg, NULL },
1410 { "-soundIcsAlarm", "soundIcsAlarm", XrmoptionSepArg, NULL },
1411 { "-reuseFirst", "reuseFirst", XrmoptionSepArg, NULL },
1412 { "-reuseChessPrograms", "reuseFirst", XrmoptionSepArg, NULL }, /*compat*/
1413 { "-reuse", "reuseFirst", XrmoptionNoArg, "True" },
1414 { "-xreuse", "reuseFirst", XrmoptionNoArg, "False" },
1415 { "-reuseSecond", "reuseSecond", XrmoptionSepArg, NULL },
1416 { "-reuse2", "reuseSecond", XrmoptionNoArg, "True" },
1417 { "-xreuse2", "reuseSecond", XrmoptionNoArg, "False" },
1418 { "-animateMoving", "animateMoving", XrmoptionSepArg, NULL },
1419 { "-animate", "animateMoving", XrmoptionNoArg, "True" },
1420 { "-xanimate", "animateMoving", XrmoptionNoArg, "False" },
1421 { "-animateDragging", "animateDragging", XrmoptionSepArg, NULL },
1422 { "-drag", "animateDragging", XrmoptionNoArg, "True" },
1423 { "-xdrag", "animateDragging", XrmoptionNoArg, "False" },
1424 { "-animateSpeed", "animateSpeed", XrmoptionSepArg, NULL },
1425 { "-popupExitMessage", "popupExitMessage", XrmoptionSepArg, NULL },
1426 { "-exit", "popupExitMessage", XrmoptionNoArg, "True" },
1427 { "-xexit", "popupExitMessage", XrmoptionNoArg, "False" },
1428 { "-popupMoveErrors", "popupMoveErrors", XrmoptionSepArg, NULL },
1429 { "-popup", "popupMoveErrors", XrmoptionNoArg, "True" },
1430 { "-xpopup", "popupMoveErrors", XrmoptionNoArg, "False" },
1431 { "-fontSizeTolerance", "fontSizeTolerance", XrmoptionSepArg, NULL },
1432 { "-initialMode", "initialMode", XrmoptionSepArg, NULL },
1433 { "-mode", "initialMode", XrmoptionSepArg, NULL },
1434 { "-variant", "variant", XrmoptionSepArg, NULL },
1435 { "-firstProtocolVersion", "firstProtocolVersion", XrmoptionSepArg, NULL },
1436 { "-secondProtocolVersion","secondProtocolVersion",XrmoptionSepArg, NULL },
1437 { "-showButtonBar", "showButtonBar", XrmoptionSepArg, NULL },
1438 { "-buttons", "showButtonBar", XrmoptionNoArg, "True" },
1439 { "-xbuttons", "showButtonBar", XrmoptionNoArg, "False" },
1443 XtActionsRec boardActions[] = {
1444 { "DrawPosition", DrawPositionProc },
1445 { "HandleUserMove", HandleUserMove },
1446 { "AnimateUserMove", AnimateUserMove },
1447 { "FileNameAction", FileNameAction },
1448 { "AskQuestionProc", AskQuestionProc },
1449 { "AskQuestionReplyAction", AskQuestionReplyAction },
1450 { "PieceMenuPopup", PieceMenuPopup },
1451 { "WhiteClock", WhiteClock },
1452 { "BlackClock", BlackClock },
1453 { "Iconify", Iconify },
1454 { "ResetProc", ResetProc },
1455 { "LoadGameProc", LoadGameProc },
1456 { "LoadNextGameProc", LoadNextGameProc },
1457 { "LoadPrevGameProc", LoadPrevGameProc },
1458 { "LoadSelectedProc", LoadSelectedProc },
1459 { "ReloadGameProc", ReloadGameProc },
1460 { "LoadPositionProc", LoadPositionProc },
1461 { "LoadNextPositionProc", LoadNextPositionProc },
1462 { "LoadPrevPositionProc", LoadPrevPositionProc },
1463 { "ReloadPositionProc", ReloadPositionProc },
1464 { "CopyPositionProc", CopyPositionProc },
1465 { "PastePositionProc", PastePositionProc },
1466 { "CopyGameProc", CopyGameProc },
1467 { "PasteGameProc", PasteGameProc },
1468 { "SaveGameProc", SaveGameProc },
1469 { "SavePositionProc", SavePositionProc },
1470 { "MailMoveProc", MailMoveProc },
1471 { "ReloadCmailMsgProc", ReloadCmailMsgProc },
1472 { "QuitProc", QuitProc },
1473 { "MachineWhiteProc", MachineWhiteProc },
1474 { "MachineBlackProc", MachineBlackProc },
1475 { "AnalysisModeProc", AnalyzeModeProc },
1476 { "AnalyzeFileProc", AnalyzeFileProc },
1477 { "TwoMachinesProc", TwoMachinesProc },
1478 { "IcsClientProc", IcsClientProc },
1479 { "EditGameProc", EditGameProc },
1480 { "EditPositionProc", EditPositionProc },
1481 { "TrainingProc", EditPositionProc },
1482 { "ShowGameListProc", ShowGameListProc },
1483 { "ShowMoveListProc", HistoryShowProc},
1484 { "EditTagsProc", EditCommentProc },
1485 { "EditCommentProc", EditCommentProc },
1486 { "IcsAlarmProc", IcsAlarmProc },
1487 { "IcsInputBoxProc", IcsInputBoxProc },
1488 { "PauseProc", PauseProc },
1489 { "AcceptProc", AcceptProc },
1490 { "DeclineProc", DeclineProc },
1491 { "RematchProc", RematchProc },
1492 { "CallFlagProc", CallFlagProc },
1493 { "DrawProc", DrawProc },
1494 { "AdjournProc", AdjournProc },
1495 { "AbortProc", AbortProc },
1496 { "ResignProc", ResignProc },
1497 { "EnterKeyProc", EnterKeyProc },
1498 { "StopObservingProc", StopObservingProc },
1499 { "StopExaminingProc", StopExaminingProc },
1500 { "BackwardProc", BackwardProc },
1501 { "ForwardProc", ForwardProc },
1502 { "ToStartProc", ToStartProc },
1503 { "ToEndProc", ToEndProc },
1504 { "RevertProc", RevertProc },
1505 { "TruncateGameProc", TruncateGameProc },
1506 { "MoveNowProc", MoveNowProc },
1507 { "RetractMoveProc", RetractMoveProc },
1508 { "AlwaysQueenProc", AlwaysQueenProc },
1509 { "AnimateDraggingProc", AnimateDraggingProc },
1510 { "AnimateMovingProc", AnimateMovingProc },
1511 { "AutoflagProc", AutoflagProc },
1512 { "AutoflipProc", AutoflipProc },
1513 { "AutobsProc", AutobsProc },
1514 { "AutoraiseProc", AutoraiseProc },
1515 { "AutosaveProc", AutosaveProc },
1516 { "BlindfoldProc", BlindfoldProc },
1517 { "FlashMovesProc", FlashMovesProc },
1518 { "FlipViewProc", FlipViewProc },
1519 { "GetMoveListProc", GetMoveListProc },
1521 { "HighlightDraggingProc", HighlightDraggingProc },
1523 { "HighlightLastMoveProc", HighlightLastMoveProc },
1524 { "IcsAlarmProc", IcsAlarmProc },
1525 { "MoveSoundProc", MoveSoundProc },
1526 { "OldSaveStyleProc", OldSaveStyleProc },
1527 { "PeriodicUpdatesProc", PeriodicUpdatesProc },
1528 { "PonderNextMoveProc", PonderNextMoveProc },
1529 { "PopupExitMessageProc", PopupExitMessageProc },
1530 { "PopupMoveErrorsProc", PopupMoveErrorsProc },
1531 { "PremoveProc", PremoveProc },
1532 { "QuietPlayProc", QuietPlayProc },
1533 { "ShowCoordsProc", ShowCoordsProc },
1534 { "ShowThinkingProc", ShowThinkingProc },
1535 { "TestLegalityProc", TestLegalityProc },
1536 { "InfoProc", InfoProc },
1537 { "ManProc", ManProc },
1538 { "HintProc", HintProc },
1539 { "BookProc", BookProc },
1540 { "AboutGameProc", AboutGameProc },
1541 { "AboutProc", AboutProc },
1542 { "DebugProc", DebugProc },
1543 { "NothingProc", NothingProc },
1544 { "CommentPopDown", (XtActionProc) CommentPopDown },
1545 { "EditCommentPopDown", (XtActionProc) EditCommentPopDown },
1546 { "TagsPopDown", (XtActionProc) TagsPopDown },
1547 { "ErrorPopDown", (XtActionProc) ErrorPopDown },
1548 { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
1549 { "AnalysisPopDown", (XtActionProc) AnalysisPopDown },
1550 { "FileNamePopDown", (XtActionProc) FileNamePopDown },
1551 { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
1552 { "GameListPopDown", (XtActionProc) GameListPopDown },
1553 { "PromotionPopDown", (XtActionProc) PromotionPopDown },
1554 { "HistoryPopDown", (XtActionProc) HistoryPopDown },
1557 char globalTranslations[] =
1558 ":<Key>R: ResignProc() \n \
1559 :<Key>r: ResetProc() \n \
1560 :<Key>g: LoadGameProc() \n \
1561 :<Key>N: LoadNextGameProc() \n \
1562 :<Key>P: LoadPrevGameProc() \n \
1563 :<Key>Q: QuitProc() \n \
1564 :<Key>F: ToEndProc() \n \
1565 :<Key>f: ForwardProc() \n \
1566 :<Key>B: ToStartProc() \n \
1567 :<Key>b: BackwardProc() \n \
1568 :<Key>p: PauseProc() \n \
1569 :<Key>d: DrawProc() \n \
1570 :<Key>t: CallFlagProc() \n \
1571 :<Key>i: Iconify() \n \
1572 :<Key>c: Iconify() \n \
1573 :<Key>v: FlipViewProc() \n \
1574 <KeyDown>Control_L: BackwardProc() \n \
1575 <KeyUp>Control_L: ForwardProc() \n \
1576 <KeyDown>Control_R: BackwardProc() \n \
1577 <KeyUp>Control_R: ForwardProc() \n \
1578 Shift<Key>1: AskQuestionProc(\"Direct command\",\
1579 \"Send to chess program:\",,1) \n \
1580 Shift<Key>2: AskQuestionProc(\"Direct command\",\
1581 \"Send to second chess program:\",,2) \n";
1583 char boardTranslations[] =
1584 "<Btn1Down>: HandleUserMove() \n \
1585 <Btn1Up>: HandleUserMove() \n \
1586 <Btn1Motion>: AnimateUserMove() \n \
1587 Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
1588 PieceMenuPopup(menuB) \n \
1589 Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
1590 PieceMenuPopup(menuW) \n \
1591 Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
1592 PieceMenuPopup(menuW) \n \
1593 Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
1594 PieceMenuPopup(menuB) \n";
1596 char whiteTranslations[] = "<BtnDown>: WhiteClock()\n";
1597 char blackTranslations[] = "<BtnDown>: BlackClock()\n";
1599 char ICSInputTranslations[] =
1600 "<Key>Return: EnterKeyProc() \n";
1602 String xboardResources[] = {
1603 "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
1604 "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
1605 "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
1610 /* Max possible square size */
1611 #define MAXSQSIZE 256
1613 static int xpm_avail[MAXSQSIZE];
1615 #ifdef HAVE_DIR_STRUCT
1617 /* Extract piece size from filename */
1619 xpm_getsize(name, len, ext)
1630 if ((p=strchr(name, '.')) == NULL ||
1631 StrCaseCmp(p+1, ext) != 0)
1637 while (*p && isdigit(*p))
1644 /* Setup xpm_avail */
1646 xpm_getavail(dirname, ext)
1654 for (i=0; i<MAXSQSIZE; ++i)
1657 if (appData.debugMode)
1658 fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
1660 dir = opendir(dirname);
1663 fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
1664 programName, dirname);
1668 while ((ent=readdir(dir)) != NULL) {
1669 i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
1670 if (i > 0 && i < MAXSQSIZE)
1680 xpm_print_avail(fp, ext)
1686 fprintf(fp, _("Available `%s' sizes:\n"), ext);
1687 for (i=1; i<MAXSQSIZE; ++i) {
1693 /* Return XPM piecesize closest to size */
1695 xpm_closest_to(dirname, size, ext)
1701 int sm_diff = MAXSQSIZE;
1705 xpm_getavail(dirname, ext);
1707 if (appData.debugMode)
1708 xpm_print_avail(stderr, ext);
1710 for (i=1; i<MAXSQSIZE; ++i) {
1713 diff = (diff<0) ? -diff : diff;
1714 if (diff < sm_diff) {
1722 fprintf(stderr, _("Error: No `%s' files!\n"), ext);
1728 #else /* !HAVE_DIR_STRUCT */
1729 /* If we are on a system without a DIR struct, we can't
1730 read the directory, so we can't collect a list of
1731 filenames, etc., so we can't do any size-fitting. */
1733 xpm_closest_to(dirname, size, ext)
1738 fprintf(stderr, _("\
1739 Warning: No DIR structure found on this system --\n\
1740 Unable to autosize for XPM/XIM pieces.\n\
1741 Please report this error to frankm@hiwaay.net.\n\
1742 Include system type & operating system in message.\n"));
1745 #endif /* HAVE_DIR_STRUCT */
1747 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
1748 "magenta", "cyan", "white" };
1752 TextColors textColors[(int)NColorClasses];
1754 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
1756 parse_color(str, which)
1760 char *p, buf[100], *d;
1763 if (strlen(str) > 99) /* watch bounds on buf */
1768 for (i=0; i<which; ++i) {
1775 /* Could be looking at something like:
1777 .. in which case we want to stop on a comma also */
1778 while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
1782 return -1; /* Use default for empty field */
1785 if (which == 2 || isdigit(*p))
1788 while (*p && isalpha(*p))
1793 for (i=0; i<8; ++i) {
1794 if (!StrCaseCmp(buf, cnames[i]))
1795 return which? (i+40) : (i+30);
1797 if (!StrCaseCmp(buf, "default")) return -1;
1799 fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
1804 parse_cpair(cc, str)
1808 if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
1809 fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
1814 /* bg and attr are optional */
1815 textColors[(int)cc].bg = parse_color(str, 1);
1816 if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {
1817 textColors[(int)cc].attr = 0;
1823 /* Arrange to catch delete-window events */
1824 Atom wm_delete_window;
1826 CatchDeleteWindow(Widget w, String procname)
1829 XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
1830 sprintf(buf, "<Message>WM_PROTOCOLS: %s() \n", procname);
1831 XtAugmentTranslations(w, XtParseTranslationTable(buf));
1838 XtSetArg(args[0], XtNiconic, False);
1839 XtSetValues(shellWidget, args, 1);
1841 XtPopup(shellWidget, XtGrabNone); /* Raise if lowered */
1849 int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
1850 XSetWindowAttributes window_attributes;
1852 Dimension timerWidth, boardWidth, w, h, sep, bor, wr, hr;
1853 XrmValue vFrom, vTo;
1854 XtGeometryResult gres;
1857 int forceMono = False;
1859 setbuf(stdout, NULL);
1860 setbuf(stderr, NULL);
1863 programName = strrchr(argv[0], '/');
1864 if (programName == NULL)
1865 programName = argv[0];
1870 XtSetLanguageProc(NULL, NULL, NULL);
1871 bindtextdomain(PRODUCT, LOCALEDIR);
1872 textdomain(PRODUCT);
1876 XtAppInitialize(&appContext, "XBoard", shellOptions,
1877 XtNumber(shellOptions),
1878 &argc, argv, xboardResources, NULL, 0);
1880 fprintf(stderr, _("%s: unrecognized argument %s\n"),
1881 programName, argv[1]);
1885 if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
1888 if (chdir(chessDir) != 0) {
1889 fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
1896 if (p == NULL) p = "/tmp";
1897 i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
1898 gameCopyFilename = (char*) malloc(i);
1899 gamePasteFilename = (char*) malloc(i);
1900 sprintf(gameCopyFilename, "%s/.xboard%05uc.pgn", p, getpid());
1901 sprintf(gamePasteFilename, "%s/.xboard%05up.pgn", p, getpid());
1903 XtGetApplicationResources(shellWidget, (XtPointer) &appData,
1904 clientResources, XtNumber(clientResources),
1908 /* This feature does not work; animation needs a rewrite */
1909 appData.highlightDragging = FALSE;
1913 xDisplay = XtDisplay(shellWidget);
1914 xScreen = DefaultScreen(xDisplay);
1915 wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
1918 * Determine boardSize
1920 if (isdigit(appData.boardSize[0])) {
1921 i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
1922 &lineGap, &clockFontPxlSize, &coordFontPxlSize,
1923 &fontPxlSize, &smallLayout, &tinyLayout);
1925 fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
1926 programName, appData.boardSize);
1930 /* Find some defaults; use the nearest known size */
1931 SizeDefaults *szd, *nearest;
1932 int distance = 99999;
1933 nearest = szd = sizeDefaults;
1934 while (szd->name != NULL) {
1935 if (abs(szd->squareSize - squareSize) < distance) {
1937 distance = abs(szd->squareSize - squareSize);
1938 if (distance == 0) break;
1942 if (i < 2) lineGap = nearest->lineGap;
1943 if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
1944 if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
1945 if (i < 5) fontPxlSize = nearest->fontPxlSize;
1946 if (i < 6) smallLayout = nearest->smallLayout;
1947 if (i < 7) tinyLayout = nearest->tinyLayout;
1950 SizeDefaults *szd = sizeDefaults;
1951 if (*appData.boardSize == NULLCHAR) {
1952 while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
1953 DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
1956 if (szd->name == NULL) szd--;
1958 while (szd->name != NULL &&
1959 StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
1960 if (szd->name == NULL) {
1961 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
1962 programName, appData.boardSize);
1966 squareSize = szd->squareSize;
1967 lineGap = szd->lineGap;
1968 clockFontPxlSize = szd->clockFontPxlSize;
1969 coordFontPxlSize = szd->coordFontPxlSize;
1970 fontPxlSize = szd->fontPxlSize;
1971 smallLayout = szd->smallLayout;
1972 tinyLayout = szd->tinyLayout;
1975 /* Now, using squareSize as a hint, find a good XPM/XIM set size */
1976 if (strlen(appData.pixmapDirectory) > 0) {
1977 p = ExpandPathName(appData.pixmapDirectory);
1979 fprintf(stderr, _("Error expanding path name \"%s\"\n"),
1980 appData.pixmapDirectory);
1983 if (appData.debugMode) {
1984 fprintf(stderr, _("\
1985 XBoard square size (hint): %d\n\
1986 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
1988 squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
1989 if (appData.debugMode) {
1990 fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
1994 boardWidth = lineGap + BOARD_SIZE * (squareSize + lineGap);
1995 if (appData.showJail == 1) {
1996 /* Jail on top and bottom */
1997 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
1998 XtSetArg(boardArgs[2], XtNheight,
1999 boardWidth + 2*(lineGap + squareSize));
2000 } else if (appData.showJail == 2) {
2002 XtSetArg(boardArgs[1], XtNwidth,
2003 boardWidth + 2*(lineGap + squareSize));
2004 XtSetArg(boardArgs[2], XtNheight, boardWidth);
2007 XtSetArg(boardArgs[1], XtNwidth, boardWidth);
2008 XtSetArg(boardArgs[2], XtNheight, boardWidth);
2012 * Determine what fonts to use.
2014 appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
2015 clockFontID = XLoadFont(xDisplay, appData.clockFont);
2016 clockFontStruct = XQueryFont(xDisplay, clockFontID);
2017 appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
2018 coordFontID = XLoadFont(xDisplay, appData.coordFont);
2019 coordFontStruct = XQueryFont(xDisplay, coordFontID);
2020 appData.font = FindFont(appData.font, fontPxlSize);
2022 xdb = XtDatabase(xDisplay);
2023 XrmPutStringResource(&xdb, "*font", appData.font);
2026 * Detect if there are not enough colors available and adapt.
2028 if (DefaultDepth(xDisplay, xScreen) <= 2) {
2029 appData.monoMode = True;
2032 if (!appData.monoMode) {
2033 vFrom.addr = (caddr_t) appData.lightSquareColor;
2034 vFrom.size = strlen(appData.lightSquareColor);
2035 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2036 if (vTo.addr == NULL) {
2037 appData.monoMode = True;
2040 lightSquareColor = *(Pixel *) vTo.addr;
2043 if (!appData.monoMode) {
2044 vFrom.addr = (caddr_t) appData.darkSquareColor;
2045 vFrom.size = strlen(appData.darkSquareColor);
2046 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2047 if (vTo.addr == NULL) {
2048 appData.monoMode = True;
2051 darkSquareColor = *(Pixel *) vTo.addr;
2054 if (!appData.monoMode) {
2055 vFrom.addr = (caddr_t) appData.whitePieceColor;
2056 vFrom.size = strlen(appData.whitePieceColor);
2057 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2058 if (vTo.addr == NULL) {
2059 appData.monoMode = True;
2062 whitePieceColor = *(Pixel *) vTo.addr;
2065 if (!appData.monoMode) {
2066 vFrom.addr = (caddr_t) appData.blackPieceColor;
2067 vFrom.size = strlen(appData.blackPieceColor);
2068 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2069 if (vTo.addr == NULL) {
2070 appData.monoMode = True;
2073 blackPieceColor = *(Pixel *) vTo.addr;
2077 if (!appData.monoMode) {
2078 vFrom.addr = (caddr_t) appData.highlightSquareColor;
2079 vFrom.size = strlen(appData.highlightSquareColor);
2080 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2081 if (vTo.addr == NULL) {
2082 appData.monoMode = True;
2085 highlightSquareColor = *(Pixel *) vTo.addr;
2089 if (!appData.monoMode) {
2090 vFrom.addr = (caddr_t) appData.premoveHighlightColor;
2091 vFrom.size = strlen(appData.premoveHighlightColor);
2092 XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
2093 if (vTo.addr == NULL) {
2094 appData.monoMode = True;
2097 premoveHighlightColor = *(Pixel *) vTo.addr;
2102 fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
2106 if (appData.monoMode && appData.debugMode) {
2107 fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
2108 (unsigned long) XWhitePixel(xDisplay, xScreen),
2109 (unsigned long) XBlackPixel(xDisplay, xScreen));
2112 if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
2113 parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
2114 parse_cpair(ColorChannel1, appData.colorChannel1) < 0 ||
2115 parse_cpair(ColorChannel, appData.colorChannel) < 0 ||
2116 parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||
2117 parse_cpair(ColorTell, appData.colorTell) < 0 ||
2118 parse_cpair(ColorChallenge, appData.colorChallenge) < 0 ||
2119 parse_cpair(ColorRequest, appData.colorRequest) < 0 ||
2120 parse_cpair(ColorSeek, appData.colorSeek) < 0 ||
2121 parse_cpair(ColorNormal, appData.colorNormal) < 0)
2123 if (appData.colorize) {
2125 _("%s: can't parse color names; disabling colorization\n"),
2128 appData.colorize = FALSE;
2130 textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
2131 textColors[ColorNone].attr = 0;
2133 XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
2139 layoutName = "tinyLayout";
2140 } else if (smallLayout) {
2141 layoutName = "smallLayout";
2143 layoutName = "normalLayout";
2145 /* Outer layoutWidget is there only to provide a name for use in
2146 resources that depend on the layout style */
2148 XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
2149 layoutArgs, XtNumber(layoutArgs));
2151 XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
2152 formArgs, XtNumber(formArgs));
2153 XtSetArg(args[0], XtNdefaultDistance, &sep);
2154 XtGetValues(formWidget, args, 1);
2157 widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar);
2159 widgetList[j++] = whiteTimerWidget =
2160 XtCreateWidget("whiteTime", labelWidgetClass,
2161 formWidget, timerArgs, XtNumber(timerArgs));
2162 XtSetArg(args[0], XtNfont, clockFontStruct);
2163 XtSetValues(whiteTimerWidget, args, 1);
2165 widgetList[j++] = blackTimerWidget =
2166 XtCreateWidget("blackTime", labelWidgetClass,
2167 formWidget, timerArgs, XtNumber(timerArgs));
2168 XtSetArg(args[0], XtNfont, clockFontStruct);
2169 XtSetValues(blackTimerWidget, args, 1);
2171 if (appData.titleInWindow) {
2172 widgetList[j++] = titleWidget =
2173 XtCreateWidget("title", labelWidgetClass, formWidget,
2174 titleArgs, XtNumber(titleArgs));
2177 if (appData.showButtonBar) {
2178 widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
2181 widgetList[j++] = messageWidget =
2182 XtCreateWidget("message", labelWidgetClass, formWidget,
2183 messageArgs, XtNumber(messageArgs));
2185 widgetList[j++] = boardWidget =
2186 XtCreateWidget("board", widgetClass, formWidget, boardArgs,
2187 XtNumber(boardArgs));
2189 XtManageChildren(widgetList, j);
2191 timerWidth = (boardWidth - sep) / 2;
2192 XtSetArg(args[0], XtNwidth, timerWidth);
2193 XtSetValues(whiteTimerWidget, args, 1);
2194 XtSetValues(blackTimerWidget, args, 1);
2196 XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
2197 XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
2198 XtGetValues(whiteTimerWidget, args, 2);
2200 if (appData.showButtonBar) {
2201 XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
2202 XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
2203 XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
2207 * formWidget uses these constraints but they are stored
2211 XtSetArg(args[i], XtNfromHoriz, 0); i++;
2212 XtSetValues(menuBarWidget, args, i);
2213 if (appData.titleInWindow) {
2216 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2217 XtSetValues(whiteTimerWidget, args, i);
2219 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2220 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2221 XtSetValues(blackTimerWidget, args, i);
2223 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2224 XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
2225 XtSetValues(titleWidget, args, i);
2227 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2228 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2229 XtSetValues(messageWidget, args, i);
2230 if (appData.showButtonBar) {
2232 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2233 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2234 XtSetValues(buttonBarWidget, args, i);
2238 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2239 XtSetValues(whiteTimerWidget, args, i);
2241 XtSetArg(args[i], XtNfromVert, titleWidget); i++;
2242 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2243 XtSetValues(blackTimerWidget, args, i);
2245 XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
2246 XtSetValues(titleWidget, args, i);
2248 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2249 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2250 XtSetValues(messageWidget, args, i);
2251 if (appData.showButtonBar) {
2253 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2254 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2255 XtSetValues(buttonBarWidget, args, i);
2260 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2261 XtSetValues(whiteTimerWidget, args, i);
2263 XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
2264 XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
2265 XtSetValues(blackTimerWidget, args, i);
2267 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2268 XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
2269 XtSetValues(messageWidget, args, i);
2270 if (appData.showButtonBar) {
2272 XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
2273 XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
2274 XtSetValues(buttonBarWidget, args, i);
2278 XtSetArg(args[0], XtNfromVert, messageWidget);
2279 XtSetValues(boardWidget, args, 1);
2281 XtRealizeWidget(shellWidget);
2284 * Correct the width of the message and title widgets.
2285 * It is not known why some systems need the extra fudge term.
2286 * The value "2" is probably larger than needed.
2288 XawFormDoLayout(formWidget, False);
2289 #define WIDTH_FUDGE 2
2291 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2292 XtSetArg(args[i], XtNheight, &h); i++;
2293 XtGetValues(messageWidget, args, i);
2294 if (appData.showButtonBar) {
2296 XtSetArg(args[i], XtNwidth, &w); i++;
2297 XtGetValues(buttonBarWidget, args, i);
2298 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2300 w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
2303 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2304 if (gres != XtGeometryYes && appData.debugMode) {
2305 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2306 programName, gres, w, h, wr, hr);
2309 /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
2310 /* The size used for the child widget in layout lags one resize behind
2311 its true size, so we resize a second time, 1 pixel smaller. Yeech! */
2313 gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
2314 if (gres != XtGeometryYes && appData.debugMode) {
2315 fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
2316 programName, gres, w, h, wr, hr);
2320 if (appData.titleInWindow) {
2322 XtSetArg(args[i], XtNborderWidth, &bor); i++;
2323 XtSetArg(args[i], XtNheight, &h); i++;
2324 XtGetValues(titleWidget, args, i);
2326 w = boardWidth - 2*bor;
2328 XtSetArg(args[0], XtNwidth, &w);
2329 XtGetValues(menuBarWidget, args, 1);
2330 w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
2333 gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
2334 if (gres != XtGeometryYes && appData.debugMode) {
2336 _("%s: titleWidget geometry error %d %d %d %d %d\n"),
2337 programName, gres, w, h, wr, hr);
2340 XawFormDoLayout(formWidget, True);
2342 xBoardWindow = XtWindow(boardWidget);
2345 * Create X checkmark bitmap and initialize option menu checks.
2347 ReadBitmap(&xMarkPixmap, "checkmark.bm",
2348 checkmark_bits, checkmark_width, checkmark_height);
2349 XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
2350 if (appData.alwaysPromoteToQueen) {
2351 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Always Queen"),
2354 if (appData.animateDragging) {
2355 XtSetValues(XtNameToWidget(menuBarWidget,
2356 "menuOptions.Animate Dragging"),
2359 if (appData.animate) {
2360 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Animate Moving"),
2363 if (appData.autoComment) {
2364 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Comment"),
2367 if (appData.autoCallFlag) {
2368 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Flag"),
2371 if (appData.autoFlipView) {
2372 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Auto Flip View"),
2375 if (appData.autoObserve) {
2376 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Observe"),
2379 if (appData.autoRaiseBoard) {
2380 XtSetValues(XtNameToWidget(menuBarWidget,
2381 "menuOptions.Auto Raise Board"), args, 1);
2383 if (appData.autoSaveGames) {
2384 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2387 if (appData.saveGameFile[0] != NULLCHAR) {
2388 /* Can't turn this off from menu */
2389 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2391 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuOptions.Auto Save"),
2395 if (appData.blindfold) {
2396 XtSetValues(XtNameToWidget(menuBarWidget,
2397 "menuOptions.Blindfold"), args, 1);
2399 if (appData.flashCount > 0) {
2400 XtSetValues(XtNameToWidget(menuBarWidget,
2401 "menuOptions.Flash Moves"),
2404 if (appData.getMoveList) {
2405 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Get Move List"),
2409 if (appData.highlightDragging) {
2410 XtSetValues(XtNameToWidget(menuBarWidget,
2411 "menuOptions.Highlight Dragging"),
2415 if (appData.highlightLastMove) {
2416 XtSetValues(XtNameToWidget(menuBarWidget,
2417 "menuOptions.Highlight Last Move"),
2420 if (appData.icsAlarm) {
2421 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.ICS Alarm"),
2424 if (appData.ringBellAfterMoves) {
2425 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Move Sound"),
2428 if (appData.oldSaveStyle) {
2429 XtSetValues(XtNameToWidget(menuBarWidget,
2430 "menuOptions.Old Save Style"), args, 1);
2432 if (appData.periodicUpdates) {
2433 XtSetValues(XtNameToWidget(menuBarWidget,
2434 "menuOptions.Periodic Updates"), args, 1);
2436 if (appData.ponderNextMove) {
2437 XtSetValues(XtNameToWidget(menuBarWidget,
2438 "menuOptions.Ponder Next Move"), args, 1);
2440 if (appData.popupExitMessage) {
2441 XtSetValues(XtNameToWidget(menuBarWidget,
2442 "menuOptions.Popup Exit Message"), args, 1);
2444 if (appData.popupMoveErrors) {
2445 XtSetValues(XtNameToWidget(menuBarWidget,
2446 "menuOptions.Popup Move Errors"), args, 1);
2448 if (appData.premove) {
2449 XtSetValues(XtNameToWidget(menuBarWidget,
2450 "menuOptions.Premove"), args, 1);
2452 if (appData.quietPlay) {
2453 XtSetValues(XtNameToWidget(menuBarWidget,
2454 "menuOptions.Quiet Play"), args, 1);
2456 if (appData.showCoords) {
2457 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Coords"),
2460 if (appData.showThinking) {
2461 XtSetValues(XtNameToWidget(menuBarWidget, "menuOptions.Show Thinking"),
2464 if (appData.testLegality) {
2465 XtSetValues(XtNameToWidget(menuBarWidget,"menuOptions.Test Legality"),
2469 /* icsEngineAnalyze - default init */
2470 appData.icsEngineAnalyze = FALSE;
2475 ReadBitmap(&wIconPixmap, "icon_white.bm",
2476 icon_white_bits, icon_white_width, icon_white_height);
2477 ReadBitmap(&bIconPixmap, "icon_black.bm",
2478 icon_black_bits, icon_black_width, icon_black_height);
2479 iconPixmap = wIconPixmap;
2481 XtSetArg(args[i], XtNiconPixmap, iconPixmap); i++;
2482 XtSetValues(shellWidget, args, i);
2485 * Create a cursor for the board widget.
2487 window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
2488 XChangeWindowAttributes(xDisplay, xBoardWindow,
2489 CWCursor, &window_attributes);
2492 * Inhibit shell resizing.
2494 shellArgs[0].value = (XtArgVal) &w;
2495 shellArgs[1].value = (XtArgVal) &h;
2496 XtGetValues(shellWidget, shellArgs, 2);
2497 shellArgs[4].value = shellArgs[2].value = w;
2498 shellArgs[5].value = shellArgs[3].value = h;
2499 XtSetValues(shellWidget, &shellArgs[2], 4);
2501 CatchDeleteWindow(shellWidget, "QuitProc");
2506 if (appData.bitmapDirectory[0] != NULLCHAR) {
2513 /* Create regular pieces */
2514 if (!useImages) CreatePieces();
2519 if (appData.animate || appData.animateDragging)
2522 XtAugmentTranslations(formWidget,
2523 XtParseTranslationTable(globalTranslations));
2524 XtAugmentTranslations(boardWidget,
2525 XtParseTranslationTable(boardTranslations));
2526 XtAugmentTranslations(whiteTimerWidget,
2527 XtParseTranslationTable(whiteTranslations));
2528 XtAugmentTranslations(blackTimerWidget,
2529 XtParseTranslationTable(blackTranslations));
2531 /* Why is the following needed on some versions of X instead
2532 * of a translation? */
2533 XtAddEventHandler(boardWidget, ExposureMask, False,
2534 (XtEventHandler) EventProc, NULL);
2539 if (errorExitStatus == -1) {
2540 if (appData.icsActive) {
2541 /* We now wait until we see "login:" from the ICS before
2542 sending the logon script (problems with timestamp otherwise) */
2543 /*ICSInitScript();*/
2544 if (appData.icsInputBox) ICSInputBoxPopUp();
2547 signal(SIGINT, IntSigHandler);
2548 signal(SIGTERM, IntSigHandler);
2549 if (*appData.cmailGameName != NULLCHAR) {
2550 signal(SIGUSR1, CmailSigHandler);
2554 XtAppMainLoop(appContext);
2561 if (appData.icsActive && oldICSInteractionTitle != NULL) {
2562 DisplayIcsInteractionTitle(oldICSInteractionTitle);
2564 unlink(gameCopyFilename);
2565 unlink(gamePasteFilename);
2576 CmailSigHandler(sig)
2582 signal(SIGUSR1, SIG_IGN); /* suspend handler */
2584 /* Activate call-back function CmailSigHandlerCallBack() */
2585 OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
2587 signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
2591 CmailSigHandlerCallBack(isr, closure, message, count, error)
2599 ReloadCmailMsgEvent(TRUE); /* Reload cmail msg */
2601 /**** end signal code ****/
2611 f = fopen(appData.icsLogon, "r");
2617 strcat(buf, appData.icsLogon);
2618 f = fopen(buf, "r");
2622 ProcessICSInitScript(f);
2629 EditCommentPopDown();
2640 SetMenuEnables(enab)
2644 if (!menuBarWidget) return;
2645 while (enab->name != NULL) {
2646 w = XtNameToWidget(menuBarWidget, enab->name);
2648 DisplayError(enab->name, 0);
2650 XtSetSensitive(w, enab->value);
2656 Enables icsEnables[] = {
2657 { "menuFile.Mail Move", False },
2658 { "menuFile.Reload CMail Message", False },
2659 { "menuMode.Machine Black", False },
2660 { "menuMode.Machine White", False },
2661 { "menuMode.Analysis Mode", False },
2662 { "menuMode.Analyze File", False },
2663 { "menuMode.Two Machines", False },
2665 { "menuHelp.Hint", False },
2666 { "menuHelp.Book", False },
2667 { "menuStep.Move Now", False },
2668 { "menuOptions.Periodic Updates", False },
2669 { "menuOptions.Show Thinking", False },
2670 { "menuOptions.Ponder Next Move", False },
2675 Enables ncpEnables[] = {
2676 { "menuFile.Mail Move", False },
2677 { "menuFile.Reload CMail Message", False },
2678 { "menuMode.Machine White", False },
2679 { "menuMode.Machine Black", False },
2680 { "menuMode.Analysis Mode", False },
2681 { "menuMode.Analyze File", False },
2682 { "menuMode.Two Machines", False },
2683 { "menuMode.ICS Client", False },
2684 { "menuMode.ICS Input Box", False },
2685 { "Action", False },
2686 { "menuStep.Revert", False },
2687 { "menuStep.Move Now", False },
2688 { "menuStep.Retract Move", False },
2689 { "menuOptions.Auto Comment", False },
2690 { "menuOptions.Auto Flag", False },
2691 { "menuOptions.Auto Flip View", False },
2692 { "menuOptions.Auto Observe", False },
2693 { "menuOptions.Auto Raise Board", False },
2694 { "menuOptions.Get Move List", False },
2695 { "menuOptions.ICS Alarm", False },
2696 { "menuOptions.Move Sound", False },
2697 { "menuOptions.Quiet Play", False },
2698 { "menuOptions.Show Thinking", False },
2699 { "menuOptions.Periodic Updates", False },
2700 { "menuOptions.Ponder Next Move", False },
2701 { "menuHelp.Hint", False },
2702 { "menuHelp.Book", False },
2706 Enables gnuEnables[] = {
2707 { "menuMode.ICS Client", False },
2708 { "menuMode.ICS Input Box", False },
2709 { "menuAction.Accept", False },
2710 { "menuAction.Decline", False },
2711 { "menuAction.Rematch", False },
2712 { "menuAction.Adjourn", False },
2713 { "menuAction.Stop Examining", False },
2714 { "menuAction.Stop Observing", False },
2715 { "menuStep.Revert", False },
2716 { "menuOptions.Auto Comment", False },
2717 { "menuOptions.Auto Observe", False },
2718 { "menuOptions.Auto Raise Board", False },
2719 { "menuOptions.Get Move List", False },
2720 { "menuOptions.Premove", False },
2721 { "menuOptions.Quiet Play", False },
2723 /* The next two options rely on SetCmailMode being called *after* */
2724 /* SetGNUMode so that when GNU is being used to give hints these */
2725 /* menu options are still available */
2727 { "menuFile.Mail Move", False },
2728 { "menuFile.Reload CMail Message", False },
2732 Enables cmailEnables[] = {
2734 { "menuAction.Call Flag", False },
2735 { "menuAction.Draw", True },
2736 { "menuAction.Adjourn", False },
2737 { "menuAction.Abort", False },
2738 { "menuAction.Stop Observing", False },
2739 { "menuAction.Stop Examining", False },
2740 { "menuFile.Mail Move", True },
2741 { "menuFile.Reload CMail Message", True },
2745 Enables trainingOnEnables[] = {
2746 { "menuMode.Edit Comment", False },
2747 { "menuMode.Pause", False },
2748 { "menuStep.Forward", False },
2749 { "menuStep.Backward", False },
2750 { "menuStep.Forward to End", False },
2751 { "menuStep.Back to Start", False },
2752 { "menuStep.Move Now", False },
2753 { "menuStep.Truncate Game", False },
2757 Enables trainingOffEnables[] = {
2758 { "menuMode.Edit Comment", True },
2759 { "menuMode.Pause", True },
2760 { "menuStep.Forward", True },
2761 { "menuStep.Backward", True },
2762 { "menuStep.Forward to End", True },
2763 { "menuStep.Back to Start", True },
2764 { "menuStep.Move Now", True },
2765 { "menuStep.Truncate Game", True },
2769 Enables machineThinkingEnables[] = {
2770 { "menuFile.Load Game", False },
2771 { "menuFile.Load Next Game", False },
2772 { "menuFile.Load Previous Game", False },
2773 { "menuFile.Reload Same Game", False },
2774 { "menuFile.Paste Game", False },
2775 { "menuFile.Load Position", False },
2776 { "menuFile.Load Next Position", False },
2777 { "menuFile.Load Previous Position", False },
2778 { "menuFile.Reload Same Position", False },
2779 { "menuFile.Paste Position", False },
2780 { "menuMode.Machine White", False },
2781 { "menuMode.Machine Black", False },
2782 { "menuMode.Two Machines", False },
2783 { "menuStep.Retract Move", False },
2787 Enables userThinkingEnables[] = {
2788 { "menuFile.Load Game", True },
2789 { "menuFile.Load Next Game", True },
2790 { "menuFile.Load Previous Game", True },
2791 { "menuFile.Reload Same Game", True },
2792 { "menuFile.Paste Game", True },
2793 { "menuFile.Load Position", True },
2794 { "menuFile.Load Next Position", True },
2795 { "menuFile.Load Previous Position", True },
2796 { "menuFile.Reload Same Position", True },
2797 { "menuFile.Paste Position", True },
2798 { "menuMode.Machine White", True },
2799 { "menuMode.Machine Black", True },
2800 { "menuMode.Two Machines", True },
2801 { "menuStep.Retract Move", True },
2807 SetMenuEnables(icsEnables);
2810 /* icsEngineAnalyze */
2811 if (appData.zippyPlay && !appData.noChessProgram)
2812 XtSetSensitive(XtNameToWidget(menuBarWidget, "menuMode.Analysis Mode"), True);
2819 SetMenuEnables(ncpEnables);
2825 SetMenuEnables(gnuEnables);
2831 SetMenuEnables(cmailEnables);
2837 SetMenuEnables(trainingOnEnables);
2838 if (appData.showButtonBar) {
2839 XtSetSensitive(buttonBarWidget, False);
2845 SetTrainingModeOff()
2847 SetMenuEnables(trainingOffEnables);
2848 if (appData.showButtonBar) {
2849 XtSetSensitive(buttonBarWidget, True);
2854 SetUserThinkingEnables()
2856 if (appData.noChessProgram) return;
2857 SetMenuEnables(userThinkingEnables);
2861 SetMachineThinkingEnables()
2863 if (appData.noChessProgram) return;
2864 SetMenuEnables(machineThinkingEnables);
2866 case MachinePlaysBlack:
2867 case MachinePlaysWhite:
2868 case TwoMachinesPlay:
2869 XtSetSensitive(XtNameToWidget(menuBarWidget,
2870 ModeToWidgetName(gameMode)), True);
2877 #define Abs(n) ((n)<0 ? -(n) : (n))
2880 * Find a font that matches "pattern" that is as close as
2881 * possible to the targetPxlSize. Prefer fonts that are k
2882 * pixels smaller to fonts that are k pixels larger. The
2883 * pattern must be in the X Consortium standard format,
2884 * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
2885 * The return value should be freed with XtFree when no
2888 char *FindFont(pattern, targetPxlSize)
2892 char **fonts, *p, *best, *scalable, *scalableTail;
2893 int i, j, nfonts, minerr, err, pxlSize;
2896 char **missing_list;
2898 char *def_string, *base_fnt_lst, strInt[3];
2900 XFontStruct **fnt_list;
2902 base_fnt_lst = calloc(1, strlen(pattern) + 3);
2903 sprintf(strInt, "%d", targetPxlSize);
2904 p = strstr(pattern, "--");
2905 strncpy(base_fnt_lst, pattern, p - pattern + 2);
2906 strcat(base_fnt_lst, strInt);
2907 strcat(base_fnt_lst, strchr(p + 2, '-'));
2909 if ((fntSet = XCreateFontSet(xDisplay,
2913 &def_string)) == NULL) {
2915 fprintf(stderr, _("Unable to create font set.\n"));
2919 nfonts = XFontsOfFontSet(fntSet, &fnt_list, &fonts);
2921 fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
2923 fprintf(stderr, _("%s: no fonts match pattern %s\n"),
2924 programName, pattern);
2932 for (i=0; i<nfonts; i++) {
2935 if (*p != '-') continue;
2937 if (*p == NULLCHAR) break;
2938 if (*p++ == '-') j++;
2940 if (j < 7) continue;
2943 scalable = fonts[i];
2946 err = pxlSize - targetPxlSize;
2947 if (Abs(err) < Abs(minerr) ||
2948 (minerr > 0 && err < 0 && -err == minerr)) {
2954 if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
2955 /* If the error is too big and there is a scalable font,
2956 use the scalable font. */
2957 int headlen = scalableTail - scalable;
2958 p = (char *) XtMalloc(strlen(scalable) + 10);
2959 while (isdigit(*scalableTail)) scalableTail++;
2960 sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
2962 p = (char *) XtMalloc(strlen(best) + 1);
2965 if (appData.debugMode) {
2966 fprintf(debugFP, _("resolved %s at pixel size %d\n to %s\n"),
2967 pattern, targetPxlSize, p);
2970 if (missing_count > 0)
2971 XFreeStringList(missing_list);
2972 XFreeFontSet(xDisplay, fntSet);
2974 XFreeFontNames(fonts);
2981 XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
2982 | GCBackground | GCFunction | GCPlaneMask;
2983 XGCValues gc_values;
2986 gc_values.plane_mask = AllPlanes;
2987 gc_values.line_width = lineGap;
2988 gc_values.line_style = LineSolid;
2989 gc_values.function = GXcopy;
2991 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
2992 gc_values.background = XBlackPixel(xDisplay, xScreen);
2993 lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
2995 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
2996 gc_values.background = XWhitePixel(xDisplay, xScreen);
2997 coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
2998 XSetFont(xDisplay, coordGC, coordFontID);
3000 if (appData.monoMode) {
3001 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3002 gc_values.background = XWhitePixel(xDisplay, xScreen);
3003 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3005 gc_values.foreground = XWhitePixel(xDisplay, xScreen);
3006 gc_values.background = XBlackPixel(xDisplay, xScreen);
3007 lightSquareGC = wbPieceGC
3008 = XtGetGC(shellWidget, value_mask, &gc_values);
3010 gc_values.foreground = XBlackPixel(xDisplay, xScreen);
3011 gc_values.background = XWhitePixel(xDisplay, xScreen);
3012 darkSquareGC = bwPieceGC
3013 = XtGetGC(shellWidget, value_mask, &gc_values);
3015 if (DefaultDepth(xDisplay, xScreen) == 1) {
3016 /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
3017 gc_values.function = GXcopyInverted;
3018 copyInvertedGC = XtGetGC(shellWidget, value_mask, &gc_values);
3019 gc_values.function = GXcopy;
3020 if (XBlackPixel(xDisplay, xScreen) == 1) {
3021 bwPieceGC = darkSquareGC;
3022 wbPieceGC = copyInvertedGC;
3024 bwPieceGC = copyInvertedGC;
3025 wbPieceGC = lightSquareGC;
3029 gc_values.foreground = highlightSquareColor;
3030 gc_values.background = highlightSquareColor;
3031 highlineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3033 gc_values.foreground = premoveHighlightColor;
3034 gc_values.background = premoveHighlightColor;
3035 prelineGC = XtGetGC(shellWidget, value_mask, &gc_values);
3037 gc_values.foreground = lightSquareColor;
3038 gc_values.background = darkSquareColor;
3039 lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3041 gc_values.foreground = darkSquareColor;
3042 gc_values.background = lightSquareColor;
3043 darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3045 gc_values.foreground = jailSquareColor;
3046 gc_values.background = jailSquareColor;
3047 jailSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
3049 gc_values.foreground = whitePieceColor;
3050 gc_values.background = darkSquareColor;
3051 wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3053 gc_values.foreground = whitePieceColor;
3054 gc_values.background = lightSquareColor;
3055 wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3057 gc_values.foreground = whitePieceColor;
3058 gc_values.background = jailSquareColor;
3059 wjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3061 gc_values.foreground = blackPieceColor;
3062 gc_values.background = darkSquareColor;
3063 bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3065 gc_values.foreground = blackPieceColor;
3066 gc_values.background = lightSquareColor;
3067 blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3069 gc_values.foreground = blackPieceColor;
3070 gc_values.background = jailSquareColor;
3071 bjPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
3075 void loadXIM(xim, xmask, filename, dest, mask)
3088 fp = fopen(filename, "rb");
3090 fprintf(stderr, _("%s: error loading XIM!\n"), programName);
3097 for (y=0; y<h; ++y) {
3098 for (x=0; x<h; ++x) {
3103 XPutPixel(xim, x, y, blackPieceColor);
3105 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3108 XPutPixel(xim, x, y, darkSquareColor);
3110 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3113 XPutPixel(xim, x, y, whitePieceColor);
3115 XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
3118 XPutPixel(xim, x, y, lightSquareColor);
3120 XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
3126 /* create Pixmap of piece */
3127 *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3129 XPutImage(xDisplay, *dest, lightSquareGC, xim,
3132 /* create Pixmap of clipmask
3133 Note: We assume the white/black pieces have the same
3134 outline, so we make only 6 masks. This is okay
3135 since the XPM clipmask routines do the same. */
3137 temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3139 XPutImage(xDisplay, temp, lightSquareGC, xmask,
3142 /* now create the 1-bit version */
3143 *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
3146 values.foreground = 1;
3147 values.background = 0;
3149 /* Don't use XtGetGC, not read only */
3150 maskGC = XCreateGC(xDisplay, *mask,
3151 GCForeground | GCBackground, &values);
3152 XCopyPlane(xDisplay, temp, *mask, maskGC,
3153 0, 0, squareSize, squareSize, 0, 0, 1);
3154 XFreePixmap(xDisplay, temp);
3158 void CreateXIMPieces()
3163 static char *ximkind[] = { "ll", "ld", "dl", "dd" };
3168 /* The XSynchronize calls were copied from CreatePieces.
3169 Not sure if needed, but can't hurt */
3170 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3173 /* temp needed by loadXIM() */
3174 ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3175 0, 0, ss, ss, AllPlanes, XYPixmap);
3177 if (strlen(appData.pixmapDirectory) == 0) {
3181 if (appData.monoMode) {
3182 DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
3186 fprintf(stderr, _("\nLoading XIMs...\n"));
3188 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3189 fprintf(stderr, "%d", piece+1);
3190 for (kind=0; kind<4; kind++) {
3191 fprintf(stderr, ".");
3192 sprintf(buf, "%s/%c%s%u.xim",
3193 ExpandPathName(appData.pixmapDirectory),
3194 ToLower(PieceToChar((ChessSquare)piece)),
3196 ximPieceBitmap[kind][piece] =
3197 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3198 0, 0, ss, ss, AllPlanes, XYPixmap);
3199 if (appData.debugMode)
3200 fprintf(stderr, _("(File:%s:) "), buf);
3201 loadXIM(ximPieceBitmap[kind][piece],
3203 &(xpmPieceBitmap[kind][piece]),
3204 &(ximMaskPm[piece%6]));
3206 fprintf(stderr," ");
3208 /* Load light and dark squares */
3209 /* If the LSQ and DSQ pieces don't exist, we will
3210 draw them with solid squares. */
3211 sprintf(buf, "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
3212 if (access(buf, 0) != 0) {
3216 fprintf(stderr, _("light square "));
3218 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3219 0, 0, ss, ss, AllPlanes, XYPixmap);
3220 if (appData.debugMode)
3221 fprintf(stderr, _("(File:%s:) "), buf);
3223 loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
3224 fprintf(stderr, _("dark square "));
3225 sprintf(buf, "%s/dsq%u.xim",
3226 ExpandPathName(appData.pixmapDirectory), ss);
3227 if (appData.debugMode)
3228 fprintf(stderr, _("(File:%s:) "), buf);
3230 XGetImage(xDisplay, DefaultRootWindow(xDisplay),
3231 0, 0, ss, ss, AllPlanes, XYPixmap);
3232 loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
3233 xpmJailSquare = xpmLightSquare;
3235 fprintf(stderr, _("Done.\n"));
3237 XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
3241 void CreateXPMPieces()
3245 u_int ss = squareSize;
3247 static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
3248 XpmColorSymbol symbols[4];
3251 /* Apparently some versions of Xpm don't define XpmFormat at all --tpm */
3252 if (appData.debugMode) {
3253 fprintf(stderr, "XPM Library Version: %d.%d%c\n",
3254 XpmFormat, XpmVersion, (char)('a' + XpmRevision - 1));
3258 /* The XSynchronize calls were copied from CreatePieces.
3259 Not sure if needed, but can't hurt */
3260 XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
3262 /* Setup translations so piece colors match square colors */
3263 symbols[0].name = "light_piece";
3264 symbols[0].value = appData.whitePieceColor;
3265 symbols[1].name = "dark_piece";
3266 symbols[1].value = appData.blackPieceColor;
3267 symbols[2].name = "light_square";
3268 symbols[2].value = appData.lightSquareColor;
3269 symbols[3].name = "dark_square";
3270 symbols[3].value = appData.darkSquareColor;
3272 attr.valuemask = XpmColorSymbols;
3273 attr.colorsymbols = symbols;
3274 attr.numsymbols = 4;
3276 if (appData.monoMode) {
3277 DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
3281 if (strlen(appData.pixmapDirectory) == 0) {
3282 XpmPieces* pieces = builtInXpms;
3285 while (pieces->size != squareSize && pieces->size) pieces++;
3286 if (!pieces->size) {
3287 fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
3290 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3291 for (kind=0; kind<4; kind++) {
3293 if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
3294 pieces->xpm[piece][kind],
3295 &(xpmPieceBitmap[kind][piece]),
3296 NULL, &attr)) != 0) {
3297 fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
3304 xpmJailSquare = xpmLightSquare;
3308 fprintf(stderr, _("\nLoading XPMs...\n"));
3311 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3312 fprintf(stderr, "%d ", piece+1);
3313 for (kind=0; kind<4; kind++) {
3314 sprintf(buf, "%s/%c%s%u.xpm",
3315 ExpandPathName(appData.pixmapDirectory),
3316 ToLower(PieceToChar((ChessSquare)piece)),
3318 if (appData.debugMode) {
3319 fprintf(stderr, _("(File:%s:) "), buf);
3321 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3322 &(xpmPieceBitmap[kind][piece]),
3323 NULL, &attr)) != 0) {
3324 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
3330 /* Load light and dark squares */
3331 /* If the LSQ and DSQ pieces don't exist, we will
3332 draw them with solid squares. */
3333 fprintf(stderr, _("light square "));
3334 sprintf(buf, "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
3335 if (access(buf, 0) != 0) {
3339 if (appData.debugMode)
3340 fprintf(stderr, _("(File:%s:) "), buf);
3342 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3343 &xpmLightSquare, NULL, &attr)) != 0) {
3344 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3347 fprintf(stderr, _("dark square "));
3348 sprintf(buf, "%s/dsq%u.xpm",
3349 ExpandPathName(appData.pixmapDirectory), ss);
3350 if (appData.debugMode) {
3351 fprintf(stderr, _("(File:%s:) "), buf);
3353 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
3354 &xpmDarkSquare, NULL, &attr)) != 0) {
3355 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
3359 xpmJailSquare = xpmLightSquare;
3360 fprintf(stderr, _("Done.\n"));
3362 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3365 #endif /* HAVE_LIBXPM */
3368 /* No built-in bitmaps */
3373 u_int ss = squareSize;
3375 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3378 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
3379 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3380 sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
3381 ss, kind == SOLID ? 's' : 'o');
3382 ReadBitmap(&pieceBitmap[kind][piece], buf, NULL, ss, ss);
3386 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3390 /* With built-in bitmaps */
3393 BuiltInBits* bib = builtInBits;
3396 u_int ss = squareSize;
3398 XSynchronize(xDisplay, True); /* Work-around for xlib/xt
3401 while (bib->squareSize != ss && bib->squareSize != 0) bib++;
3403 for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
3404 for (piece = (int) WhitePawn; piece <= (int) WhiteKing; piece++) {
3405 sprintf(buf, "%c%u%c.bm", ToLower(PieceToChar((ChessSquare)piece)),
3406 ss, kind == SOLID ? 's' : 'o');
3407 ReadBitmap(&pieceBitmap[kind][piece], buf,
3408 bib->bits[kind][piece], ss, ss);
3412 XSynchronize(xDisplay, False); /* Work-around for xlib/xt
3417 void ReadBitmap(pm, name, bits, wreq, hreq)
3420 unsigned char bits[];
3426 char msg[MSG_SIZ], fullname[MSG_SIZ];
3428 if (*appData.bitmapDirectory != NULLCHAR) {
3429 strcpy(fullname, appData.bitmapDirectory);
3430 strcat(fullname, "/");
3431 strcat(fullname, name);
3432 errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
3433 &w, &h, pm, &x_hot, &y_hot);
3434 if (errcode != BitmapSuccess) {
3436 case BitmapOpenFailed:
3437 sprintf(msg, _("Can't open bitmap file %s"), fullname);
3439 case BitmapFileInvalid:
3440 sprintf(msg, _("Invalid bitmap in file %s"), fullname);
3442 case BitmapNoMemory:
3443 sprintf(msg, _("Ran out of memory reading bitmap file %s"),
3447 sprintf(msg, _("Unknown XReadBitmapFile error %d on file %s"),
3451 fprintf(stderr, _("%s: %s...using built-in\n"),
3453 } else if (w != wreq || h != hreq) {
3455 _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
3456 programName, fullname, w, h, wreq, hreq);
3462 fprintf(stderr, _("%s: No built-in bitmap for %s; giving up\n"),
3466 *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
3475 if (lineGap == 0) return;
3476 for (i = 0; i < BOARD_SIZE + 1; i++) {
3477 gridSegments[i].x1 = 0;
3478 gridSegments[i].x2 =
3479 lineGap + BOARD_SIZE * (squareSize + lineGap);
3480 gridSegments[i].y1 = gridSegments[i].y2
3481 = lineGap / 2 + (i * (squareSize + lineGap));
3483 gridSegments[i + BOARD_SIZE + 1].y1 = 0;
3484 gridSegments[i + BOARD_SIZE + 1].y2 =
3485 BOARD_SIZE * (squareSize + lineGap);
3486 gridSegments[i + BOARD_SIZE + 1].x1 =
3487 gridSegments[i + BOARD_SIZE + 1].x2
3488 = lineGap / 2 + (i * (squareSize + lineGap));
3492 static void MenuBarSelect(w, addr, index)
3497 XtActionProc proc = (XtActionProc) addr;
3499 (proc)(NULL, NULL, NULL, NULL);
3502 void CreateMenuBarPopup(parent, name, mb)
3512 menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
3515 XtSetArg(args[j], XtNleftMargin, 20); j++;
3516 XtSetArg(args[j], XtNrightMargin, 20); j++;
3518 while (mi->string != NULL) {
3519 if (strcmp(mi->string, "----") == 0) {
3520 entry = XtCreateManagedWidget(mi->string, smeLineObjectClass,
3523 XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string)));
3524 entry = XtCreateManagedWidget(mi->string, smeBSBObjectClass,
3526 XtAddCallback(entry, XtNcallback,
3527 (XtCallbackProc) MenuBarSelect,
3528 (caddr_t) mi->proc);