Declare some shared global variables in backend.h
[xboard.git] / xboard.c
1 /*
2  * xboard.c -- X front end for XBoard
3  *
4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
5  * Massachusetts.
6  *
7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
8  * 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
9  *
10  * The following terms apply to Digital Equipment Corporation's copyright
11  * interest in XBoard:
12  * ------------------------------------------------------------------------
13  * All Rights Reserved
14  *
15  * Permission to use, copy, modify, and distribute this software and its
16  * documentation for any purpose and without fee is hereby granted,
17  * provided that the above copyright notice appear in all copies and that
18  * both that copyright notice and this permission notice appear in
19  * supporting documentation, and that the name of Digital not be
20  * used in advertising or publicity pertaining to distribution of the
21  * software without specific, written prior permission.
22  *
23  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
24  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
25  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
26  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
27  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
28  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
29  * SOFTWARE.
30  * ------------------------------------------------------------------------
31  *
32  * The following terms apply to the enhanced version of XBoard
33  * distributed by the Free Software Foundation:
34  * ------------------------------------------------------------------------
35  *
36  * GNU XBoard is free software: you can redistribute it and/or modify
37  * it under the terms of the GNU General Public License as published by
38  * the Free Software Foundation, either version 3 of the License, or (at
39  * your option) any later version.
40  *
41  * GNU XBoard is distributed in the hope that it will be useful, but
42  * WITHOUT ANY WARRANTY; without even the implied warranty of
43  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
44  * General Public License for more details.
45  *
46  * You should have received a copy of the GNU General Public License
47  * along with this program. If not, see http://www.gnu.org/licenses/.  *
48  *
49  *------------------------------------------------------------------------
50  ** See the file ChangeLog for a revision history.  */
51
52 #define HIGHDRAG 1
53
54 #include "config.h"
55
56 #include <stdio.h>
57 #include <ctype.h>
58 #include <signal.h>
59 #include <errno.h>
60 #include <sys/types.h>
61 #include <sys/stat.h>
62 #include <pwd.h>
63 #include <math.h>
64
65 #if !OMIT_SOCKETS
66 # if HAVE_SYS_SOCKET_H
67 #  include <sys/socket.h>
68 #  include <netinet/in.h>
69 #  include <netdb.h>
70 # else /* not HAVE_SYS_SOCKET_H */
71 #  if HAVE_LAN_SOCKET_H
72 #   include <lan/socket.h>
73 #   include <lan/in.h>
74 #   include <lan/netdb.h>
75 #  else /* not HAVE_LAN_SOCKET_H */
76 #   define OMIT_SOCKETS 1
77 #  endif /* not HAVE_LAN_SOCKET_H */
78 # endif /* not HAVE_SYS_SOCKET_H */
79 #endif /* !OMIT_SOCKETS */
80
81 #if STDC_HEADERS
82 # include <stdlib.h>
83 # include <string.h>
84 #else /* not STDC_HEADERS */
85 extern char *getenv();
86 # if HAVE_STRING_H
87 #  include <string.h>
88 # else /* not HAVE_STRING_H */
89 #  include <strings.h>
90 # endif /* not HAVE_STRING_H */
91 #endif /* not STDC_HEADERS */
92
93 #if HAVE_SYS_FCNTL_H
94 # include <sys/fcntl.h>
95 #else /* not HAVE_SYS_FCNTL_H */
96 # if HAVE_FCNTL_H
97 #  include <fcntl.h>
98 # endif /* HAVE_FCNTL_H */
99 #endif /* not HAVE_SYS_FCNTL_H */
100
101 #if HAVE_SYS_SYSTEMINFO_H
102 # include <sys/systeminfo.h>
103 #endif /* HAVE_SYS_SYSTEMINFO_H */
104
105 #if TIME_WITH_SYS_TIME
106 # include <sys/time.h>
107 # include <time.h>
108 #else
109 # if HAVE_SYS_TIME_H
110 #  include <sys/time.h>
111 # else
112 #  include <time.h>
113 # endif
114 #endif
115
116 #if HAVE_UNISTD_H
117 # include <unistd.h>
118 #endif
119
120 #if HAVE_SYS_WAIT_H
121 # include <sys/wait.h>
122 #endif
123
124 #if HAVE_DIRENT_H
125 # include <dirent.h>
126 # define NAMLEN(dirent) strlen((dirent)->d_name)
127 # define HAVE_DIR_STRUCT
128 #else
129 # define dirent direct
130 # define NAMLEN(dirent) (dirent)->d_namlen
131 # if HAVE_SYS_NDIR_H
132 #  include <sys/ndir.h>
133 #  define HAVE_DIR_STRUCT
134 # endif
135 # if HAVE_SYS_DIR_H
136 #  include <sys/dir.h>
137 #  define HAVE_DIR_STRUCT
138 # endif
139 # if HAVE_NDIR_H
140 #  include <ndir.h>
141 #  define HAVE_DIR_STRUCT
142 # endif
143 #endif
144
145 #if ENABLE_NLS
146 #include <locale.h>
147 #endif
148
149 #include <X11/Intrinsic.h>
150 #include <X11/StringDefs.h>
151 #include <X11/Shell.h>
152 #include <X11/cursorfont.h>
153 #include <X11/Xatom.h>
154 #include <X11/Xmu/Atoms.h>
155 #if USE_XAW3D
156 #include <X11/Xaw3d/Dialog.h>
157 #include <X11/Xaw3d/Form.h>
158 #include <X11/Xaw3d/List.h>
159 #include <X11/Xaw3d/Label.h>
160 #include <X11/Xaw3d/SimpleMenu.h>
161 #include <X11/Xaw3d/SmeBSB.h>
162 #include <X11/Xaw3d/SmeLine.h>
163 #include <X11/Xaw3d/Box.h>
164 #include <X11/Xaw3d/MenuButton.h>
165 #include <X11/Xaw3d/Text.h>
166 #include <X11/Xaw3d/AsciiText.h>
167 #else
168 #include <X11/Xaw/Dialog.h>
169 #include <X11/Xaw/Form.h>
170 #include <X11/Xaw/List.h>
171 #include <X11/Xaw/Label.h>
172 #include <X11/Xaw/SimpleMenu.h>
173 #include <X11/Xaw/SmeBSB.h>
174 #include <X11/Xaw/SmeLine.h>
175 #include <X11/Xaw/Box.h>
176 #include <X11/Xaw/MenuButton.h>
177 #include <X11/Xaw/Text.h>
178 #include <X11/Xaw/AsciiText.h>
179 #endif
180
181 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
182 #include "common.h"
183
184 #if HAVE_LIBXPM
185 #include <X11/xpm.h>
186 #include "pixmaps/pixmaps.h"
187 #define IMAGE_EXT "xpm"
188 #else
189 #define IMAGE_EXT "xim"
190 #include "bitmaps/bitmaps.h"
191 #endif
192
193 #include "bitmaps/icon_white.bm"
194 #include "bitmaps/icon_black.bm"
195 #include "bitmaps/checkmark.bm"
196
197 #include "frontend.h"
198 #include "backend.h"
199 #include "backendz.h"
200 #include "moves.h"
201 #include "xboard.h"
202 #include "childio.h"
203 #include "xgamelist.h"
204 #include "xhistory.h"
205 #include "xedittags.h"
206 #include "menus.h"
207 #include "board.h"
208 #include "gettext.h"
209
210
211 #ifdef __EMX__
212 #ifndef HAVE_USLEEP
213 #define HAVE_USLEEP
214 #endif
215 #define usleep(t)   _sleep2(((t)+500)/1000)
216 #endif
217
218 #ifdef ENABLE_NLS
219 # define  _(s) gettext (s)
220 # define N_(s) gettext_noop (s)
221 #else
222 # define  _(s) (s)
223 # define N_(s)  s
224 #endif
225
226 int main P((int argc, char **argv));
227 FILE * XsraSelFile P((Widget w, char *prompt, char *ok, char *cancel, char *failed,
228                 char *init_path, char *filter, char *mode, int (*show_entry)(), char **name_return));
229 RETSIGTYPE CmailSigHandler P((int sig));
230 RETSIGTYPE IntSigHandler P((int sig));
231 RETSIGTYPE TermSizeSigHandler P((int sig));
232 void CreateGCs P((int redo));
233 void CreateAnyPieces P((void));
234 void CreateXIMPieces P((void));
235 void CreateXPMPieces P((void));
236 void CreateXPMBoard P((char *s, int n));
237 void CreatePieces P((void));
238 void CreatePieceMenus P((void));
239 Widget CreateMenuBar P((Menu *mb, int boardWidth));
240 Widget CreateButtonBar P ((MenuItem *mi));
241 #if ENABLE_NLS
242 char *InsertPxlSize P((char *pattern, int targetPxlSize));
243 XFontSet CreateFontSet P((char *base_fnt_lst));
244 #else
245 char *FindFont P((char *pattern, int targetPxlSize));
246 #endif
247 void PieceMenuPopup P((Widget w, XEvent *event,
248                        String *params, Cardinal *num_params));
249 static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
250 static void DropMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
251 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
252                    u_int wreq, u_int hreq));
253 void CreateGrid P((void));
254 int EventToSquare P((int x, int limit));
255 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
256 void DelayedDrag P((void));
257 void MoveTypeInProc P((Widget widget, caddr_t unused, XEvent *event));
258 void HandleUserMove P((Widget w, XEvent *event,
259                      String *prms, Cardinal *nprms));
260 void AnimateUserMove P((Widget w, XEvent * event,
261                      String * params, Cardinal * nParams));
262 void HandlePV P((Widget w, XEvent * event,
263                      String * params, Cardinal * nParams));
264 void SelectPV P((Widget w, XEvent * event,
265                      String * params, Cardinal * nParams));
266 void StopPV P((Widget w, XEvent * event,
267                      String * params, Cardinal * nParams));
268 void WhiteClock P((Widget w, XEvent *event,
269                    String *prms, Cardinal *nprms));
270 void BlackClock P((Widget w, XEvent *event,
271                    String *prms, Cardinal *nprms));
272 void DrawPositionProc P((Widget w, XEvent *event,
273                      String *prms, Cardinal *nprms));
274 void XDrawPosition P((Widget w, /*Boolean*/int repaint,
275                      Board board));
276 void CommentClick P((Widget w, XEvent * event,
277                    String * params, Cardinal * nParams));
278 void CommentPopUp P((char *title, char *label));
279 void CommentPopDown P((void));
280 void ICSInputBoxPopUp P((void));
281 void ICSInputBoxPopDown P((void));
282 void FileNamePopUp P((char *label, char *def, char *filter,
283                       FileProc proc, char *openMode));
284 void FileNamePopDown P((void));
285 void FileNameCallback P((Widget w, XtPointer client_data,
286                          XtPointer call_data));
287 void FileNameAction P((Widget w, XEvent *event,
288                        String *prms, Cardinal *nprms));
289 void AskQuestionReplyAction P((Widget w, XEvent *event,
290                           String *prms, Cardinal *nprms));
291 void AskQuestionProc P((Widget w, XEvent *event,
292                           String *prms, Cardinal *nprms));
293 void AskQuestionPopDown P((void));
294 void PromotionPopDown P((void));
295 void PromotionCallback P((Widget w, XtPointer client_data,
296                           XtPointer call_data));
297 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
298 void KeyBindingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
299 void QuitWrapper P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
300 void TypeInProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
301 void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
302 void UpKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
303 void DownKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
304 void TempBackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
305 void TempForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
306 Boolean TempBackwardActive = False;
307 void ManInner P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
308 void DisplayMove P((int moveNumber));
309 void DisplayTitle P((char *title));
310 void ICSInitScript P((void));
311 void ErrorPopUp P((char *title, char *text, int modal));
312 void ErrorPopDown P((void));
313 static char *ExpandPathName P((char *path));
314 void SelectMove P((Widget w, XEvent * event, String * params, Cardinal * nParams));
315 void GameListOptionsPopDown P(());
316 void GenericPopDown P(());
317 void update_ics_width P(());
318 int get_term_width P(());
319 int CopyMemoProc P(());
320 void DrawArrowHighlight P((int fromX, int fromY, int toX,int toY));
321 Boolean IsDrawArrowEnabled P(());
322
323 /*
324 * XBoard depends on Xt R4 or higher
325 */
326 int xtVersion = XtSpecificationRelease;
327
328 int xScreen;
329 Display *xDisplay;
330 Window xBoardWindow;
331 Pixel lightSquareColor, darkSquareColor, whitePieceColor, blackPieceColor,
332   jailSquareColor, highlightSquareColor, premoveHighlightColor;
333 Pixel lowTimeWarningColor;
334 GC lightSquareGC, darkSquareGC, jailSquareGC, lineGC, wdPieceGC, wlPieceGC,
335   bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC, highlineGC,
336   wjPieceGC, bjPieceGC, prelineGC, countGC;
337 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
338 Widget shellWidget, layoutWidget, formWidget, boardWidget, messageWidget,
339   whiteTimerWidget, blackTimerWidget, titleWidget, widgetList[16],
340   commentShell, promotionShell, whitePieceMenu, blackPieceMenu, dropMenu,
341   menuBarWidget, buttonBarWidget, editShell, errorShell, analysisShell,
342   ICSInputShell, fileNameShell, askQuestionShell;
343 Widget historyShell, evalGraphShell, gameListShell;
344 XSegment secondSegments[BOARD_RANKS + BOARD_FILES + 2];
345 XSegment gridSegments[BOARD_RANKS + BOARD_FILES + 2];
346 XSegment jailGridSegments[BOARD_RANKS + BOARD_FILES + 6];
347 #if ENABLE_NLS
348 XFontSet fontSet, clockFontSet;
349 #else
350 Font clockFontID;
351 XFontStruct *clockFontStruct;
352 #endif
353 Font coordFontID, countFontID;
354 XFontStruct *coordFontStruct, *countFontStruct;
355 XtAppContext appContext;
356 char *layoutName;
357 char *oldICSInteractionTitle;
358
359 FileProc fileProc;
360 char *fileOpenMode;
361 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
362
363 Position commentX = -1, commentY = -1;
364 Dimension commentW, commentH;
365 typedef unsigned int BoardSize;
366 BoardSize boardSize;
367 Boolean chessProgram;
368
369 int  minX, minY; // [HGM] placement: volatile limits on upper-left corner
370 int smallLayout = 0, tinyLayout = 0,
371   marginW, marginH, // [HGM] for run-time resizing
372   fromX = -1, fromY = -1, toX, toY, commentUp = False, analysisUp = False,
373   ICSInputBoxUp = False, askQuestionUp = False,
374   filenameUp = False, promotionUp = False, pmFromX = -1, pmFromY = -1,
375   errorUp = False, errorExitStatus = -1, defaultLineGap;
376 Dimension textHeight;
377 Pixel timerForegroundPixel, timerBackgroundPixel;
378 Pixel buttonForegroundPixel, buttonBackgroundPixel;
379 char *chessDir, *programName, *programVersion;
380 Boolean alwaysOnTop = False;
381 char *icsTextMenuString;
382 char *icsNames;
383 char *firstChessProgramNames;
384 char *secondChessProgramNames;
385
386 WindowPlacement wpMain;
387 WindowPlacement wpConsole;
388 WindowPlacement wpComment;
389 WindowPlacement wpMoveHistory;
390 WindowPlacement wpEvalGraph;
391 WindowPlacement wpEngineOutput;
392 WindowPlacement wpGameList;
393 WindowPlacement wpTags;
394
395 extern Widget shells[];
396 extern Boolean shellUp[];
397
398 #define SOLID 0
399 #define OUTLINE 1
400 Pixmap pieceBitmap[2][(int)BlackPawn];
401 Pixmap pieceBitmap2[2][(int)BlackPawn+4];       /* [HGM] pieces */
402 Pixmap xpmPieceBitmap[4][(int)BlackPawn];       /* LL, LD, DL, DD actually used*/
403 Pixmap xpmPieceBitmap2[4][(int)BlackPawn+4];    /* LL, LD, DL, DD set to select from */
404 Pixmap xpmLightSquare, xpmDarkSquare, xpmJailSquare;
405 Pixmap xpmBoardBitmap[2];
406 int useImages, useImageSqs, useTexture, textureW[2], textureH[2];
407 XImage *ximPieceBitmap[4][(int)BlackPawn+4];    /* LL, LD, DL, DD */
408 Pixmap ximMaskPm[(int)BlackPawn];               /* clipmasks, used for XIM pieces */
409 Pixmap ximMaskPm2[(int)BlackPawn+4];            /* clipmasks, used for XIM pieces */
410 XImage *ximLightSquare, *ximDarkSquare;
411 XImage *xim_Cross;
412
413 #define pieceToSolid(piece) &pieceBitmap[SOLID][(piece) % (int)BlackPawn]
414 #define pieceToOutline(piece) &pieceBitmap[OUTLINE][(piece) % (int)BlackPawn]
415
416 #define White(piece) ((int)(piece) < (int)BlackPawn)
417
418 /* Bitmaps for use as masks when drawing XPM pieces.
419    Need one for each black and white piece.             */
420 static Pixmap xpmMask[BlackKing + 1];
421
422 /* This magic number is the number of intermediate frames used
423    in each half of the animation. For short moves it's reduced
424    by 1. The total number of frames will be factor * 2 + 1.  */
425 #define kFactor    4
426
427 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
428
429 #define PAUSE_BUTTON "P"
430 MenuItem buttonBar[] = {
431     {"<<", "<<", ToStartEvent},
432     {"<", "<", BackwardEvent},
433     {N_(PAUSE_BUTTON), PAUSE_BUTTON, PauseEvent},
434     {">", ">", ForwardEvent},
435     {">>", ">>", ToEndEvent},
436     {NULL, NULL, NULL}
437 };
438
439 #define PIECE_MENU_SIZE 18
440 String pieceMenuStrings[2][PIECE_MENU_SIZE] = {
441     { N_("White"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
442       N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
443       N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
444       N_("Empty square"), N_("Clear board") },
445     { N_("Black"), "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"),
446       N_("Queen"), N_("King"), "----", N_("Elephant"), N_("Cannon"),
447       N_("Archbishop"), N_("Chancellor"), "----", N_("Promote"), N_("Demote"),
448       N_("Empty square"), N_("Clear board") }
449 };
450 /* must be in same order as pieceMenuStrings! */
451 ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
452     { WhitePlay, (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
453         WhiteRook, WhiteQueen, WhiteKing, (ChessSquare) 0, WhiteAlfil,
454         WhiteCannon, WhiteAngel, WhiteMarshall, (ChessSquare) 0,
455         PromotePiece, DemotePiece, EmptySquare, ClearBoard },
456     { BlackPlay, (ChessSquare) 0, BlackPawn, BlackKnight, BlackBishop,
457         BlackRook, BlackQueen, BlackKing, (ChessSquare) 0, BlackAlfil,
458         BlackCannon, BlackAngel, BlackMarshall, (ChessSquare) 0,
459         PromotePiece, DemotePiece, EmptySquare, ClearBoard },
460 };
461
462 #define DROP_MENU_SIZE 6
463 String dropMenuStrings[DROP_MENU_SIZE] = {
464     "----", N_("Pawn"), N_("Knight"), N_("Bishop"), N_("Rook"), N_("Queen")
465   };
466 /* must be in same order as dropMenuStrings! */
467 ChessSquare dropMenuTranslation[DROP_MENU_SIZE] = {
468     (ChessSquare) 0, WhitePawn, WhiteKnight, WhiteBishop,
469     WhiteRook, WhiteQueen
470 };
471
472 typedef struct {
473     char piece;
474     char* widget;
475 } DropMenuEnables;
476
477 DropMenuEnables dmEnables[] = {
478     { 'P', "Pawn" },
479     { 'N', "Knight" },
480     { 'B', "Bishop" },
481     { 'R', "Rook" },
482     { 'Q', "Queen" }
483 };
484
485 Arg shellArgs[] = {
486     { XtNwidth, 0 },
487     { XtNheight, 0 },
488     { XtNminWidth, 0 },
489     { XtNminHeight, 0 },
490     { XtNmaxWidth, 0 },
491     { XtNmaxHeight, 0 }
492 };
493
494 Arg layoutArgs[] = {
495     { XtNborderWidth, 0 },
496     { XtNdefaultDistance, 0 },
497 };
498
499 Arg formArgs[] = {
500     { XtNborderWidth, 0 },
501     { XtNresizable, (XtArgVal) True },
502 };
503
504 Arg boardArgs[] = {
505     { XtNborderWidth, 0 },
506     { XtNwidth, 0 },
507     { XtNheight, 0 }
508 };
509
510 Arg titleArgs[] = {
511     { XtNjustify, (XtArgVal) XtJustifyRight },
512     { XtNlabel, (XtArgVal) "..." },
513     { XtNresizable, (XtArgVal) True },
514     { XtNresize, (XtArgVal) False }
515 };
516
517 Arg messageArgs[] = {
518     { XtNjustify, (XtArgVal) XtJustifyLeft },
519     { XtNlabel, (XtArgVal) "..." },
520     { XtNresizable, (XtArgVal) True },
521     { XtNresize, (XtArgVal) False }
522 };
523
524 Arg timerArgs[] = {
525     { XtNborderWidth, 0 },
526     { XtNjustify, (XtArgVal) XtJustifyLeft }
527 };
528
529 XtResource clientResources[] = {
530     { "flashCount", "flashCount", XtRInt, sizeof(int),
531         XtOffset(AppDataPtr, flashCount), XtRImmediate,
532         (XtPointer) FLASH_COUNT  },
533 };
534
535 XrmOptionDescRec shellOptions[] = {
536     { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
537     { "-flash", "flashCount", XrmoptionNoArg, "3" },
538     { "-xflash", "flashCount", XrmoptionNoArg, "0" },
539 };
540
541 XtActionsRec boardActions[] = {
542     { "DrawPosition", DrawPositionProc },
543     { "HandleUserMove", HandleUserMove },
544     { "AnimateUserMove", AnimateUserMove },
545     { "HandlePV", HandlePV },
546     { "SelectPV", SelectPV },
547     { "StopPV", StopPV },
548     { "FileNameAction", FileNameAction },
549     { "AskQuestionProc", AskQuestionProc },
550     { "AskQuestionReplyAction", AskQuestionReplyAction },
551     { "PieceMenuPopup", PieceMenuPopup },
552     { "WhiteClock", WhiteClock },
553     { "BlackClock", BlackClock },
554     { "MenuItem", KeyBindingProc }, // [HGM] generic handler for key bindings
555     { "QuitProc", QuitWrapper },
556     { "ManProc", ManInner },
557     { "TempBackwardProc", TempBackwardProc },
558     { "TempForwardProc", TempForwardProc },
559     { "CommentClick", (XtActionProc) CommentClick },
560     { "CommentPopDown", (XtActionProc) CommentPopDown },
561     { "TagsPopDown", (XtActionProc) TagsPopDown },
562     { "ErrorPopDown", (XtActionProc) ErrorPopDown },
563     { "ICSInputBoxPopDown", (XtActionProc) ICSInputBoxPopDown },
564     { "FileNamePopDown", (XtActionProc) FileNamePopDown },
565     { "AskQuestionPopDown", (XtActionProc) AskQuestionPopDown },
566     { "GameListPopDown", (XtActionProc) GameListPopDown },
567     { "GameListOptionsPopDown", (XtActionProc) GameListOptionsPopDown },
568     { "PromotionPopDown", (XtActionProc) PromotionPopDown },
569     { "EngineOutputPopDown", (XtActionProc) EngineOutputPopDown },
570     { "EvalGraphPopDown", (XtActionProc) EvalGraphPopDown },
571     { "GenericPopDown", (XtActionProc) GenericPopDown },
572     { "CopyMemoProc", (XtActionProc) CopyMemoProc },
573     { "SelectMove", (XtActionProc) SelectMove },
574     { "LoadSelectedProc", LoadSelectedProc },
575     { "SetFilterProc", SetFilterProc },
576     { "TypeInProc", TypeInProc },
577     { "EnterKeyProc", EnterKeyProc },
578     { "UpKeyProc", UpKeyProc },
579     { "DownKeyProc", DownKeyProc },
580 };
581
582 char globalTranslations[] =
583   ":<Key>F9: MenuItem(ResignProc) \n \
584    :Ctrl<Key>n: MenuItem(NewGame) \n \
585    :Meta<Key>V: MenuItem(NewVariant) \n \
586    :Ctrl<Key>o: MenuItem(LoadGame) \n \
587    :Meta<Key>Next: MenuItem(LoadNextGameProc) \n \
588    :Meta<Key>Prior: MenuItem(LoadPrevGameProc) \n \
589    :Ctrl<Key>Down: LoadSelectedProc(3) \n \
590    :Ctrl<Key>Up: LoadSelectedProc(-3) \n \
591    :Ctrl<Key>s: MenuItem(SaveGame) \n \
592    :Ctrl<Key>c: MenuItem(CopyGame) \n \
593    :Ctrl<Key>v: MenuItem(PasteGame) \n \
594    :Ctrl<Key>O: MenuItem(LoadPosition) \n \
595    :Shift<Key>Next: MenuItem(LoadNextPositionProc) \n \
596    :Shift<Key>Prior: MenuItem(LoadPrevPositionProc) \n \
597    :Ctrl<Key>S: MenuItem(SavePosition) \n \
598    :Ctrl<Key>C: MenuItem(CopyPosition) \n \
599    :Ctrl<Key>V: MenuItem(PastePosition) \n \
600    :Ctrl<Key>q: MenuItem(Exit) \n \
601    :Ctrl<Key>w: MenuItem(MachineWhite) \n \
602    :Ctrl<Key>b: MenuItem(MachineBlack) \n \
603    :Ctrl<Key>t: MenuItem(TwoMachines) \n \
604    :Ctrl<Key>a: MenuItem(AnalysisMode) \n \
605    :Ctrl<Key>g: MenuItem(AnalyzeFile) \n \
606    :Ctrl<Key>e: MenuItem(EditGame) \n \
607    :Ctrl<Key>E: MenuItem(EditPosition) \n \
608    :Meta<Key>O: MenuItem(ShowEngineOutput) \n \
609    :Meta<Key>E: MenuItem(ShowEvaluationGraph) \n \
610    :Meta<Key>G: MenuItem(ShowGameList) \n \
611    :Meta<Key>H: MenuItem(ShowMoveHistory) \n \
612    :<Key>Pause: MenuItem(Pause) \n \
613    :<Key>F3: MenuItem(Accept) \n \
614    :<Key>F4: MenuItem(Decline) \n \
615    :<Key>F12: MenuItem(Rematch) \n \
616    :<Key>F5: MenuItem(CallFlag) \n \
617    :<Key>F6: MenuItem(Draw) \n \
618    :<Key>F7: MenuItem(Adjourn) \n \
619    :<Key>F8: MenuItem(Abort) \n \
620    :<Key>F10: MenuItem(StopObserving) \n \
621    :<Key>F11: MenuItem(StopExamining) \n \
622    :Ctrl<Key>d: MenuItem(DebugProc) \n \
623    :Meta Ctrl<Key>F12: MenuItem(DebugProc) \n \
624    :Meta<Key>End: MenuItem(ToEnd) \n \
625    :Meta<Key>Right: MenuItem(Forward) \n \
626    :Meta<Key>Home: MenuItem(ToStart) \n \
627    :Meta<Key>Left: MenuItem(Backward) \n \
628    :<Key>Left: MenuItem(Backward) \n \
629    :<Key>Right: MenuItem(Forward) \n \
630    :<Key>Home: MenuItem(Revert) \n \
631    :<Key>End: MenuItem(TruncateGame) \n \
632    :Ctrl<Key>m: MenuItem(MoveNow) \n \
633    :Ctrl<Key>x: MenuItem(RetractMove) \n \
634    :Meta<Key>J: MenuItem(Adjudications) \n \
635    :Meta<Key>U: MenuItem(CommonEngine) \n \
636    :Meta<Key>T: MenuItem(TimeControl) \n \
637    :Ctrl<Key>P: MenuItem(PonderNextMove) \n "
638 #ifndef OPTIONSDIALOG
639     "\
640    :Ctrl<Key>Q: MenuItem(AlwaysQueenProc) \n \
641    :Ctrl<Key>F: MenuItem(AutoflagProc) \n \
642    :Ctrl<Key>A: MenuItem(AnimateMovingProc) \n \
643    :Ctrl<Key>L: MenuItem(TestLegalityProc) \n \
644    :Ctrl<Key>H: MenuItem(HideThinkingProc) \n "
645 #endif
646    "\
647    :<Key>F1: MenuItem(Manual) \n \
648    :<Key>F2: MenuItem(FlipView) \n \
649    :<KeyDown>Return: TempBackwardProc() \n \
650    :<KeyUp>Return: TempForwardProc() \n";
651
652 char boardTranslations[] =
653    "<Btn1Down>: HandleUserMove(0) \n \
654    Shift<Btn1Up>: HandleUserMove(1) \n \
655    <Btn1Up>: HandleUserMove(0) \n \
656    <Btn1Motion>: AnimateUserMove() \n \
657    <Btn3Motion>: HandlePV() \n \
658    <Btn2Motion>: HandlePV() \n \
659    <Btn3Up>: PieceMenuPopup(menuB) \n \
660    <Btn2Up>: PieceMenuPopup(menuB) \n \
661    Shift<Btn2Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD)\
662                  PieceMenuPopup(menuB) \n \
663    Any<Btn2Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD) \
664                  PieceMenuPopup(menuW) \n \
665    Shift<Btn3Down>: XawPositionSimpleMenu(menuW) XawPositionSimpleMenu(menuD)\
666                  PieceMenuPopup(menuW) \n \
667    Any<Btn3Down>: XawPositionSimpleMenu(menuB) XawPositionSimpleMenu(menuD) \
668                  PieceMenuPopup(menuB) \n";
669
670 char whiteTranslations[] =
671    "Shift<BtnDown>: WhiteClock(1)\n \
672    <BtnDown>: WhiteClock(0)\n";
673 char blackTranslations[] =
674    "Shift<BtnDown>: BlackClock(1)\n \
675    <BtnDown>: BlackClock(0)\n";
676
677 char ICSInputTranslations[] =
678     "<Key>Up: UpKeyProc() \n "
679     "<Key>Down: DownKeyProc() \n "
680     "<Key>Return: EnterKeyProc() \n";
681
682 // [HGM] vari: another hideous kludge: call extend-end first so we can be sure select-start works,
683 //             as the widget is destroyed before the up-click can call extend-end
684 char commentTranslations[] = "<Btn3Down>: extend-end() select-start() CommentClick() \n";
685
686 String xboardResources[] = {
687     "*fileName*value.translations: #override\\n <Key>Return: FileNameAction()",
688     "*question*value.translations: #override\\n <Key>Return: AskQuestionReplyAction()",
689     "*errorpopup*translations: #override\\n <Key>Return: ErrorPopDown()",
690     NULL
691   };
692
693
694 /* Max possible square size */
695 #define MAXSQSIZE 256
696
697 static int xpm_avail[MAXSQSIZE];
698
699 #ifdef HAVE_DIR_STRUCT
700
701 /* Extract piece size from filename */
702 static int
703 xpm_getsize (char *name, int len, char *ext)
704 {
705     char *p, *d;
706     char buf[10];
707
708     if (len < 4)
709       return 0;
710
711     if ((p=strchr(name, '.')) == NULL ||
712         StrCaseCmp(p+1, ext) != 0)
713       return 0;
714
715     p = name + 3;
716     d = buf;
717
718     while (*p && isdigit(*p))
719       *(d++) = *(p++);
720
721     *d = 0;
722     return atoi(buf);
723 }
724
725 /* Setup xpm_avail */
726 static int
727 xpm_getavail (char *dirname, char *ext)
728 {
729     DIR *dir;
730     struct dirent *ent;
731     int  i;
732
733     for (i=0; i<MAXSQSIZE; ++i)
734       xpm_avail[i] = 0;
735
736     if (appData.debugMode)
737       fprintf(stderr, "XPM dir:%s:ext:%s:\n", dirname, ext);
738
739     dir = opendir(dirname);
740     if (!dir)
741       {
742           fprintf(stderr, _("%s: Can't access XPM directory %s\n"),
743                   programName, dirname);
744           exit(1);
745       }
746
747     while ((ent=readdir(dir)) != NULL) {
748         i = xpm_getsize(ent->d_name, NAMLEN(ent), ext);
749         if (i > 0 && i < MAXSQSIZE)
750           xpm_avail[i] = 1;
751     }
752
753     closedir(dir);
754
755     return 0;
756 }
757
758 void
759 xpm_print_avail (FILE *fp, char *ext)
760 {
761     int i;
762
763     fprintf(fp, _("Available `%s' sizes:\n"), ext);
764     for (i=1; i<MAXSQSIZE; ++i) {
765         if (xpm_avail[i])
766           printf("%d\n", i);
767     }
768 }
769
770 /* Return XPM piecesize closest to size */
771 int
772 xpm_closest_to (char *dirname, int size, char *ext)
773 {
774     int i;
775     int sm_diff = MAXSQSIZE;
776     int sm_index = 0;
777     int diff;
778
779     xpm_getavail(dirname, ext);
780
781     if (appData.debugMode)
782       xpm_print_avail(stderr, ext);
783
784     for (i=1; i<MAXSQSIZE; ++i) {
785         if (xpm_avail[i]) {
786             diff = size - i;
787             diff = (diff<0) ? -diff : diff;
788             if (diff < sm_diff) {
789                 sm_diff = diff;
790                 sm_index = i;
791             }
792         }
793     }
794
795     if (!sm_index) {
796         fprintf(stderr, _("Error: No `%s' files!\n"), ext);
797         exit(1);
798     }
799
800     return sm_index;
801 }
802 #else   /* !HAVE_DIR_STRUCT */
803 /* If we are on a system without a DIR struct, we can't
804    read the directory, so we can't collect a list of
805    filenames, etc., so we can't do any size-fitting. */
806 int
807 xpm_closest_to (char *dirname, int size, char *ext)
808 {
809     fprintf(stderr, _("\
810 Warning: No DIR structure found on this system --\n\
811          Unable to autosize for XPM/XIM pieces.\n\
812    Please report this error to %s.\n\
813    Include system type & operating system in message.\n"), PACKAGE_BUGREPORT););
814     return size;
815 }
816 #endif /* HAVE_DIR_STRUCT */
817
818 static char *cnames[9] = { "black", "red", "green", "yellow", "blue",
819                              "magenta", "cyan", "white" };
820 typedef struct {
821     int attr, bg, fg;
822 } TextColors;
823 TextColors textColors[(int)NColorClasses];
824
825 /* String is: "fg, bg, attr". Which is 0, 1, 2 */
826 static int
827 parse_color (char *str, int which)
828 {
829     char *p, buf[100], *d;
830     int i;
831
832     if (strlen(str) > 99)       /* watch bounds on buf */
833       return -1;
834
835     p = str;
836     d = buf;
837     for (i=0; i<which; ++i) {
838         p = strchr(p, ',');
839         if (!p)
840           return -1;
841         ++p;
842     }
843
844     /* Could be looking at something like:
845        black, , 1
846        .. in which case we want to stop on a comma also */
847     while (*p && *p != ',' && !isalpha(*p) && !isdigit(*p))
848       ++p;
849
850     if (*p == ',') {
851         return -1;              /* Use default for empty field */
852     }
853
854     if (which == 2 || isdigit(*p))
855       return atoi(p);
856
857     while (*p && isalpha(*p))
858       *(d++) = *(p++);
859
860     *d = 0;
861
862     for (i=0; i<8; ++i) {
863         if (!StrCaseCmp(buf, cnames[i]))
864           return which? (i+40) : (i+30);
865     }
866     if (!StrCaseCmp(buf, "default")) return -1;
867
868     fprintf(stderr, _("%s: unrecognized color %s\n"), programName, buf);
869     return -2;
870 }
871
872 static int
873 parse_cpair (ColorClass cc, char *str)
874 {
875     if ((textColors[(int)cc].fg=parse_color(str, 0)) == -2) {
876         fprintf(stderr, _("%s: can't parse foreground color in `%s'\n"),
877                 programName, str);
878         return -1;
879     }
880
881     /* bg and attr are optional */
882     textColors[(int)cc].bg = parse_color(str, 1);
883     if ((textColors[(int)cc].attr = parse_color(str, 2)) < 0) {
884         textColors[(int)cc].attr = 0;
885     }
886     return 0;
887 }
888
889
890 /* Arrange to catch delete-window events */
891 Atom wm_delete_window;
892 void
893 CatchDeleteWindow (Widget w, String procname)
894 {
895   char buf[MSG_SIZ];
896   XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
897   snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
898   XtAugmentTranslations(w, XtParseTranslationTable(buf));
899 }
900
901 void
902 BoardToTop ()
903 {
904   Arg args[16];
905   XtSetArg(args[0], XtNiconic, False);
906   XtSetValues(shellWidget, args, 1);
907
908   XtPopup(shellWidget, XtGrabNone); /* Raise if lowered  */
909 }
910
911 //---------------------------------------------------------------------------------------------------------
912 // some symbol definitions to provide the proper (= XBoard) context for the code in args.h
913 #define XBOARD True
914 #define JAWS_ARGS
915 #define CW_USEDEFAULT (1<<31)
916 #define ICS_TEXT_MENU_SIZE 90
917 #define DEBUG_FILE "xboard.debug"
918 #define SetCurrentDirectory chdir
919 #define GetCurrentDirectory(SIZE, NAME) getcwd(NAME, SIZE)
920 #define OPTCHAR "-"
921 #define SEPCHAR " "
922
923 // these two must some day move to frontend.h, when they are implemented
924 Boolean GameListIsUp();
925
926 // The option definition and parsing code common to XBoard and WinBoard is collected in this file
927 #include "args.h"
928
929 // front-end part of option handling
930
931 // [HGM] This platform-dependent table provides the location for storing the color info
932 extern char *crWhite, * crBlack;
933
934 void *
935 colorVariable[] = {
936   &appData.whitePieceColor,
937   &appData.blackPieceColor,
938   &appData.lightSquareColor,
939   &appData.darkSquareColor,
940   &appData.highlightSquareColor,
941   &appData.premoveHighlightColor,
942   &appData.lowTimeWarningColor,
943   NULL,
944   NULL,
945   NULL,
946   NULL,
947   NULL,
948   &crWhite,
949   &crBlack,
950   NULL
951 };
952
953 // [HGM] font: keep a font for each square size, even non-stndard ones
954 #define NUM_SIZES 18
955 #define MAX_SIZE 130
956 Boolean fontIsSet[NUM_FONTS], fontValid[NUM_FONTS][MAX_SIZE];
957 char *fontTable[NUM_FONTS][MAX_SIZE];
958
959 void
960 ParseFont (char *name, int number)
961 { // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
962   int size;
963   if(sscanf(name, "size%d:", &size)) {
964     // [HGM] font: font is meant for specific boardSize (likely from settings file);
965     //       defer processing it until we know if it matches our board size
966     if(size >= 0 && size<MAX_SIZE) { // for now, fixed limit
967         fontTable[number][size] = strdup(strchr(name, ':')+1);
968         fontValid[number][size] = True;
969     }
970     return;
971   }
972   switch(number) {
973     case 0: // CLOCK_FONT
974         appData.clockFont = strdup(name);
975       break;
976     case 1: // MESSAGE_FONT
977         appData.font = strdup(name);
978       break;
979     case 2: // COORD_FONT
980         appData.coordFont = strdup(name);
981       break;
982     default:
983       return;
984   }
985   fontIsSet[number] = True; // [HGM] font: indicate a font was specified (not from settings file)
986 }
987
988 void
989 SetFontDefaults ()
990 { // only 2 fonts currently
991   appData.clockFont = CLOCK_FONT_NAME;
992   appData.coordFont = COORD_FONT_NAME;
993   appData.font  =   DEFAULT_FONT_NAME;
994 }
995
996 void
997 CreateFonts ()
998 { // no-op, until we identify the code for this already in XBoard and move it here
999 }
1000
1001 void
1002 ParseColor (int n, char *name)
1003 { // in XBoard, just copy the color-name string
1004   if(colorVariable[n]) *(char**)colorVariable[n] = strdup(name);
1005 }
1006
1007 void
1008 ParseTextAttribs (ColorClass cc, char *s)
1009 {
1010     (&appData.colorShout)[cc] = strdup(s);
1011 }
1012
1013 void
1014 ParseBoardSize (void *addr, char *name)
1015 {
1016     appData.boardSize = strdup(name);
1017 }
1018
1019 void
1020 LoadAllSounds ()
1021 { // In XBoard the sound-playing program takes care of obtaining the actual sound
1022 }
1023
1024 void
1025 SetCommPortDefaults ()
1026 { // for now, this is a no-op, as the corresponding option does not exist in XBoard
1027 }
1028
1029 // [HGM] args: these three cases taken out to stay in front-end
1030 void
1031 SaveFontArg (FILE *f, ArgDescriptor *ad)
1032 {
1033   char *name;
1034   int i, n = (int)(intptr_t)ad->argLoc;
1035   switch(n) {
1036     case 0: // CLOCK_FONT
1037         name = appData.clockFont;
1038       break;
1039     case 1: // MESSAGE_FONT
1040         name = appData.font;
1041       break;
1042     case 2: // COORD_FONT
1043         name = appData.coordFont;
1044       break;
1045     default:
1046       return;
1047   }
1048   for(i=0; i<NUM_SIZES; i++) // [HGM] font: current font becomes standard for current size
1049     if(sizeDefaults[i].squareSize == squareSize) { // only for standard sizes!
1050         fontTable[n][squareSize] = strdup(name);
1051         fontValid[n][squareSize] = True;
1052         break;
1053   }
1054   for(i=0; i<MAX_SIZE; i++) if(fontValid[n][i]) // [HGM] font: store all standard fonts
1055     fprintf(f, OPTCHAR "%s" SEPCHAR "\"size%d:%s\"\n", ad->argName, i, fontTable[n][i]);
1056 }
1057
1058 void
1059 ExportSounds ()
1060 { // nothing to do, as the sounds are at all times represented by their text-string names already
1061 }
1062
1063 void
1064 SaveAttribsArg (FILE *f, ArgDescriptor *ad)
1065 {       // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
1066         fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)(intptr_t)ad->argLoc]);
1067 }
1068
1069 void
1070 SaveColor (FILE *f, ArgDescriptor *ad)
1071 {       // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
1072         if(colorVariable[(int)(intptr_t)ad->argLoc])
1073         fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)(intptr_t)ad->argLoc]);
1074 }
1075
1076 void
1077 SaveBoardSize (FILE *f, char *name, void *addr)
1078 { // wrapper to shield back-end from BoardSize & sizeInfo
1079   fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
1080 }
1081
1082 void
1083 ParseCommPortSettings (char *s)
1084 { // no such option in XBoard (yet)
1085 }
1086
1087 extern Widget engineOutputShell;
1088 int frameX, frameY;
1089
1090 void
1091 GetActualPlacement (Widget wg, WindowPlacement *wp)
1092 {
1093   Arg args[16];
1094   Dimension w, h;
1095   Position x, y;
1096   XWindowAttributes winAt;
1097   Window win, dummy;
1098   int i, rx, ry;
1099
1100   if(!wg) return;
1101
1102     win = XtWindow(wg);
1103     XGetWindowAttributes(xDisplay, win, &winAt); // this works, where XtGetValues on XtNx, XtNy does not!
1104     XTranslateCoordinates (xDisplay, win, winAt.root, -winAt.border_width, -winAt.border_width, &rx, &ry, &dummy);
1105     wp->x = rx - winAt.x;
1106     wp->y = ry - winAt.y;
1107     wp->height = winAt.height;
1108     wp->width = winAt.width;
1109     frameX = winAt.x; frameY = winAt.y; // remember to decide if windows touch
1110 }
1111
1112 void
1113 GetWindowCoords ()
1114 { // wrapper to shield use of window handles from back-end (make addressible by number?)
1115   // In XBoard this will have to wait until awareness of window parameters is implemented
1116   GetActualPlacement(shellWidget, &wpMain);
1117   if(EngineOutputIsUp()) GetActualPlacement(engineOutputShell, &wpEngineOutput);
1118   if(MoveHistoryIsUp()) GetActualPlacement(shells[7], &wpMoveHistory);
1119   if(EvalGraphIsUp()) GetActualPlacement(evalGraphShell, &wpEvalGraph);
1120   if(GameListIsUp()) GetActualPlacement(gameListShell, &wpGameList);
1121   if(shellUp[1]) GetActualPlacement(shells[1], &wpComment);
1122   if(shellUp[2]) GetActualPlacement(shells[2], &wpTags);
1123 }
1124
1125 void
1126 PrintCommPortSettings (FILE *f, char *name)
1127 { // This option does not exist in XBoard
1128 }
1129
1130 int
1131 MySearchPath (char *installDir, char *name, char *fullname)
1132 { // just append installDir and name. Perhaps ExpandPath should be used here?
1133   name = ExpandPathName(name);
1134   if(name && name[0] == '/')
1135     safeStrCpy(fullname, name, MSG_SIZ );
1136   else {
1137     sprintf(fullname, "%s%c%s", installDir, '/', name);
1138   }
1139   return 1;
1140 }
1141
1142 int
1143 MyGetFullPathName (char *name, char *fullname)
1144 { // should use ExpandPath?
1145   name = ExpandPathName(name);
1146   safeStrCpy(fullname, name, MSG_SIZ );
1147   return 1;
1148 }
1149
1150 void
1151 EnsureOnScreen (int *x, int *y, int minX, int minY)
1152 {
1153   return;
1154 }
1155
1156 int
1157 MainWindowUp ()
1158 { // [HGM] args: allows testing if main window is realized from back-end
1159   return xBoardWindow != 0;
1160 }
1161
1162 void
1163 PopUpStartupDialog ()
1164 {  // start menu not implemented in XBoard
1165 }
1166
1167 char *
1168 ConvertToLine (int argc, char **argv)
1169 {
1170   static char line[128*1024], buf[1024];
1171   int i;
1172
1173   line[0] = NULLCHAR;
1174   for(i=1; i<argc; i++)
1175     {
1176       if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') || argv[i][0] == NULLCHAR)
1177           && argv[i][0] != '{' )
1178         snprintf(buf, sizeof(buf)/sizeof(buf[0]), "{%s} ", argv[i]);
1179       else
1180         snprintf(buf, sizeof(buf)/sizeof(buf[0]), "%s ", argv[i]);
1181       strncat(line, buf, 128*1024 - strlen(line) - 1 );
1182     }
1183
1184   line[strlen(line)-1] = NULLCHAR;
1185   return line;
1186 }
1187
1188 //--------------------------------------------------------------------------------------------
1189
1190 #ifdef IDSIZES
1191   // eventually, all layout determining code should go into a subroutine, but until then IDSIZE remains undefined
1192 #else
1193 #define BoardSize int
1194 void
1195 InitDrawingSizes (BoardSize boardSize, int flags)
1196 {   // [HGM] resize is functional now, but for board format changes only (nr of ranks, files)
1197     Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
1198     Arg args[16];
1199     XtGeometryResult gres;
1200     int i;
1201     static Dimension oldWidth, oldHeight;
1202     static VariantClass oldVariant;
1203     static int oldDual = -1, oldMono = -1;
1204
1205     if(!formWidget) return;
1206
1207     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
1208     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
1209     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
1210
1211   if(boardWidth != oldWidth || boardHeight != oldHeight || oldDual != twoBoards) { // do resizing stuff only if size actually changed
1212     /*
1213      * Enable shell resizing.
1214      */
1215     shellArgs[0].value = (XtArgVal) &w;
1216     shellArgs[1].value = (XtArgVal) &h;
1217     XtGetValues(shellWidget, shellArgs, 2);
1218
1219     shellArgs[4].value = 3*w; shellArgs[2].value = 10;
1220     shellArgs[5].value = 2*h; shellArgs[3].value = 10;
1221     XtSetValues(shellWidget, &shellArgs[2], 4);
1222
1223     XtSetArg(args[0], XtNdefaultDistance, &sep);
1224     XtGetValues(formWidget, args, 1);
1225
1226     oldWidth = boardWidth; oldHeight = boardHeight; oldDual = twoBoards;
1227     CreateGrid();
1228     hOffset = boardWidth + 10;
1229     for(i=0; i<BOARD_WIDTH+BOARD_HEIGHT+2; i++) { // [HGM] dual: grid for second board
1230         secondSegments[i] = gridSegments[i];
1231         secondSegments[i].x1 += hOffset;
1232         secondSegments[i].x2 += hOffset;
1233     }
1234
1235     XtSetArg(args[0], XtNwidth, boardWidth);
1236     XtSetArg(args[1], XtNheight, boardHeight);
1237     XtSetValues(boardWidget, args, 2);
1238
1239     timerWidth = (boardWidth - sep) / 2;
1240     XtSetArg(args[0], XtNwidth, timerWidth);
1241     XtSetValues(whiteTimerWidget, args, 1);
1242     XtSetValues(blackTimerWidget, args, 1);
1243
1244     XawFormDoLayout(formWidget, False);
1245
1246     if (appData.titleInWindow) {
1247         i = 0;
1248         XtSetArg(args[i], XtNborderWidth, &bor); i++;
1249         XtSetArg(args[i], XtNheight, &h);  i++;
1250         XtGetValues(titleWidget, args, i);
1251         if (smallLayout) {
1252             w = boardWidth - 2*bor;
1253         } else {
1254             XtSetArg(args[0], XtNwidth, &w);
1255             XtGetValues(menuBarWidget, args, 1);
1256             w = boardWidth - w - sep - 2*bor - 2; // WIDTH_FUDGE
1257         }
1258
1259         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
1260         if (gres != XtGeometryYes && appData.debugMode) {
1261             fprintf(stderr,
1262                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),
1263                     programName, gres, w, h, wr, hr);
1264         }
1265     }
1266
1267     XawFormDoLayout(formWidget, True);
1268
1269     /*
1270      * Inhibit shell resizing.
1271      */
1272     shellArgs[0].value = w = (XtArgVal) boardWidth + marginW + twoBoards*hOffset; // [HGM] dual
1273     shellArgs[1].value = h = (XtArgVal) boardHeight + marginH;
1274     shellArgs[4].value = shellArgs[2].value = w;
1275     shellArgs[5].value = shellArgs[3].value = h;
1276     XtSetValues(shellWidget, &shellArgs[0], 6);
1277
1278     XSync(xDisplay, False);
1279     DelayedDrag();
1280   }
1281
1282     // [HGM] pieces: tailor piece bitmaps to needs of specific variant
1283     // (only for xpm)
1284
1285   if(gameInfo.variant != oldVariant) { // and only if variant changed
1286
1287     if(useImages) {
1288       for(i=0; i<4; i++) {
1289         int p;
1290         for(p=0; p<=(int)WhiteKing; p++)
1291            xpmPieceBitmap[i][p] = xpmPieceBitmap2[i][p]; // defaults
1292         if(gameInfo.variant == VariantShogi) {
1293            xpmPieceBitmap[i][(int)WhiteCannon] = xpmPieceBitmap2[i][(int)WhiteKing+1];
1294            xpmPieceBitmap[i][(int)WhiteNightrider] = xpmPieceBitmap2[i][(int)WhiteKing+2];
1295            xpmPieceBitmap[i][(int)WhiteSilver] = xpmPieceBitmap2[i][(int)WhiteKing+3];
1296            xpmPieceBitmap[i][(int)WhiteGrasshopper] = xpmPieceBitmap2[i][(int)WhiteKing+4];
1297            xpmPieceBitmap[i][(int)WhiteQueen] = xpmPieceBitmap2[i][(int)WhiteLance];
1298         }
1299 #ifdef GOTHIC
1300         if(gameInfo.variant == VariantGothic) {
1301            xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteSilver];
1302         }
1303 #endif
1304         if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
1305            xpmPieceBitmap[i][(int)WhiteAngel]    = xpmPieceBitmap2[i][(int)WhiteFalcon];
1306            xpmPieceBitmap[i][(int)WhiteMarshall] = xpmPieceBitmap2[i][(int)WhiteAlfil];
1307         }
1308 #if !HAVE_LIBXPM
1309         // [HGM] why are thee ximMasks used at all? the ximPieceBitmaps seem to be never used!
1310         for(p=0; p<=(int)WhiteKing; p++)
1311            ximMaskPm[p] = ximMaskPm2[p]; // defaults
1312         if(gameInfo.variant == VariantShogi) {
1313            ximMaskPm[(int)WhiteCannon] = ximMaskPm2[(int)WhiteKing+1];
1314            ximMaskPm[(int)WhiteNightrider] = ximMaskPm2[(int)WhiteKing+2];
1315            ximMaskPm[(int)WhiteSilver] = ximMaskPm2[(int)WhiteKing+3];
1316            ximMaskPm[(int)WhiteGrasshopper] = ximMaskPm2[(int)WhiteKing+4];
1317            ximMaskPm[(int)WhiteQueen] = ximMaskPm2[(int)WhiteLance];
1318         }
1319 #ifdef GOTHIC
1320         if(gameInfo.variant == VariantGothic) {
1321            ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteSilver];
1322         }
1323 #endif
1324         if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
1325            ximMaskPm[(int)WhiteAngel]    = ximMaskPm2[(int)WhiteFalcon];
1326            ximMaskPm[(int)WhiteMarshall] = ximMaskPm2[(int)WhiteAlfil];
1327         }
1328 #endif
1329       }
1330     } else {
1331       for(i=0; i<2; i++) {
1332         int p;
1333         for(p=0; p<=(int)WhiteKing; p++)
1334            pieceBitmap[i][p] = pieceBitmap2[i][p]; // defaults
1335         if(gameInfo.variant == VariantShogi) {
1336            pieceBitmap[i][(int)WhiteCannon] = pieceBitmap2[i][(int)WhiteKing+1];
1337            pieceBitmap[i][(int)WhiteNightrider] = pieceBitmap2[i][(int)WhiteKing+2];
1338            pieceBitmap[i][(int)WhiteSilver] = pieceBitmap2[i][(int)WhiteKing+3];
1339            pieceBitmap[i][(int)WhiteGrasshopper] = pieceBitmap2[i][(int)WhiteKing+4];
1340            pieceBitmap[i][(int)WhiteQueen] = pieceBitmap2[i][(int)WhiteLance];
1341         }
1342 #ifdef GOTHIC
1343         if(gameInfo.variant == VariantGothic) {
1344            pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteSilver];
1345         }
1346 #endif
1347         if(gameInfo.variant == VariantSChess && (squareSize == 49 || squareSize == 72)) {
1348            pieceBitmap[i][(int)WhiteAngel]    = pieceBitmap2[i][(int)WhiteFalcon];
1349            pieceBitmap[i][(int)WhiteMarshall] = pieceBitmap2[i][(int)WhiteAlfil];
1350         }
1351       }
1352     }
1353     oldMono = -10; // kludge to force recreation of animation masks
1354     oldVariant = gameInfo.variant;
1355   }
1356 #if HAVE_LIBXPM
1357   if(appData.monoMode != oldMono)
1358     CreateAnimVars();
1359 #endif
1360   oldMono = appData.monoMode;
1361 }
1362 #endif
1363
1364 void
1365 ParseIcsTextColors ()
1366 {   // [HGM] tken out of main(), so it can be called from ICS-Options dialog
1367     if (parse_cpair(ColorShout, appData.colorShout) < 0 ||
1368         parse_cpair(ColorSShout, appData.colorSShout) < 0 ||
1369         parse_cpair(ColorChannel1, appData.colorChannel1) < 0  ||
1370         parse_cpair(ColorChannel, appData.colorChannel) < 0  ||
1371         parse_cpair(ColorKibitz, appData.colorKibitz) < 0 ||
1372         parse_cpair(ColorTell, appData.colorTell) < 0 ||
1373         parse_cpair(ColorChallenge, appData.colorChallenge) < 0  ||
1374         parse_cpair(ColorRequest, appData.colorRequest) < 0  ||
1375         parse_cpair(ColorSeek, appData.colorSeek) < 0  ||
1376         parse_cpair(ColorNormal, appData.colorNormal) < 0)
1377       {
1378           if (appData.colorize) {
1379               fprintf(stderr,
1380                       _("%s: can't parse color names; disabling colorization\n"),
1381                       programName);
1382           }
1383           appData.colorize = FALSE;
1384       }
1385 }
1386
1387 int
1388 MakeOneColor (char *name, Pixel *color)
1389 {
1390     XrmValue vFrom, vTo;
1391     if (!appData.monoMode) {
1392         vFrom.addr = (caddr_t) name;
1393         vFrom.size = strlen(name);
1394         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
1395         if (vTo.addr == NULL) {
1396           appData.monoMode = True;
1397           return True;
1398         } else {
1399           *color = *(Pixel *) vTo.addr;
1400         }
1401     }
1402     return False;
1403 }
1404
1405 int
1406 MakeColors ()
1407 {   // [HGM] taken out of main(), so it can be called from BoardOptions dialog
1408     int forceMono = False;
1409
1410     forceMono |= MakeOneColor(appData.lightSquareColor, &lightSquareColor);
1411     forceMono |= MakeOneColor(appData.darkSquareColor, &darkSquareColor);
1412     forceMono |= MakeOneColor(appData.whitePieceColor, &whitePieceColor);
1413     forceMono |= MakeOneColor(appData.blackPieceColor, &blackPieceColor);
1414     forceMono |= MakeOneColor(appData.highlightSquareColor, &highlightSquareColor);
1415     forceMono |= MakeOneColor(appData.premoveHighlightColor, &premoveHighlightColor);
1416
1417     return forceMono;
1418 }
1419
1420 void
1421 CreateAnyPieces ()
1422 {   // [HGM] taken out of main
1423 #if HAVE_LIBXPM
1424     if (appData.monoMode && // [HGM] no sense to go on to certain doom
1425        (appData.bitmapDirectory == NULL || appData.bitmapDirectory[0] == NULLCHAR))
1426             appData.bitmapDirectory = strdup(DEF_BITMAP_DIR);
1427
1428     if (appData.bitmapDirectory[0] != NULLCHAR) {
1429       CreatePieces();
1430     } else {
1431       CreateXPMPieces();
1432       CreateXPMBoard(appData.liteBackTextureFile, 1);
1433       CreateXPMBoard(appData.darkBackTextureFile, 0);
1434     }
1435 #else
1436     CreateXIMPieces();
1437     /* Create regular pieces */
1438     if (!useImages) CreatePieces();
1439 #endif
1440 }
1441
1442 int
1443 main (int argc, char **argv)
1444 {
1445     int i, j, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
1446     XSetWindowAttributes window_attributes;
1447     Arg args[16];
1448     Dimension timerWidth, boardWidth, boardHeight, w, h, sep, bor, wr, hr;
1449     XrmValue vFrom, vTo;
1450     XtGeometryResult gres;
1451     char *p;
1452     XrmDatabase xdb;
1453     int forceMono = False;
1454
1455     srandom(time(0)); // [HGM] book: make random truly random
1456
1457     setbuf(stdout, NULL);
1458     setbuf(stderr, NULL);
1459     debugFP = stderr;
1460
1461     if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
1462         printf("%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);
1463         exit(0);
1464     }
1465
1466     programName = strrchr(argv[0], '/');
1467     if (programName == NULL)
1468       programName = argv[0];
1469     else
1470       programName++;
1471
1472 #ifdef ENABLE_NLS
1473     XtSetLanguageProc(NULL, NULL, NULL);
1474     bindtextdomain(PACKAGE, LOCALEDIR);
1475     textdomain(PACKAGE);
1476 #endif
1477
1478     shellWidget =
1479       XtAppInitialize(&appContext, "XBoard", shellOptions,
1480                       XtNumber(shellOptions),
1481                       &argc, argv, xboardResources, NULL, 0);
1482     appData.boardSize = "";
1483     InitAppData(ConvertToLine(argc, argv));
1484     p = getenv("HOME");
1485     if (p == NULL) p = "/tmp";
1486     i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
1487     gameCopyFilename = (char*) malloc(i);
1488     gamePasteFilename = (char*) malloc(i);
1489     snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
1490     snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
1491
1492     XtGetApplicationResources(shellWidget, (XtPointer) &appData,
1493                               clientResources, XtNumber(clientResources),
1494                               NULL, 0);
1495
1496     { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
1497         static char buf[MSG_SIZ];
1498         EscapeExpand(buf, appData.firstInitString);
1499         appData.firstInitString = strdup(buf);
1500         EscapeExpand(buf, appData.secondInitString);
1501         appData.secondInitString = strdup(buf);
1502         EscapeExpand(buf, appData.firstComputerString);
1503         appData.firstComputerString = strdup(buf);
1504         EscapeExpand(buf, appData.secondComputerString);
1505         appData.secondComputerString = strdup(buf);
1506     }
1507
1508     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
1509         chessDir = ".";
1510     } else {
1511         if (chdir(chessDir) != 0) {
1512             fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
1513             perror(chessDir);
1514             exit(1);
1515         }
1516     }
1517
1518     if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
1519         /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
1520         if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL)  {
1521            printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
1522            exit(errno);
1523         }
1524         setbuf(debugFP, NULL);
1525     }
1526
1527 #if ENABLE_NLS
1528     if (appData.debugMode) {
1529       fprintf(debugFP, "locale = %s\n", setlocale(LC_ALL, NULL));
1530     }
1531 #endif
1532
1533     /* [HGM,HR] make sure board size is acceptable */
1534     if(appData.NrFiles > BOARD_FILES ||
1535        appData.NrRanks > BOARD_RANKS   )
1536          DisplayFatalError(_("Recompile with larger BOARD_RANKS or BOARD_FILES to support this size"), 0, 2);
1537
1538 #if !HIGHDRAG
1539     /* This feature does not work; animation needs a rewrite */
1540     appData.highlightDragging = FALSE;
1541 #endif
1542     InitBackEnd1();
1543
1544     xDisplay = XtDisplay(shellWidget);
1545     xScreen = DefaultScreen(xDisplay);
1546     wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
1547
1548         gameInfo.variant = StringToVariant(appData.variant);
1549         InitPosition(FALSE);
1550
1551 #ifdef IDSIZE
1552     InitDrawingSizes(-1, 0); // [HGM] initsize: make this into a subroutine
1553 #else
1554     if (isdigit(appData.boardSize[0])) {
1555         i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
1556                    &lineGap, &clockFontPxlSize, &coordFontPxlSize,
1557                    &fontPxlSize, &smallLayout, &tinyLayout);
1558         if (i == 0) {
1559             fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
1560                     programName, appData.boardSize);
1561             exit(2);
1562         }
1563         if (i < 7) {
1564             /* Find some defaults; use the nearest known size */
1565             SizeDefaults *szd, *nearest;
1566             int distance = 99999;
1567             nearest = szd = sizeDefaults;
1568             while (szd->name != NULL) {
1569                 if (abs(szd->squareSize - squareSize) < distance) {
1570                     nearest = szd;
1571                     distance = abs(szd->squareSize - squareSize);
1572                     if (distance == 0) break;
1573                 }
1574                 szd++;
1575             }
1576             if (i < 2) lineGap = nearest->lineGap;
1577             if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
1578             if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
1579             if (i < 5) fontPxlSize = nearest->fontPxlSize;
1580             if (i < 6) smallLayout = nearest->smallLayout;
1581             if (i < 7) tinyLayout = nearest->tinyLayout;
1582         }
1583     } else {
1584         SizeDefaults *szd = sizeDefaults;
1585         if (*appData.boardSize == NULLCHAR) {
1586             while (DisplayWidth(xDisplay, xScreen) < szd->minScreenSize ||
1587                    DisplayHeight(xDisplay, xScreen) < szd->minScreenSize) {
1588               szd++;
1589             }
1590             if (szd->name == NULL) szd--;
1591             appData.boardSize = strdup(szd->name); // [HGM] settings: remember name for saving settings
1592         } else {
1593             while (szd->name != NULL &&
1594                    StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
1595             if (szd->name == NULL) {
1596                 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
1597                         programName, appData.boardSize);
1598                 exit(2);
1599             }
1600         }
1601         squareSize = szd->squareSize;
1602         lineGap = szd->lineGap;
1603         clockFontPxlSize = szd->clockFontPxlSize;
1604         coordFontPxlSize = szd->coordFontPxlSize;
1605         fontPxlSize = szd->fontPxlSize;
1606         smallLayout = szd->smallLayout;
1607         tinyLayout = szd->tinyLayout;
1608         // [HGM] font: use defaults from settings file if available and not overruled
1609     }
1610     if(!fontIsSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
1611         appData.clockFont = fontTable[CLOCK_FONT][squareSize];
1612     if(!fontIsSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
1613         appData.font = fontTable[MESSAGE_FONT][squareSize];
1614     if(!fontIsSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
1615         appData.coordFont = fontTable[COORD_FONT][squareSize];
1616
1617     /* Now, using squareSize as a hint, find a good XPM/XIM set size */
1618     if (strlen(appData.pixmapDirectory) > 0) {
1619         p = ExpandPathName(appData.pixmapDirectory);
1620         if (!p) {
1621             fprintf(stderr, _("Error expanding path name \"%s\"\n"),
1622                    appData.pixmapDirectory);
1623             exit(1);
1624         }
1625         if (appData.debugMode) {
1626           fprintf(stderr, _("\
1627 XBoard square size (hint): %d\n\
1628 %s fulldir:%s:\n"), squareSize, IMAGE_EXT, p);
1629         }
1630         squareSize = xpm_closest_to(p, squareSize, IMAGE_EXT);
1631         if (appData.debugMode) {
1632             fprintf(stderr, _("Closest %s size: %d\n"), IMAGE_EXT, squareSize);
1633         }
1634     }
1635     defaultLineGap = lineGap;
1636     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
1637
1638     /* [HR] height treated separately (hacked) */
1639     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
1640     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
1641     if (appData.showJail == 1) {
1642         /* Jail on top and bottom */
1643         XtSetArg(boardArgs[1], XtNwidth, boardWidth);
1644         XtSetArg(boardArgs[2], XtNheight,
1645                  boardHeight + 2*(lineGap + squareSize));
1646     } else if (appData.showJail == 2) {
1647         /* Jail on sides */
1648         XtSetArg(boardArgs[1], XtNwidth,
1649                  boardWidth + 2*(lineGap + squareSize));
1650         XtSetArg(boardArgs[2], XtNheight, boardHeight);
1651     } else {
1652         /* No jail */
1653         XtSetArg(boardArgs[1], XtNwidth, boardWidth);
1654         XtSetArg(boardArgs[2], XtNheight, boardHeight);
1655     }
1656
1657     /*
1658      * Determine what fonts to use.
1659      */
1660 #if ENABLE_NLS
1661     appData.font = InsertPxlSize(appData.font, fontPxlSize);
1662     appData.clockFont = InsertPxlSize(appData.clockFont, clockFontPxlSize);
1663     appData.coordFont = InsertPxlSize(appData.coordFont, coordFontPxlSize);
1664     fontSet = CreateFontSet(appData.font);
1665     clockFontSet = CreateFontSet(appData.clockFont);
1666     {
1667       /* For the coordFont, use the 0th font of the fontset. */
1668       XFontSet coordFontSet = CreateFontSet(appData.coordFont);
1669       XFontStruct **font_struct_list;
1670       XFontSetExtents *fontSize;
1671       char **font_name_list;
1672       XFontsOfFontSet(coordFontSet, &font_struct_list, &font_name_list);
1673       coordFontID = XLoadFont(xDisplay, font_name_list[0]);
1674       coordFontStruct = XQueryFont(xDisplay, coordFontID);
1675       fontSize = XExtentsOfFontSet(fontSet); // [HGM] figure out how much vertical space font takes
1676       textHeight = fontSize->max_logical_extent.height + 5; // add borderWidth
1677     }
1678 #else
1679     appData.font = FindFont(appData.font, fontPxlSize);
1680     appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
1681     appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
1682     clockFontID = XLoadFont(xDisplay, appData.clockFont);
1683     clockFontStruct = XQueryFont(xDisplay, clockFontID);
1684     coordFontID = XLoadFont(xDisplay, appData.coordFont);
1685     coordFontStruct = XQueryFont(xDisplay, coordFontID);
1686 #endif
1687     countFontID = coordFontID;  // [HGM] holdings
1688     countFontStruct = coordFontStruct;
1689
1690     xdb = XtDatabase(xDisplay);
1691 #if ENABLE_NLS
1692     XrmPutLineResource(&xdb, "*international: True");
1693     vTo.size = sizeof(XFontSet);
1694     vTo.addr = (XtPointer) &fontSet;
1695     XrmPutResource(&xdb, "*fontSet", XtRFontSet, &vTo);
1696 #else
1697     XrmPutStringResource(&xdb, "*font", appData.font);
1698 #endif
1699
1700     /*
1701      * Detect if there are not enough colors available and adapt.
1702      */
1703     if (DefaultDepth(xDisplay, xScreen) <= 2) {
1704       appData.monoMode = True;
1705     }
1706
1707     forceMono = MakeColors();
1708
1709     if (forceMono) {
1710       fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
1711               programName);
1712         appData.monoMode = True;
1713     }
1714
1715     if (appData.lowTimeWarning && !appData.monoMode) {
1716       vFrom.addr = (caddr_t) appData.lowTimeWarningColor;
1717       vFrom.size = strlen(appData.lowTimeWarningColor);
1718       XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
1719       if (vTo.addr == NULL)
1720                 appData.monoMode = True;
1721       else
1722                 lowTimeWarningColor = *(Pixel *) vTo.addr;
1723     }
1724
1725     if (appData.monoMode && appData.debugMode) {
1726         fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
1727                 (unsigned long) XWhitePixel(xDisplay, xScreen),
1728                 (unsigned long) XBlackPixel(xDisplay, xScreen));
1729     }
1730
1731     ParseIcsTextColors();
1732     textColors[ColorNone].fg = textColors[ColorNone].bg = -1;
1733     textColors[ColorNone].attr = 0;
1734
1735     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
1736
1737     /*
1738      * widget hierarchy
1739      */
1740     if (tinyLayout) {
1741         layoutName = "tinyLayout";
1742     } else if (smallLayout) {
1743         layoutName = "smallLayout";
1744     } else {
1745         layoutName = "normalLayout";
1746     }
1747     /* Outer layoutWidget is there only to provide a name for use in
1748        resources that depend on the layout style */
1749     layoutWidget =
1750       XtCreateManagedWidget(layoutName, formWidgetClass, shellWidget,
1751                             layoutArgs, XtNumber(layoutArgs));
1752     formWidget =
1753       XtCreateManagedWidget("form", formWidgetClass, layoutWidget,
1754                             formArgs, XtNumber(formArgs));
1755     XtSetArg(args[0], XtNdefaultDistance, &sep);
1756     XtGetValues(formWidget, args, 1);
1757
1758     j = 0;
1759     widgetList[j++] = menuBarWidget = CreateMenuBar(menuBar, boardWidth);
1760     XtSetArg(args[0], XtNtop,    XtChainTop);
1761     XtSetArg(args[1], XtNbottom, XtChainTop);
1762     XtSetArg(args[2], XtNright,  XtChainLeft);
1763     XtSetValues(menuBarWidget, args, 3);
1764
1765     widgetList[j++] = whiteTimerWidget =
1766       XtCreateWidget("whiteTime", labelWidgetClass,
1767                      formWidget, timerArgs, XtNumber(timerArgs));
1768 #if ENABLE_NLS
1769     XtSetArg(args[0], XtNfontSet, clockFontSet);
1770 #else
1771     XtSetArg(args[0], XtNfont, clockFontStruct);
1772 #endif
1773     XtSetArg(args[1], XtNtop,    XtChainTop);
1774     XtSetArg(args[2], XtNbottom, XtChainTop);
1775     XtSetValues(whiteTimerWidget, args, 3);
1776
1777     widgetList[j++] = blackTimerWidget =
1778       XtCreateWidget("blackTime", labelWidgetClass,
1779                      formWidget, timerArgs, XtNumber(timerArgs));
1780 #if ENABLE_NLS
1781     XtSetArg(args[0], XtNfontSet, clockFontSet);
1782 #else
1783     XtSetArg(args[0], XtNfont, clockFontStruct);
1784 #endif
1785     XtSetArg(args[1], XtNtop,    XtChainTop);
1786     XtSetArg(args[2], XtNbottom, XtChainTop);
1787     XtSetValues(blackTimerWidget, args, 3);
1788
1789     if (appData.titleInWindow) {
1790         widgetList[j++] = titleWidget =
1791           XtCreateWidget("title", labelWidgetClass, formWidget,
1792                          titleArgs, XtNumber(titleArgs));
1793         XtSetArg(args[0], XtNtop,    XtChainTop);
1794         XtSetArg(args[1], XtNbottom, XtChainTop);
1795         XtSetValues(titleWidget, args, 2);
1796     }
1797
1798     if (appData.showButtonBar) {
1799       widgetList[j++] = buttonBarWidget = CreateButtonBar(buttonBar);
1800       XtSetArg(args[0], XtNleft,  XtChainRight); // [HGM] glue to right window edge
1801       XtSetArg(args[1], XtNright, XtChainRight); //       for good run-time sizing
1802       XtSetArg(args[2], XtNtop,    XtChainTop);
1803       XtSetArg(args[3], XtNbottom, XtChainTop);
1804       XtSetValues(buttonBarWidget, args, 4);
1805     }
1806
1807     widgetList[j++] = messageWidget =
1808       XtCreateWidget("message", labelWidgetClass, formWidget,
1809                      messageArgs, XtNumber(messageArgs));
1810     XtSetArg(args[0], XtNtop,    XtChainTop);
1811     XtSetArg(args[1], XtNbottom, XtChainTop);
1812     XtSetValues(messageWidget, args, 2);
1813
1814     widgetList[j++] = boardWidget =
1815       XtCreateWidget("board", widgetClass, formWidget, boardArgs,
1816                      XtNumber(boardArgs));
1817
1818     XtManageChildren(widgetList, j);
1819
1820     timerWidth = (boardWidth - sep) / 2;
1821     XtSetArg(args[0], XtNwidth, timerWidth);
1822     XtSetValues(whiteTimerWidget, args, 1);
1823     XtSetValues(blackTimerWidget, args, 1);
1824
1825     XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
1826     XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
1827     XtGetValues(whiteTimerWidget, args, 2);
1828
1829     if (appData.showButtonBar) {
1830       XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
1831       XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
1832       XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
1833     }
1834
1835     /*
1836      * formWidget uses these constraints but they are stored
1837      * in the children.
1838      */
1839     i = 0;
1840     XtSetArg(args[i], XtNfromHoriz, 0); i++;
1841     XtSetValues(menuBarWidget, args, i);
1842     if (appData.titleInWindow) {
1843         if (smallLayout) {
1844             i = 0;
1845             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
1846             XtSetValues(whiteTimerWidget, args, i);
1847             i = 0;
1848             XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
1849             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
1850             XtSetValues(blackTimerWidget, args, i);
1851             i = 0;
1852             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
1853             XtSetArg(args[i], XtNjustify, XtJustifyLeft); i++;
1854             XtSetValues(titleWidget, args, i);
1855             i = 0;
1856             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
1857             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
1858             XtSetValues(messageWidget, args, i);
1859             if (appData.showButtonBar) {
1860               i = 0;
1861               XtSetArg(args[i], XtNfromVert, titleWidget); i++;
1862               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
1863               XtSetValues(buttonBarWidget, args, i);
1864             }
1865         } else {
1866             i = 0;
1867             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
1868             XtSetValues(whiteTimerWidget, args, i);
1869             i = 0;
1870             XtSetArg(args[i], XtNfromVert, titleWidget); i++;
1871             XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
1872             XtSetValues(blackTimerWidget, args, i);
1873             i = 0;
1874             XtSetArg(args[i], XtNfromHoriz, menuBarWidget); i++;
1875             XtSetValues(titleWidget, args, i);
1876             i = 0;
1877             XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
1878             XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
1879             XtSetValues(messageWidget, args, i);
1880             if (appData.showButtonBar) {
1881               i = 0;
1882               XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
1883               XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
1884               XtSetValues(buttonBarWidget, args, i);
1885             }
1886         }
1887     } else {
1888         i = 0;
1889         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
1890         XtSetValues(whiteTimerWidget, args, i);
1891         i = 0;
1892         XtSetArg(args[i], XtNfromVert, menuBarWidget); i++;
1893         XtSetArg(args[i], XtNfromHoriz, whiteTimerWidget); i++;
1894         XtSetValues(blackTimerWidget, args, i);
1895         i = 0;
1896         XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
1897         XtSetArg(args[i], XtNresizable, (XtArgVal) True); i++;
1898         XtSetValues(messageWidget, args, i);
1899         if (appData.showButtonBar) {
1900           i = 0;
1901           XtSetArg(args[i], XtNfromVert, whiteTimerWidget); i++;
1902           XtSetArg(args[i], XtNfromHoriz, messageWidget); i++;
1903           XtSetValues(buttonBarWidget, args, i);
1904         }
1905     }
1906     i = 0;
1907     XtSetArg(args[0], XtNfromVert, messageWidget);
1908     XtSetArg(args[1], XtNtop,    XtChainTop);
1909     XtSetArg(args[2], XtNbottom, XtChainBottom);
1910     XtSetArg(args[3], XtNleft,   XtChainLeft);
1911     XtSetArg(args[4], XtNright,  XtChainRight);
1912     XtSetValues(boardWidget, args, 5);
1913
1914     XtRealizeWidget(shellWidget);
1915
1916     if(wpMain.x > 0) {
1917       XtSetArg(args[0], XtNx, wpMain.x);
1918       XtSetArg(args[1], XtNy, wpMain.y);
1919       XtSetValues(shellWidget, args, 2);
1920     }
1921
1922     /*
1923      * Correct the width of the message and title widgets.
1924      * It is not known why some systems need the extra fudge term.
1925      * The value "2" is probably larger than needed.
1926      */
1927     XawFormDoLayout(formWidget, False);
1928
1929 #define WIDTH_FUDGE 2
1930     i = 0;
1931     XtSetArg(args[i], XtNborderWidth, &bor);  i++;
1932     XtSetArg(args[i], XtNheight, &h);  i++;
1933     XtGetValues(messageWidget, args, i);
1934     if (appData.showButtonBar) {
1935       i = 0;
1936       XtSetArg(args[i], XtNwidth, &w);  i++;
1937       XtGetValues(buttonBarWidget, args, i);
1938       w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
1939     } else {
1940       w = boardWidth - 2*bor + 1; /*!! +1 compensates for kludge below */
1941     }
1942
1943     gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
1944     if (gres != XtGeometryYes && appData.debugMode) {
1945       fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
1946               programName, gres, w, h, wr, hr);
1947     }
1948
1949     /* !! Horrible hack to work around bug in XFree86 4.0.1 (X11R6.4.3) */
1950     /* The size used for the child widget in layout lags one resize behind
1951        its true size, so we resize a second time, 1 pixel smaller.  Yeech! */
1952     w--;
1953     gres = XtMakeResizeRequest(messageWidget, w, h, &wr, &hr);
1954     if (gres != XtGeometryYes && appData.debugMode) {
1955       fprintf(stderr, _("%s: messageWidget geometry error %d %d %d %d %d\n"),
1956               programName, gres, w, h, wr, hr);
1957     }
1958     /* !! end hack */
1959     if(!textHeight) textHeight = hr; // [HGM] if !NLS textHeight is still undefined, and we grab it from here
1960     XtSetArg(args[0], XtNleft,  XtChainLeft);  // [HGM] glue ends for good run-time sizing
1961     XtSetArg(args[1], XtNright, XtChainRight);
1962     XtSetValues(messageWidget, args, 2);
1963
1964     if (appData.titleInWindow) {
1965         i = 0;
1966         XtSetArg(args[i], XtNborderWidth, &bor); i++;
1967         XtSetArg(args[i], XtNheight, &h);  i++;
1968         XtGetValues(titleWidget, args, i);
1969         if (smallLayout) {
1970             w = boardWidth - 2*bor;
1971         } else {
1972             XtSetArg(args[0], XtNwidth, &w);
1973             XtGetValues(menuBarWidget, args, 1);
1974             w = boardWidth - w - sep - 2*bor - WIDTH_FUDGE;
1975         }
1976
1977         gres = XtMakeResizeRequest(titleWidget, w, h, &wr, &hr);
1978         if (gres != XtGeometryYes && appData.debugMode) {
1979             fprintf(stderr,
1980                     _("%s: titleWidget geometry error %d %d %d %d %d\n"),
1981                     programName, gres, w, h, wr, hr);
1982         }
1983     }
1984     XawFormDoLayout(formWidget, True);
1985
1986     xBoardWindow = XtWindow(boardWidget);
1987
1988     // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
1989     //       not need to go into InitDrawingSizes().
1990 #endif
1991
1992     /*
1993      * Create X checkmark bitmap and initialize option menu checks.
1994      */
1995     ReadBitmap(&xMarkPixmap, "checkmark.bm",
1996                checkmark_bits, checkmark_width, checkmark_height);
1997     InitMenuMarkers();
1998
1999     /*
2000      * Create an icon.
2001      */
2002     ReadBitmap(&wIconPixmap, "icon_white.bm",
2003                icon_white_bits, icon_white_width, icon_white_height);
2004     ReadBitmap(&bIconPixmap, "icon_black.bm",
2005                icon_black_bits, icon_black_width, icon_black_height);
2006     iconPixmap = wIconPixmap;
2007     i = 0;
2008     XtSetArg(args[i], XtNiconPixmap, iconPixmap);  i++;
2009     XtSetValues(shellWidget, args, i);
2010
2011     /*
2012      * Create a cursor for the board widget.
2013      */
2014     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
2015     XChangeWindowAttributes(xDisplay, xBoardWindow,
2016                             CWCursor, &window_attributes);
2017
2018     /*
2019      * Inhibit shell resizing.
2020      */
2021     shellArgs[0].value = (XtArgVal) &w;
2022     shellArgs[1].value = (XtArgVal) &h;
2023     XtGetValues(shellWidget, shellArgs, 2);
2024     shellArgs[4].value = shellArgs[2].value = w;
2025     shellArgs[5].value = shellArgs[3].value = h;
2026     XtSetValues(shellWidget, &shellArgs[2], 4);
2027     marginW =  w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
2028     marginH =  h - boardHeight;
2029
2030     CatchDeleteWindow(shellWidget, "QuitProc");
2031
2032     CreateGCs(False);
2033     CreateGrid();
2034     CreateAnyPieces();
2035
2036     CreatePieceMenus();
2037
2038     if (appData.animate || appData.animateDragging)
2039       CreateAnimVars();
2040
2041     XtAugmentTranslations(formWidget,
2042                           XtParseTranslationTable(globalTranslations));
2043     XtAugmentTranslations(boardWidget,
2044                           XtParseTranslationTable(boardTranslations));
2045     XtAugmentTranslations(whiteTimerWidget,
2046                           XtParseTranslationTable(whiteTranslations));
2047     XtAugmentTranslations(blackTimerWidget,
2048                           XtParseTranslationTable(blackTranslations));
2049
2050     /* Why is the following needed on some versions of X instead
2051      * of a translation? */
2052     XtAddEventHandler(boardWidget, ExposureMask|PointerMotionMask, False,
2053                       (XtEventHandler) EventProc, NULL);
2054     /* end why */
2055     XtAddEventHandler(formWidget, KeyPressMask, False,
2056                       (XtEventHandler) MoveTypeInProc, NULL);
2057     XtAddEventHandler(shellWidget, StructureNotifyMask, False,
2058                       (XtEventHandler) EventProc, NULL);
2059
2060     /* [AS] Restore layout */
2061     if( wpMoveHistory.visible ) {
2062       HistoryPopUp();
2063     }
2064
2065     if( wpEvalGraph.visible )
2066       {
2067         EvalGraphPopUp();
2068       };
2069
2070     if( wpEngineOutput.visible ) {
2071       EngineOutputPopUp();
2072     }
2073
2074     InitBackEnd2();
2075
2076     if (errorExitStatus == -1) {
2077         if (appData.icsActive) {
2078             /* We now wait until we see "login:" from the ICS before
2079                sending the logon script (problems with timestamp otherwise) */
2080             /*ICSInitScript();*/
2081             if (appData.icsInputBox) ICSInputBoxPopUp();
2082         }
2083
2084     #ifdef SIGWINCH
2085     signal(SIGWINCH, TermSizeSigHandler);
2086     #endif
2087         signal(SIGINT, IntSigHandler);
2088         signal(SIGTERM, IntSigHandler);
2089         if (*appData.cmailGameName != NULLCHAR) {
2090             signal(SIGUSR1, CmailSigHandler);
2091         }
2092     }
2093
2094     gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
2095     InitPosition(TRUE);
2096 //    XtSetKeyboardFocus(shellWidget, formWidget);
2097     XSetInputFocus(xDisplay, XtWindow(formWidget), RevertToPointerRoot, CurrentTime);
2098
2099     XtAppMainLoop(appContext);
2100     if (appData.debugMode) fclose(debugFP); // [DM] debug
2101     return 0;
2102 }
2103
2104 static Boolean noEcho;
2105
2106 void
2107 ShutDownFrontEnd ()
2108 {
2109     if (appData.icsActive && oldICSInteractionTitle != NULL) {
2110         DisplayIcsInteractionTitle(oldICSInteractionTitle);
2111     }
2112     if (saveSettingsOnExit) SaveSettings(settingsFileName);
2113     unlink(gameCopyFilename);
2114     unlink(gamePasteFilename);
2115     if(noEcho) EchoOn();
2116 }
2117
2118 RETSIGTYPE
2119 TermSizeSigHandler (int sig)
2120 {
2121     update_ics_width();
2122 }
2123
2124 RETSIGTYPE
2125 IntSigHandler (int sig)
2126 {
2127     ExitEvent(sig);
2128 }
2129
2130 RETSIGTYPE
2131 CmailSigHandler (int sig)
2132 {
2133     int dummy = 0;
2134     int error;
2135
2136     signal(SIGUSR1, SIG_IGN);   /* suspend handler     */
2137
2138     /* Activate call-back function CmailSigHandlerCallBack()             */
2139     OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
2140
2141     signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
2142 }
2143
2144 void
2145 CmailSigHandlerCallBack (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
2146 {
2147     BoardToTop();
2148     ReloadCmailMsgEvent(TRUE);  /* Reload cmail msg  */
2149 }
2150 /**** end signal code ****/
2151
2152
2153 void
2154 ICSInitScript ()
2155 {
2156   /* try to open the icsLogon script, either in the location given
2157    * or in the users HOME directory
2158    */
2159
2160   FILE *f;
2161   char buf[MSG_SIZ];
2162   char *homedir;
2163
2164   f = fopen(appData.icsLogon, "r");
2165   if (f == NULL)
2166     {
2167       homedir = getenv("HOME");
2168       if (homedir != NULL)
2169         {
2170           safeStrCpy(buf, homedir, sizeof(buf)/sizeof(buf[0]) );
2171           strncat(buf, "/", MSG_SIZ - strlen(buf) - 1);
2172           strncat(buf, appData.icsLogon,  MSG_SIZ - strlen(buf) - 1);
2173           f = fopen(buf, "r");
2174         }
2175     }
2176
2177   if (f != NULL)
2178     ProcessICSInitScript(f);
2179   else
2180     printf("Warning: Couldn't open icsLogon file (checked %s and %s).\n", appData.icsLogon, buf);
2181
2182   return;
2183 }
2184
2185 void
2186 ResetFrontEnd ()
2187 {
2188     CommentPopDown();
2189     TagsPopDown();
2190     return;
2191 }
2192
2193 // [HGM] code borrowed from winboard.c (which should thus go to backend.c!)
2194 #define HISTORY_SIZE 64
2195 static char *history[HISTORY_SIZE];
2196 int histIn = 0, histP = 0;
2197
2198 void
2199 SaveInHistory (char *cmd)
2200 {
2201   if (history[histIn] != NULL) {
2202     free(history[histIn]);
2203     history[histIn] = NULL;
2204   }
2205   if (*cmd == NULLCHAR) return;
2206   history[histIn] = StrSave(cmd);
2207   histIn = (histIn + 1) % HISTORY_SIZE;
2208   if (history[histIn] != NULL) {
2209     free(history[histIn]);
2210     history[histIn] = NULL;
2211   }
2212   histP = histIn;
2213 }
2214
2215 char *
2216 PrevInHistory (char *cmd)
2217 {
2218   int newhp;
2219   if (histP == histIn) {
2220     if (history[histIn] != NULL) free(history[histIn]);
2221     history[histIn] = StrSave(cmd);
2222   }
2223   newhp = (histP - 1 + HISTORY_SIZE) % HISTORY_SIZE;
2224   if (newhp == histIn || history[newhp] == NULL) return NULL;
2225   histP = newhp;
2226   return history[histP];
2227 }
2228
2229 char *
2230 NextInHistory ()
2231 {
2232   if (histP == histIn) return NULL;
2233   histP = (histP + 1) % HISTORY_SIZE;
2234   return history[histP];   
2235 }
2236 // end of borrowed code
2237
2238 #define Abs(n) ((n)<0 ? -(n) : (n))
2239
2240 #ifdef ENABLE_NLS
2241 char *
2242 InsertPxlSize (char *pattern, int targetPxlSize)
2243 {
2244     char *base_fnt_lst, strInt[12], *p, *q;
2245     int alternatives, i, len, strIntLen;
2246
2247     /*
2248      * Replace the "*" (if present) in the pixel-size slot of each
2249      * alternative with the targetPxlSize.
2250      */
2251     p = pattern;
2252     alternatives = 1;
2253     while ((p = strchr(p, ',')) != NULL) {
2254       alternatives++;
2255       p++;
2256     }
2257     snprintf(strInt, sizeof(strInt), "%d", targetPxlSize);
2258     strIntLen = strlen(strInt);
2259     base_fnt_lst = calloc(1, strlen(pattern) + strIntLen * alternatives + 1);
2260
2261     p = pattern;
2262     q = base_fnt_lst;
2263     while (alternatives--) {
2264       char *comma = strchr(p, ',');
2265       for (i=0; i<14; i++) {
2266         char *hyphen = strchr(p, '-');
2267         if (!hyphen) break;
2268         if (comma && hyphen > comma) break;
2269         len = hyphen + 1 - p;
2270         if (i == 7 && *p == '*' && len == 2) {
2271           p += len;
2272           memcpy(q, strInt, strIntLen);
2273           q += strIntLen;
2274           *q++ = '-';
2275         } else {
2276           memcpy(q, p, len);
2277           p += len;
2278           q += len;
2279         }
2280       }
2281       if (!comma) break;
2282       len = comma + 1 - p;
2283       memcpy(q, p, len);
2284       p += len;
2285       q += len;
2286     }
2287     strcpy(q, p);
2288
2289     return base_fnt_lst;
2290 }
2291
2292 XFontSet
2293 CreateFontSet (char *base_fnt_lst)
2294 {
2295     XFontSet fntSet;
2296     char **missing_list;
2297     int missing_count;
2298     char *def_string;
2299
2300     fntSet = XCreateFontSet(xDisplay, base_fnt_lst,
2301                             &missing_list, &missing_count, &def_string);
2302     if (appData.debugMode) {
2303       int i, count;
2304       XFontStruct **font_struct_list;
2305       char **font_name_list;
2306       fprintf(debugFP, "Requested font set for list %s\n", base_fnt_lst);
2307       if (fntSet) {
2308         fprintf(debugFP, " got list %s, locale %s\n",
2309                 XBaseFontNameListOfFontSet(fntSet),
2310                 XLocaleOfFontSet(fntSet));
2311         count = XFontsOfFontSet(fntSet, &font_struct_list, &font_name_list);
2312         for (i = 0; i < count; i++) {
2313           fprintf(debugFP, " got charset %s\n", font_name_list[i]);
2314         }
2315       }
2316       for (i = 0; i < missing_count; i++) {
2317         fprintf(debugFP, " missing charset %s\n", missing_list[i]);
2318       }
2319     }
2320     if (fntSet == NULL) {
2321       fprintf(stderr, _("Unable to create font set for %s.\n"), base_fnt_lst);
2322       exit(2);
2323     }
2324     return fntSet;
2325 }
2326 #else // not ENABLE_NLS
2327 /*
2328  * Find a font that matches "pattern" that is as close as
2329  * possible to the targetPxlSize.  Prefer fonts that are k
2330  * pixels smaller to fonts that are k pixels larger.  The
2331  * pattern must be in the X Consortium standard format,
2332  * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
2333  * The return value should be freed with XtFree when no
2334  * longer needed.
2335  */
2336 char *
2337 FindFont (char *pattern, int targetPxlSize)
2338 {
2339     char **fonts, *p, *best, *scalable, *scalableTail;
2340     int i, j, nfonts, minerr, err, pxlSize;
2341
2342     fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
2343     if (nfonts < 1) {
2344         fprintf(stderr, _("%s: no fonts match pattern %s\n"),
2345                 programName, pattern);
2346         exit(2);
2347     }
2348
2349     best = fonts[0];
2350     scalable = NULL;
2351     minerr = 999999;
2352     for (i=0; i<nfonts; i++) {
2353         j = 0;
2354         p = fonts[i];
2355         if (*p != '-') continue;
2356         while (j < 7) {
2357             if (*p == NULLCHAR) break;
2358             if (*p++ == '-') j++;
2359         }
2360         if (j < 7) continue;
2361         pxlSize = atoi(p);
2362         if (pxlSize == 0) {
2363             scalable = fonts[i];
2364             scalableTail = p;
2365         } else {
2366             err = pxlSize - targetPxlSize;
2367             if (Abs(err) < Abs(minerr) ||
2368                 (minerr > 0 && err < 0 && -err == minerr)) {
2369                 best = fonts[i];
2370                 minerr = err;
2371             }
2372         }
2373     }
2374     if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
2375         /* If the error is too big and there is a scalable font,
2376            use the scalable font. */
2377         int headlen = scalableTail - scalable;
2378         p = (char *) XtMalloc(strlen(scalable) + 10);
2379         while (isdigit(*scalableTail)) scalableTail++;
2380         sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
2381     } else {
2382         p = (char *) XtMalloc(strlen(best) + 2);
2383         safeStrCpy(p, best, strlen(best)+1 );
2384     }
2385     if (appData.debugMode) {
2386         fprintf(debugFP, _("resolved %s at pixel size %d\n  to %s\n"),
2387                 pattern, targetPxlSize, p);
2388     }
2389     XFreeFontNames(fonts);
2390     return p;
2391 }
2392 #endif
2393
2394 void
2395 DeleteGCs ()
2396 {   // [HGM] deletes GCs that are to be remade, to prevent resource leak;
2397     // must be called before all non-first callse to CreateGCs()
2398     XtReleaseGC(shellWidget, highlineGC);
2399     XtReleaseGC(shellWidget, lightSquareGC);
2400     XtReleaseGC(shellWidget, darkSquareGC);
2401     XtReleaseGC(shellWidget, lineGC);
2402     if (appData.monoMode) {
2403         if (DefaultDepth(xDisplay, xScreen) == 1) {
2404             XtReleaseGC(shellWidget, wbPieceGC);
2405         } else {
2406             XtReleaseGC(shellWidget, bwPieceGC);
2407         }
2408     } else {
2409         XtReleaseGC(shellWidget, prelineGC);
2410         XtReleaseGC(shellWidget, jailSquareGC);
2411         XtReleaseGC(shellWidget, wdPieceGC);
2412         XtReleaseGC(shellWidget, wlPieceGC);
2413         XtReleaseGC(shellWidget, wjPieceGC);
2414         XtReleaseGC(shellWidget, bdPieceGC);
2415         XtReleaseGC(shellWidget, blPieceGC);
2416         XtReleaseGC(shellWidget, bjPieceGC);
2417     }
2418 }
2419
2420 static GC
2421 CreateOneGC (XGCValues *gc_values, Pixel foreground, Pixel background)
2422 {
2423     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
2424       | GCBackground | GCFunction | GCPlaneMask;
2425     gc_values->foreground = foreground;
2426     gc_values->background = background;
2427     return XtGetGC(shellWidget, value_mask, gc_values);
2428 }
2429
2430 void
2431 CreateGCs (int redo)
2432 {
2433     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
2434       | GCBackground | GCFunction | GCPlaneMask;
2435     XGCValues gc_values;
2436     GC copyInvertedGC;
2437     Pixel white = XWhitePixel(xDisplay, xScreen);
2438     Pixel black = XBlackPixel(xDisplay, xScreen);
2439
2440     gc_values.plane_mask = AllPlanes;
2441     gc_values.line_width = lineGap;
2442     gc_values.line_style = LineSolid;
2443     gc_values.function = GXcopy;
2444
2445   if(redo) {
2446     DeleteGCs(); // called a second time; clean up old GCs first
2447   } else { // [HGM] grid and font GCs created on first call only
2448     coordGC = CreateOneGC(&gc_values, black, white);
2449     XSetFont(xDisplay, coordGC, coordFontID);
2450
2451     // [HGM] make font for holdings counts (white on black)
2452     countGC = CreateOneGC(&gc_values, white, black);
2453     XSetFont(xDisplay, countGC, countFontID);
2454   }
2455     lineGC = CreateOneGC(&gc_values, black, black);
2456
2457     if (appData.monoMode) {
2458
2459         highlineGC = CreateOneGC(&gc_values, white, white);
2460         lightSquareGC = wbPieceGC = CreateOneGC(&gc_values, white, black);
2461         darkSquareGC = bwPieceGC = CreateOneGC(&gc_values, black, white);
2462
2463         if (DefaultDepth(xDisplay, xScreen) == 1) {
2464             /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
2465             gc_values.function = GXcopyInverted;
2466             copyInvertedGC = CreateOneGC(&gc_values, black, white);
2467             gc_values.function = GXcopy;
2468             if (XBlackPixel(xDisplay, xScreen) == 1) {
2469                 bwPieceGC = darkSquareGC;
2470                 wbPieceGC = copyInvertedGC;
2471             } else {
2472                 bwPieceGC = copyInvertedGC;
2473                 wbPieceGC = lightSquareGC;
2474             }
2475         }
2476     } else {
2477
2478         highlineGC = CreateOneGC(&gc_values, highlightSquareColor, highlightSquareColor);
2479         prelineGC = CreateOneGC(&gc_values, premoveHighlightColor, premoveHighlightColor);
2480         lightSquareGC = CreateOneGC(&gc_values, lightSquareColor, darkSquareColor);
2481         darkSquareGC = CreateOneGC(&gc_values, darkSquareColor, lightSquareColor);
2482         jailSquareGC = CreateOneGC(&gc_values, jailSquareColor, jailSquareColor);
2483         wdPieceGC = CreateOneGC(&gc_values, whitePieceColor, darkSquareColor);
2484         wlPieceGC = CreateOneGC(&gc_values, whitePieceColor, lightSquareColor);
2485         wjPieceGC = CreateOneGC(&gc_values, whitePieceColor, jailSquareColor);
2486         bdPieceGC = CreateOneGC(&gc_values, blackPieceColor, darkSquareColor);
2487         blPieceGC = CreateOneGC(&gc_values, blackPieceColor, lightSquareColor);
2488         bjPieceGC = CreateOneGC(&gc_values, blackPieceColor, jailSquareColor);
2489     }
2490 }
2491
2492 void
2493 loadXIM (XImage *xim, XImage *xmask, char *filename, Pixmap *dest, Pixmap *mask)
2494 {
2495     int x, y, w, h, p;
2496     FILE *fp;
2497     Pixmap temp;
2498     XGCValues   values;
2499     GC maskGC;
2500
2501     fp = fopen(filename, "rb");
2502     if (!fp) {
2503         fprintf(stderr, _("%s: error loading XIM!\n"), programName);
2504         exit(1);
2505     }
2506
2507     w = fgetc(fp);
2508     h = fgetc(fp);
2509
2510     for (y=0; y<h; ++y) {
2511         for (x=0; x<h; ++x) {
2512             p = fgetc(fp);
2513
2514             switch (p) {
2515               case 0:
2516                 XPutPixel(xim, x, y, blackPieceColor);
2517                 if (xmask)
2518                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
2519                 break;
2520               case 1:
2521                 XPutPixel(xim, x, y, darkSquareColor);
2522                 if (xmask)
2523                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
2524                 break;
2525               case 2:
2526                 XPutPixel(xim, x, y, whitePieceColor);
2527                 if (xmask)
2528                   XPutPixel(xmask, x, y, WhitePixel(xDisplay,xScreen));
2529                 break;
2530               case 3:
2531                 XPutPixel(xim, x, y, lightSquareColor);
2532                 if (xmask)
2533                   XPutPixel(xmask, x, y, BlackPixel(xDisplay,xScreen));
2534                 break;
2535             }
2536         }
2537     }
2538
2539     fclose(fp);
2540
2541     /* create Pixmap of piece */
2542     *dest = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
2543                           w, h, xim->depth);
2544     XPutImage(xDisplay, *dest, lightSquareGC, xim,
2545               0, 0, 0, 0, w, h);
2546
2547     /* create Pixmap of clipmask
2548        Note: We assume the white/black pieces have the same
2549              outline, so we make only 6 masks. This is okay
2550              since the XPM clipmask routines do the same. */
2551     if (xmask) {
2552       temp = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
2553                             w, h, xim->depth);
2554       XPutImage(xDisplay, temp, lightSquareGC, xmask,
2555               0, 0, 0, 0, w, h);
2556
2557       /* now create the 1-bit version */
2558       *mask = XCreatePixmap(xDisplay, DefaultRootWindow(xDisplay),
2559                           w, h, 1);
2560
2561       values.foreground = 1;
2562       values.background = 0;
2563
2564       /* Don't use XtGetGC, not read only */
2565       maskGC = XCreateGC(xDisplay, *mask,
2566                     GCForeground | GCBackground, &values);
2567       XCopyPlane(xDisplay, temp, *mask, maskGC,
2568                   0, 0, squareSize, squareSize, 0, 0, 1);
2569       XFreePixmap(xDisplay, temp);
2570     }
2571 }
2572
2573
2574 char pieceBitmapNames[] = "pnbrqfeacwmohijgdvlsukpnsl";
2575
2576 void
2577 CreateXIMPieces ()
2578 {
2579     int piece, kind;
2580     char buf[MSG_SIZ];
2581     u_int ss;
2582     static char *ximkind[] = { "ll", "ld", "dl", "dd" };
2583     XImage *ximtemp;
2584
2585     ss = squareSize;
2586
2587     /* The XSynchronize calls were copied from CreatePieces.
2588        Not sure if needed, but can't hurt */
2589     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
2590                                      buffering bug */
2591
2592     /* temp needed by loadXIM() */
2593     ximtemp = XGetImage(xDisplay, DefaultRootWindow(xDisplay),
2594                  0, 0, ss, ss, AllPlanes, XYPixmap);
2595
2596     if (strlen(appData.pixmapDirectory) == 0) {
2597       useImages = 0;
2598     } else {
2599         useImages = 1;
2600         if (appData.monoMode) {
2601           DisplayFatalError(_("XIM pieces cannot be used in monochrome mode"),
2602                             0, 2);
2603           ExitEvent(2);
2604         }
2605         fprintf(stderr, _("\nLoading XIMs...\n"));
2606         /* Load pieces */
2607         for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
2608             fprintf(stderr, "%d", piece+1);
2609             for (kind=0; kind<4; kind++) {
2610                 fprintf(stderr, ".");
2611                 snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xim",
2612                         ExpandPathName(appData.pixmapDirectory),
2613                         piece <= (int) WhiteKing ? "" : "w",
2614                         pieceBitmapNames[piece],
2615                         ximkind[kind], ss);
2616                 ximPieceBitmap[kind][piece] =
2617                   XGetImage(xDisplay, DefaultRootWindow(xDisplay),
2618                             0, 0, ss, ss, AllPlanes, XYPixmap);
2619                 if (appData.debugMode)
2620                   fprintf(stderr, _("(File:%s:) "), buf);
2621                 loadXIM(ximPieceBitmap[kind][piece],
2622                         ximtemp, buf,
2623                         &(xpmPieceBitmap2[kind][piece]),
2624                         &(ximMaskPm2[piece]));
2625                 if(piece <= (int)WhiteKing)
2626                     xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
2627             }
2628             fprintf(stderr," ");
2629         }
2630         /* Load light and dark squares */
2631         /* If the LSQ and DSQ pieces don't exist, we will
2632            draw them with solid squares. */
2633         snprintf(buf,sizeof(buf), "%s/lsq%u.xim", ExpandPathName(appData.pixmapDirectory), ss);
2634         if (access(buf, 0) != 0) {
2635             useImageSqs = 0;
2636         } else {
2637             useImageSqs = 1;
2638             fprintf(stderr, _("light square "));
2639             ximLightSquare=
2640               XGetImage(xDisplay, DefaultRootWindow(xDisplay),
2641                         0, 0, ss, ss, AllPlanes, XYPixmap);
2642             if (appData.debugMode)
2643               fprintf(stderr, _("(File:%s:) "), buf);
2644
2645             loadXIM(ximLightSquare, NULL, buf, &xpmLightSquare, NULL);
2646             fprintf(stderr, _("dark square "));
2647             snprintf(buf,sizeof(buf), "%s/dsq%u.xim",
2648                     ExpandPathName(appData.pixmapDirectory), ss);
2649             if (appData.debugMode)
2650               fprintf(stderr, _("(File:%s:) "), buf);
2651             ximDarkSquare=
2652               XGetImage(xDisplay, DefaultRootWindow(xDisplay),
2653                         0, 0, ss, ss, AllPlanes, XYPixmap);
2654             loadXIM(ximDarkSquare, NULL, buf, &xpmDarkSquare, NULL);
2655             xpmJailSquare = xpmLightSquare;
2656         }
2657         fprintf(stderr, _("Done.\n"));
2658     }
2659     XSynchronize(xDisplay, False); /* Work-around for xlib/xt buffering bug */
2660 }
2661
2662 static VariantClass oldVariant = (VariantClass) -1; // [HGM] pieces: redo every time variant changes
2663
2664 #if HAVE_LIBXPM
2665 void
2666 CreateXPMBoard (char *s, int kind)
2667 {
2668     XpmAttributes attr;
2669     attr.valuemask = 0;
2670     if(!appData.useBitmaps || s == NULL || *s == 0 || *s == '*') { useTexture &= ~(kind+1); return; }
2671     if (XpmReadFileToPixmap(xDisplay, xBoardWindow, s, &(xpmBoardBitmap[kind]), NULL, &attr) == 0) {
2672         useTexture |= kind + 1; textureW[kind] = attr.width; textureH[kind] = attr.height;
2673     }
2674 }
2675
2676 void
2677 FreeXPMPieces ()
2678 {   // [HGM] to prevent resoucre leak on calling CreaeXPMPieces() a second time,
2679     // thisroutine has to be called t free the old piece pixmaps
2680     int piece, kind;
2681     for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++)
2682         for (kind=0; kind<4; kind++) XFreePixmap(xDisplay, xpmPieceBitmap2[kind][piece]);
2683     if(useImageSqs) {
2684         XFreePixmap(xDisplay, xpmLightSquare);
2685         XFreePixmap(xDisplay, xpmDarkSquare);
2686     }
2687 }
2688
2689 void
2690 CreateXPMPieces ()
2691 {
2692     int piece, kind, r;
2693     char buf[MSG_SIZ];
2694     u_int ss = squareSize;
2695     XpmAttributes attr;
2696     static char *xpmkind[] = { "ll", "ld", "dl", "dd" };
2697     XpmColorSymbol symbols[4];
2698     static int redo = False;
2699
2700     if(redo) FreeXPMPieces(); else redo = 1;
2701
2702     /* The XSynchronize calls were copied from CreatePieces.
2703        Not sure if needed, but can't hurt */
2704     XSynchronize(xDisplay, True); /* Work-around for xlib/xt buffering bug */
2705
2706     /* Setup translations so piece colors match square colors */
2707     symbols[0].name = "light_piece";
2708     symbols[0].value = appData.whitePieceColor;
2709     symbols[1].name = "dark_piece";
2710     symbols[1].value = appData.blackPieceColor;
2711     symbols[2].name = "light_square";
2712     symbols[2].value = appData.lightSquareColor;
2713     symbols[3].name = "dark_square";
2714     symbols[3].value = appData.darkSquareColor;
2715
2716     attr.valuemask = XpmColorSymbols;
2717     attr.colorsymbols = symbols;
2718     attr.numsymbols = 4;
2719
2720     if (appData.monoMode) {
2721       DisplayFatalError(_("XPM pieces cannot be used in monochrome mode"),
2722                         0, 2);
2723       ExitEvent(2);
2724     }
2725     if (strlen(appData.pixmapDirectory) == 0) {
2726         XpmPieces* pieces = builtInXpms;
2727         useImages = 1;
2728         /* Load pieces */
2729         while (pieces->size != squareSize && pieces->size) pieces++;
2730         if (!pieces->size) {
2731           fprintf(stderr, _("No builtin XPM pieces of size %d\n"), squareSize);
2732           exit(1);
2733         }
2734         for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
2735             for (kind=0; kind<4; kind++) {
2736
2737                 if ((r=XpmCreatePixmapFromData(xDisplay, xBoardWindow,
2738                                                pieces->xpm[piece][kind],
2739                                                &(xpmPieceBitmap2[kind][piece]),
2740                                                NULL, &attr)) != 0) {
2741                   fprintf(stderr, _("Error %d loading XPM image \"%s\"\n"),
2742                           r, buf);
2743                   exit(1);
2744                 }
2745                 if(piece <= (int) WhiteKing)
2746                     xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
2747             }
2748         }
2749         useImageSqs = 0;
2750         xpmJailSquare = xpmLightSquare;
2751     } else {
2752         useImages = 1;
2753
2754         fprintf(stderr, _("\nLoading XPMs...\n"));
2755
2756         /* Load pieces */
2757         for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
2758             fprintf(stderr, "%d ", piece+1);
2759             for (kind=0; kind<4; kind++) {
2760               snprintf(buf, sizeof(buf), "%s/%s%c%s%u.xpm",
2761                         ExpandPathName(appData.pixmapDirectory),
2762                         piece > (int) WhiteKing ? "w" : "",
2763                         pieceBitmapNames[piece],
2764                         xpmkind[kind], ss);
2765                 if (appData.debugMode) {
2766                     fprintf(stderr, _("(File:%s:) "), buf);
2767                 }
2768                 if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
2769                                            &(xpmPieceBitmap2[kind][piece]),
2770                                            NULL, &attr)) != 0) {
2771                     if(piece != (int)WhiteKing && piece > (int)WhiteQueen) {
2772                       // [HGM] missing: read of unorthodox piece failed; substitute King.
2773                       snprintf(buf, sizeof(buf), "%s/k%s%u.xpm",
2774                                 ExpandPathName(appData.pixmapDirectory),
2775                                 xpmkind[kind], ss);
2776                         if (appData.debugMode) {
2777                             fprintf(stderr, _("(Replace by File:%s:) "), buf);
2778                         }
2779                         r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
2780                                                 &(xpmPieceBitmap2[kind][piece]),
2781                                                 NULL, &attr);
2782                     }
2783                     if (r != 0) {
2784                         fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"),
2785                                 r, buf);
2786                         exit(1);
2787                     }
2788                 }
2789                 if(piece <= (int) WhiteKing)
2790                     xpmPieceBitmap[kind][piece] = xpmPieceBitmap2[kind][piece];
2791             }
2792         }
2793         /* Load light and dark squares */
2794         /* If the LSQ and DSQ pieces don't exist, we will
2795            draw them with solid squares. */
2796         fprintf(stderr, _("light square "));
2797         snprintf(buf, sizeof(buf), "%s/lsq%u.xpm", ExpandPathName(appData.pixmapDirectory), ss);
2798         if (access(buf, 0) != 0) {
2799             useImageSqs = 0;
2800         } else {
2801             useImageSqs = 1;
2802             if (appData.debugMode)
2803               fprintf(stderr, _("(File:%s:) "), buf);
2804
2805             if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
2806                                        &xpmLightSquare, NULL, &attr)) != 0) {
2807                 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
2808                 exit(1);
2809             }
2810             fprintf(stderr, _("dark square "));
2811             snprintf(buf, sizeof(buf), "%s/dsq%u.xpm",
2812                     ExpandPathName(appData.pixmapDirectory), ss);
2813             if (appData.debugMode) {
2814                 fprintf(stderr, _("(File:%s:) "), buf);
2815             }
2816             if ((r=XpmReadFileToPixmap(xDisplay, xBoardWindow, buf,
2817                                        &xpmDarkSquare, NULL, &attr)) != 0) {
2818                 fprintf(stderr, _("Error %d loading XPM file \"%s\"\n"), r, buf);
2819                 exit(1);
2820             }
2821         }
2822         xpmJailSquare = xpmLightSquare;
2823         fprintf(stderr, _("Done.\n"));
2824     }
2825     oldVariant = -1; // kludge to force re-makig of animation masks
2826     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
2827                                       buffering bug */
2828 }
2829 #endif /* HAVE_LIBXPM */
2830
2831 #if HAVE_LIBXPM
2832 /* No built-in bitmaps */
2833 void CreatePieces()
2834 {
2835     int piece, kind;
2836     char buf[MSG_SIZ];
2837     u_int ss = squareSize;
2838
2839     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
2840                                      buffering bug */
2841
2842     for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
2843         for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
2844           snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
2845                    pieceBitmapNames[piece],
2846                    ss, kind == SOLID ? 's' : 'o');
2847           ReadBitmap(&pieceBitmap2[kind][piece], buf, NULL, ss, ss);
2848           if(piece <= (int)WhiteKing)
2849             pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
2850         }
2851     }
2852
2853     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
2854                                       buffering bug */
2855 }
2856 #else
2857 /* With built-in bitmaps */
2858 void
2859 CreatePieces ()
2860 {
2861     BuiltInBits* bib = builtInBits;
2862     int piece, kind;
2863     char buf[MSG_SIZ];
2864     u_int ss = squareSize;
2865
2866     XSynchronize(xDisplay, True); /* Work-around for xlib/xt
2867                                      buffering bug */
2868
2869     while (bib->squareSize != ss && bib->squareSize != 0) bib++;
2870
2871     for (kind = SOLID; kind <= (appData.monoMode ? OUTLINE : SOLID); kind++) {
2872         for (piece = (int) WhitePawn; piece <= (int) WhiteKing + 4; piece++) {
2873           snprintf(buf, MSG_SIZ, "%s%c%u%c.bm", piece > (int)WhiteKing ? "w" : "",
2874                    pieceBitmapNames[piece],
2875                    ss, kind == SOLID ? 's' : 'o');
2876           ReadBitmap(&pieceBitmap2[kind][piece], buf,
2877                      bib->bits[kind][piece], ss, ss);
2878           if(piece <= (int)WhiteKing)
2879             pieceBitmap[kind][piece] = pieceBitmap2[kind][piece];
2880         }
2881     }
2882
2883     XSynchronize(xDisplay, False); /* Work-around for xlib/xt
2884                                       buffering bug */
2885 }
2886 #endif
2887
2888 void
2889 ReadBitmap (Pixmap *pm, String name, unsigned char bits[], u_int wreq, u_int hreq)
2890 {
2891     int x_hot, y_hot;
2892     u_int w, h;
2893     int errcode;
2894     char msg[MSG_SIZ], fullname[MSG_SIZ];
2895
2896     if (*appData.bitmapDirectory != NULLCHAR) {
2897       safeStrCpy(fullname, appData.bitmapDirectory, sizeof(fullname)/sizeof(fullname[0]) );
2898       strncat(fullname, "/", MSG_SIZ - strlen(fullname) - 1);
2899       strncat(fullname, name, MSG_SIZ - strlen(fullname) - 1);
2900       errcode = XReadBitmapFile(xDisplay, xBoardWindow, fullname,
2901                                 &w, &h, pm, &x_hot, &y_hot);
2902       fprintf(stderr, "load %s\n", name);
2903         if (errcode != BitmapSuccess) {
2904             switch (errcode) {
2905               case BitmapOpenFailed:
2906                 snprintf(msg, sizeof(msg), _("Can't open bitmap file %s"), fullname);
2907                 break;
2908               case BitmapFileInvalid:
2909                 snprintf(msg, sizeof(msg), _("Invalid bitmap in file %s"), fullname);
2910                 break;
2911               case BitmapNoMemory:
2912                 snprintf(msg, sizeof(msg), _("Ran out of memory reading bitmap file %s"),
2913                         fullname);
2914                 break;
2915               default:
2916                 snprintf(msg, sizeof(msg), _("Unknown XReadBitmapFile error %d on file %s"),
2917                         errcode, fullname);
2918                 break;
2919             }
2920             fprintf(stderr, _("%s: %s...using built-in\n"),
2921                     programName, msg);
2922         } else if (w != wreq || h != hreq) {
2923             fprintf(stderr,
2924                     _("%s: Bitmap %s is %dx%d, not %dx%d...using built-in\n"),
2925                     programName, fullname, w, h, wreq, hreq);
2926         } else {
2927             return;
2928         }
2929     }
2930     if (bits != NULL) {
2931         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
2932                                     wreq, hreq);
2933     }
2934 }
2935
2936 void
2937 CreateGrid ()
2938 {
2939     int i, j;
2940
2941     if (lineGap == 0) return;
2942
2943     /* [HR] Split this into 2 loops for non-square boards. */
2944
2945     for (i = 0; i < BOARD_HEIGHT + 1; i++) {
2946         gridSegments[i].x1 = 0;
2947         gridSegments[i].x2 =
2948           lineGap + BOARD_WIDTH * (squareSize + lineGap);
2949         gridSegments[i].y1 = gridSegments[i].y2
2950           = lineGap / 2 + (i * (squareSize + lineGap));
2951     }
2952
2953     for (j = 0; j < BOARD_WIDTH + 1; j++) {
2954         gridSegments[j + i].y1 = 0;
2955         gridSegments[j + i].y2 =
2956           lineGap + BOARD_HEIGHT * (squareSize + lineGap);
2957         gridSegments[j + i].x1 = gridSegments[j + i].x2
2958           = lineGap / 2 + (j * (squareSize + lineGap));
2959     }
2960 }
2961
2962 int nrOfMenuItems = 7;
2963 Widget menuWidget[150];
2964 MenuListItem menuItemList[150] = {
2965     { "LoadNextGameProc", LoadNextGameProc },
2966     { "LoadPrevGameProc", LoadPrevGameProc },
2967     { "ReloadGameProc", ReloadGameProc },
2968     { "ReloadPositionProc", ReloadPositionProc },
2969 #ifndef OPTIONSDIALOG
2970     { "AlwaysQueenProc", AlwaysQueenProc },
2971     { "AnimateDraggingProc", AnimateDraggingProc },
2972     { "AnimateMovingProc", AnimateMovingProc },
2973     { "AutoflagProc", AutoflagProc },
2974     { "AutoflipProc", AutoflipProc },
2975     { "BlindfoldProc", BlindfoldProc },
2976     { "FlashMovesProc", FlashMovesProc },
2977 #if HIGHDRAG
2978     { "HighlightDraggingProc", HighlightDraggingProc },
2979 #endif
2980     { "HighlightLastMoveProc", HighlightLastMoveProc },
2981 //    { "IcsAlarmProc", IcsAlarmProc },
2982     { "MoveSoundProc", MoveSoundProc },
2983     { "PeriodicUpdatesProc", PeriodicUpdatesProc },
2984     { "PopupExitMessageProc", PopupExitMessageProc },
2985     { "PopupMoveErrorsProc", PopupMoveErrorsProc },
2986 //    { "PremoveProc", PremoveProc },
2987     { "ShowCoordsProc", ShowCoordsProc },
2988     { "ShowThinkingProc", ShowThinkingProc },
2989     { "HideThinkingProc", HideThinkingProc },
2990     { "TestLegalityProc", TestLegalityProc },
2991 #endif
2992     { "AboutGameProc", AboutGameEvent },
2993     { "DebugProc", DebugProc },
2994     { "NothingProc", NothingProc },
2995   {NULL, NothingProc}
2996 };
2997
2998 void
2999 MarkMenuItem (char *menuRef, int state)
3000 {
3001     int nr = MenuToNumber(menuRef);
3002     if(nr >= 0) {
3003         Arg args[2];
3004         XtSetArg(args[0], XtNleftBitmap, state ? xMarkPixmap : None);
3005         XtSetValues(menuWidget[nr], args, 1);
3006     }
3007 }
3008
3009 void
3010 EnableMenuItem (char *menuRef, int state)
3011 {
3012     int nr = MenuToNumber(menuRef);
3013     if(nr >= 0) XtSetSensitive(menuWidget[nr], state);
3014 }
3015
3016 void
3017 EnableButtonBar (int state)
3018 {
3019     XtSetSensitive(buttonBarWidget, state);
3020 }
3021
3022
3023 void
3024 SetMenuEnables (Enables *enab)
3025 {
3026   while (enab->name != NULL) {
3027     EnableMenuItem(enab->name, enab->value);
3028     enab++;
3029   }
3030 }
3031
3032 int
3033 Equal(char *p, char *s)
3034 {   // compare strings skipping spaces in second
3035     while(*s) {
3036         if(*s == ' ') { s++; continue; }
3037         if(*s++ != *p++) return 0;
3038     }
3039     return !*p;
3040 }
3041
3042 void
3043 KeyBindingProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3044 {   // [HGM] new method of key binding: specify MenuItem(FlipView) in stead of FlipViewProc in translation string
3045     int i;
3046     if(*nprms == 0) return;
3047     for(i=0; menuItemList[i].name; i++) {
3048         if(Equal(prms[0], menuItemList[i].name)) {
3049             (menuItemList[i].proc) ();
3050             return;
3051         }
3052     }
3053 }
3054
3055 static void
3056 MenuBarSelect (Widget w, caddr_t addr, caddr_t index)
3057 {
3058     MenuProc *proc = (MenuProc *) addr;
3059
3060     (proc)();
3061 }
3062
3063 static void
3064 MenuEngineSelect (Widget w, caddr_t addr, caddr_t index)
3065 {
3066     RecentEngineEvent((int) (intptr_t) addr);
3067 }
3068
3069 // some stuff that must remain in front-end
3070 static Widget mainBar, currentMenu;
3071 static int wtot, nr = 0, widths[10];
3072
3073 void
3074 AppendMenuItem (char *text, char *name, MenuProc *action)
3075 {
3076     int j;
3077     Widget entry;
3078     Arg args[16];
3079
3080     j = 0;
3081     XtSetArg(args[j], XtNleftMargin, 20);   j++;
3082     XtSetArg(args[j], XtNrightMargin, 20);  j++;
3083
3084         if (strcmp(text, "----") == 0) {
3085           entry = XtCreateManagedWidget(text, smeLineObjectClass,
3086                                           currentMenu, args, j);
3087         } else {
3088           XtSetArg(args[j], XtNlabel, XtNewString(_(text)));
3089             entry = XtCreateManagedWidget(name, smeBSBObjectClass,
3090                                           currentMenu, args, j+1);
3091             XtAddCallback(entry, XtNcallback,
3092                           (XtCallbackProc) (strcmp(name, "recent") ? MenuBarSelect : MenuEngineSelect),
3093                           (caddr_t) action);
3094             menuWidget[nrOfMenuItems] = entry;
3095         }
3096 }
3097
3098 void
3099 CreateMenuButton (char *name, Menu *mb)
3100 {   // create menu button on main bar, and shell for pull-down list
3101     int i, j;
3102     Arg args[16];
3103     Dimension w;
3104
3105         j = 0;
3106         XtSetArg(args[j], XtNmenuName, XtNewString(name));  j++;
3107         XtSetArg(args[j], XtNlabel, XtNewString(_(mb->name)));  j++;
3108         XtSetArg(args[j], XtNborderWidth, 0);                   j++;
3109         mb->subMenu = XtCreateManagedWidget(mb->name, menuButtonWidgetClass,
3110                                        mainBar, args, j);
3111     currentMenu = XtCreatePopupShell(name, simpleMenuWidgetClass,
3112                               mainBar, NULL, 0);
3113         j = 0;
3114         XtSetArg(args[j], XtNwidth, &w);                   j++;
3115         XtGetValues(mb->subMenu, args, j);
3116         wtot += mb->textWidth = widths[nr++] = w;
3117 }
3118
3119 Widget
3120 CreateMenuBar (Menu *mb, int boardWidth)
3121 {
3122     int i, j;
3123     Arg args[16];
3124     char menuName[MSG_SIZ];
3125     Dimension w;
3126     Menu *ma = mb;
3127
3128     // create bar itself
3129     j = 0;
3130     XtSetArg(args[j], XtNorientation, XtorientHorizontal);  j++;
3131     XtSetArg(args[j], XtNvSpace, 0);                        j++;
3132     XtSetArg(args[j], XtNborderWidth, 0);                   j++;
3133     mainBar = XtCreateWidget("menuBar", boxWidgetClass,
3134                              formWidget, args, j);
3135
3136     CreateMainMenus(mb); // put menus in bar according to description in back-end
3137
3138     // size buttons to make menu bar fit, clipping menu names where necessary
3139     while(wtot > boardWidth - 40) {
3140         int wmax=0, imax=0;
3141         for(i=0; i<nr; i++) if(widths[i] > wmax) wmax = widths[imax=i];
3142         widths[imax]--;
3143         wtot--;
3144     }
3145     for(i=0; i<nr; i++) if(widths[i] != ma[i].textWidth) {
3146         j = 0;
3147         XtSetArg(args[j], XtNwidth, widths[i]);                   j++;
3148         XtSetValues(ma[i].subMenu, args, j);
3149     }
3150
3151     return mainBar;
3152 }
3153
3154 Widget
3155 CreateButtonBar (MenuItem *mi)
3156 {
3157     int j;
3158     Widget button, buttonBar;
3159     Arg args[16];
3160
3161     j = 0;
3162     XtSetArg(args[j], XtNorientation, XtorientHorizontal); j++;
3163     if (tinyLayout) {
3164         XtSetArg(args[j], XtNhSpace, 0); j++;
3165     }
3166     XtSetArg(args[j], XtNborderWidth, 0); j++;
3167     XtSetArg(args[j], XtNvSpace, 0);                        j++;
3168     buttonBar = XtCreateWidget("buttonBar", boxWidgetClass,
3169                                formWidget, args, j);
3170
3171     while (mi->string != NULL) {
3172         j = 0;
3173         if (tinyLayout) {
3174             XtSetArg(args[j], XtNinternalWidth, 2); j++;
3175             XtSetArg(args[j], XtNborderWidth, 0); j++;
3176         }
3177       XtSetArg(args[j], XtNlabel, XtNewString(_(mi->string))); j++;
3178         button = XtCreateManagedWidget(mi->string, commandWidgetClass,
3179                                        buttonBar, args, j);
3180         XtAddCallback(button, XtNcallback,
3181                       (XtCallbackProc) MenuBarSelect,
3182                       (caddr_t) mi->proc);
3183         mi++;
3184     }
3185     return buttonBar;
3186 }
3187
3188 Widget
3189 CreatePieceMenu (char *name, int color)
3190 {
3191     int i;
3192     Widget entry, menu;
3193     Arg args[16];
3194     ChessSquare selection;
3195
3196     menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
3197                               boardWidget, args, 0);
3198
3199     for (i = 0; i < PIECE_MENU_SIZE; i++) {
3200         String item = pieceMenuStrings[color][i];
3201
3202         if (strcmp(item, "----") == 0) {
3203             entry = XtCreateManagedWidget(item, smeLineObjectClass,
3204                                           menu, NULL, 0);
3205         } else {
3206           XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
3207             entry = XtCreateManagedWidget(item, smeBSBObjectClass,
3208                                 menu, args, 1);
3209             selection = pieceMenuTranslation[color][i];
3210             XtAddCallback(entry, XtNcallback,
3211                           (XtCallbackProc) PieceMenuSelect,
3212                           (caddr_t) selection);
3213             if (selection == WhitePawn || selection == BlackPawn) {
3214                 XtSetArg(args[0], XtNpopupOnEntry, entry);
3215                 XtSetValues(menu, args, 1);
3216             }
3217         }
3218     }
3219     return menu;
3220 }
3221
3222 void
3223 CreatePieceMenus ()
3224 {
3225     int i;
3226     Widget entry;
3227     Arg args[16];
3228     ChessSquare selection;
3229
3230     whitePieceMenu = CreatePieceMenu("menuW", 0);
3231     blackPieceMenu = CreatePieceMenu("menuB", 1);
3232
3233     if(appData.pieceMenu) // [HGM] sweep: no idea what this was good for, but it stopped reporting button events outside the window
3234     XtRegisterGrabAction(PieceMenuPopup, True,
3235                          (unsigned)(ButtonPressMask|ButtonReleaseMask),
3236                          GrabModeAsync, GrabModeAsync);
3237
3238     XtSetArg(args[0], XtNlabel, _("Drop"));
3239     dropMenu = XtCreatePopupShell("menuD", simpleMenuWidgetClass,
3240                                   boardWidget, args, 1);
3241     for (i = 0; i < DROP_MENU_SIZE; i++) {
3242         String item = dropMenuStrings[i];
3243
3244         if (strcmp(item, "----") == 0) {
3245             entry = XtCreateManagedWidget(item, smeLineObjectClass,
3246                                           dropMenu, NULL, 0);
3247         } else {
3248           XtSetArg(args[0], XtNlabel, XtNewString(_(item)));
3249             entry = XtCreateManagedWidget(item, smeBSBObjectClass,
3250                                 dropMenu, args, 1);
3251             selection = dropMenuTranslation[i];
3252             XtAddCallback(entry, XtNcallback,
3253                           (XtCallbackProc) DropMenuSelect,
3254                           (caddr_t) selection);
3255         }
3256     }
3257 }
3258
3259 void
3260 SetupDropMenu ()
3261 {
3262     int i, j, count;
3263     char label[32];
3264     Arg args[16];
3265     Widget entry;
3266     char* p;
3267
3268     for (i=0; i<sizeof(dmEnables)/sizeof(DropMenuEnables); i++) {
3269         entry = XtNameToWidget(dropMenu, dmEnables[i].widget);
3270         p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,
3271                    dmEnables[i].piece);
3272         XtSetSensitive(entry, p != NULL || !appData.testLegality
3273                        /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse
3274                                        && !appData.icsActive));
3275         count = 0;
3276         while (p && *p++ == dmEnables[i].piece) count++;
3277         snprintf(label, sizeof(label), "%s  %d", dmEnables[i].widget, count);
3278         j = 0;
3279         XtSetArg(args[j], XtNlabel, label); j++;
3280         XtSetValues(entry, args, j);
3281     }
3282 }
3283
3284 void
3285 PieceMenuPopup (Widget w, XEvent *event, String *params, Cardinal *num_params)
3286 {
3287     String whichMenu; int menuNr = -2;
3288     shiftKey = strcmp(params[0], "menuW"); // used to indicate black
3289     if (event->type == ButtonRelease)
3290         menuNr = RightClick(Release, event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
3291     else if (event->type == ButtonPress)
3292         menuNr = RightClick(Press,   event->xbutton.x, event->xbutton.y, &pmFromX, &pmFromY);
3293     switch(menuNr) {
3294       case 0: whichMenu = params[0]; break;
3295       case 1: SetupDropMenu(); whichMenu = "menuD"; break;
3296       case 2:
3297       case -1: if (errorUp) ErrorPopDown();
3298       default: return;
3299     }
3300     XtPopupSpringLoaded(XtNameToWidget(boardWidget, whichMenu));
3301 }
3302
3303 static void
3304 PieceMenuSelect (Widget w, ChessSquare piece, caddr_t junk)
3305 {
3306     if (pmFromX < 0 || pmFromY < 0) return;
3307     EditPositionMenuEvent(piece, pmFromX, pmFromY);
3308 }
3309
3310 static void
3311 DropMenuSelect (Widget w, ChessSquare piece, caddr_t junk)
3312 {
3313     if (pmFromX < 0 || pmFromY < 0) return;
3314     DropMenuEvent(piece, pmFromX, pmFromY);
3315 }
3316
3317 void
3318 WhiteClock (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3319 {
3320     shiftKey = prms[0][0] & 1;
3321     ClockClick(0);
3322 }
3323
3324 void
3325 BlackClock (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3326 {
3327     shiftKey = prms[0][0] & 1;
3328     ClockClick(1);
3329 }
3330
3331
3332 static void
3333 do_flash_delay (unsigned long msec)
3334 {
3335     TimeDelay(msec);
3336 }
3337
3338 void
3339 DrawBorder (int x, int y, int type)
3340 {
3341     GC gc = lineGC;
3342
3343     if(type == 1) gc = highlineGC; else if(type == 2) gc = prelineGC;
3344
3345     XDrawRectangle(xDisplay, xBoardWindow, gc, x, y,
3346                    squareSize+lineGap, squareSize+lineGap);
3347 }
3348
3349 static int
3350 CutOutSquare (int x, int y, int *x0, int *y0, int  kind)
3351 {
3352     int W = BOARD_WIDTH, H = BOARD_HEIGHT;
3353     int nx = x/(squareSize + lineGap), ny = y/(squareSize + lineGap);
3354     *x0 = 0; *y0 = 0;
3355     if(textureW[kind] < squareSize || textureH[kind] < squareSize) return 0;
3356     if(textureW[kind] < W*squareSize)
3357         *x0 = (textureW[kind] - squareSize) * nx/(W-1);
3358     else
3359         *x0 = textureW[kind]*nx / W + (textureW[kind] - W*squareSize) / (2*W);
3360     if(textureH[kind] < H*squareSize)
3361         *y0 = (textureH[kind] - squareSize) * ny/(H-1);
3362     else
3363         *y0 = textureH[kind]*ny / H + (textureH[kind] - H*squareSize) / (2*H);
3364     return 1;
3365 }
3366
3367 static void
3368 BlankSquare (int x, int y, int color, ChessSquare piece, Drawable dest, int fac)
3369 {   // [HGM] extra param 'fac' for forcing destination to (0,0) for copying to animation buffer
3370     int x0, y0;
3371     if (useImages && color != 2 && (useTexture & color+1) && CutOutSquare(x, y, &x0, &y0, color)) {
3372         XCopyArea(xDisplay, xpmBoardBitmap[color], dest, wlPieceGC, x0, y0,
3373                   squareSize, squareSize, x*fac, y*fac);
3374     } else
3375     if (useImages && useImageSqs) {
3376         Pixmap pm;
3377         switch (color) {
3378           case 1: /* light */
3379             pm = xpmLightSquare;
3380             break;
3381           case 0: /* dark */
3382             pm = xpmDarkSquare;
3383             break;
3384           case 2: /* neutral */
3385           default:
3386             pm = xpmJailSquare;
3387             break;
3388         }
3389         XCopyArea(xDisplay, pm, dest, wlPieceGC, 0, 0,
3390                   squareSize, squareSize, x*fac, y*fac);
3391     } else {
3392         GC gc;
3393         switch (color) {
3394           case 1: /* light */
3395             gc = lightSquareGC;
3396             break;
3397           case 0: /* dark */
3398             gc = darkSquareGC;
3399             break;
3400           case 2: /* neutral */
3401           default:
3402             gc = jailSquareGC;
3403             break;
3404         }
3405         XFillRectangle(xDisplay, dest, gc, x*fac, y*fac, squareSize, squareSize);
3406     }
3407 }
3408
3409 /*
3410    I split out the routines to draw a piece so that I could
3411    make a generic flash routine.
3412 */
3413 static void
3414 monoDrawPiece_1bit (ChessSquare piece, int square_color, int x, int y, Drawable dest)
3415 {
3416     /* Avoid XCopyPlane on 1-bit screens to work around Sun bug */
3417     switch (square_color) {
3418       case 1: /* light */
3419       case 2: /* neutral */
3420       default:
3421         XCopyArea(xDisplay, (int) piece < (int) BlackPawn
3422                   ? *pieceToOutline(piece)
3423                   : *pieceToSolid(piece),
3424                   dest, bwPieceGC, 0, 0,
3425                   squareSize, squareSize, x, y);
3426         break;
3427       case 0: /* dark */
3428         XCopyArea(xDisplay, (int) piece < (int) BlackPawn
3429                   ? *pieceToSolid(piece)
3430                   : *pieceToOutline(piece),
3431                   dest, wbPieceGC, 0, 0,
3432                   squareSize, squareSize, x, y);
3433         break;
3434     }
3435 }
3436
3437 static void
3438 monoDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
3439 {
3440     switch (square_color) {
3441       case 1: /* light */
3442       case 2: /* neutral */
3443       default:
3444         XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
3445                    ? *pieceToOutline(piece)
3446                    : *pieceToSolid(piece),
3447                    dest, bwPieceGC, 0, 0,
3448                    squareSize, squareSize, x, y, 1);
3449         break;
3450       case 0: /* dark */
3451         XCopyPlane(xDisplay, (int) piece < (int) BlackPawn
3452                    ? *pieceToSolid(piece)
3453                    : *pieceToOutline(piece),
3454                    dest, wbPieceGC, 0, 0,
3455                    squareSize, squareSize, x, y, 1);
3456         break;
3457     }
3458 }
3459
3460 static void
3461 colorDrawPiece (ChessSquare piece, int square_color, int x, int y, Drawable dest)
3462 {
3463     if(pieceToSolid(piece) == NULL) return; // [HGM] bitmaps: make it non-fatal if we have no bitmap;
3464     switch (square_color) {
3465       case 1: /* light */
3466         XCopyPlane(xDisplay, *pieceToSolid(piece),
3467                    dest, (int) piece < (int) BlackPawn
3468                    ? wlPieceGC : blPieceGC, 0, 0,
3469                    squareSize, squareSize, x, y, 1);
3470         break;
3471       case 0: /* dark */
3472         XCopyPlane(xDisplay, *pieceToSolid(piece),
3473                    dest, (int) piece < (int) BlackPawn
3474                    ? wdPieceGC : bdPieceGC, 0, 0,
3475                    squareSize, squareSize, x, y, 1);
3476         break;
3477       case 2: /* neutral */
3478       default:
3479         XCopyPlane(xDisplay, *pieceToSolid(piece),
3480                    dest, (int) piece < (int) BlackPawn
3481                    ? wjPieceGC : bjPieceGC, 0, 0,
3482                    squareSize, squareSize, x, y, 1);
3483         break;
3484     }
3485 }
3486
3487 static void
3488 colorDrawPieceImage (ChessSquare piece, int square_color, int x, int y, Drawable dest)
3489 {
3490     int kind, p = piece;
3491
3492     switch (square_color) {
3493       case 1: /* light */
3494       case 2: /* neutral */
3495       default:
3496         if ((int)piece < (int) BlackPawn) {
3497             kind = 0;
3498         } else {
3499             kind = 2;
3500             piece -= BlackPawn;
3501         }
3502         break;
3503       case 0: /* dark */
3504         if ((int)piece < (int) BlackPawn) {
3505             kind = 1;
3506         } else {
3507             kind = 3;
3508             piece -= BlackPawn;
3509         }
3510         break;
3511     }
3512     if(appData.upsideDown && flipView) { kind ^= 2; p += p < BlackPawn ? BlackPawn : -BlackPawn; }// swap white and black pieces
3513     if(useTexture & square_color+1) {
3514         BlankSquare(x, y, square_color, piece, dest, 1); // erase previous contents with background
3515         XSetClipMask(xDisplay, wlPieceGC, xpmMask[p]);
3516         XSetClipOrigin(xDisplay, wlPieceGC, x, y);
3517         XCopyArea(xDisplay, xpmPieceBitmap[kind][piece], dest, wlPieceGC, 0, 0, squareSize, squareSize, x, y);
3518         XSetClipMask(xDisplay, wlPieceGC, None);
3519         XSetClipOrigin(xDisplay, wlPieceGC, 0, 0);
3520     } else
3521     XCopyArea(xDisplay, xpmPieceBitmap[kind][piece],
3522               dest, wlPieceGC, 0, 0,
3523               squareSize, squareSize, x, y);
3524 }
3525
3526 typedef void (*DrawFunc)();
3527
3528 DrawFunc
3529 ChooseDrawFunc ()
3530 {
3531     if (appData.monoMode) {
3532         if (DefaultDepth(xDisplay, xScreen) == 1) {
3533             return monoDrawPiece_1bit;
3534         } else {
3535             return monoDrawPiece;
3536         }
3537     } else {
3538         if (useImages)
3539           return colorDrawPieceImage;
3540         else
3541           return colorDrawPiece;
3542     }
3543 }
3544
3545 void
3546 DrawDot (int marker, int x, int y, int r)
3547 {
3548         if(appData.monoMode) {
3549             XFillArc(xDisplay, xBoardWindow, marker == 2 ? darkSquareGC : lightSquareGC,
3550                     x, y, r, r, 0, 64*360);
3551             XDrawArc(xDisplay, xBoardWindow, marker == 2 ? lightSquareGC : darkSquareGC,
3552                     x, y, r, r, 0, 64*360);
3553         } else
3554         XFillArc(xDisplay, xBoardWindow, marker == 2 ? prelineGC : highlineGC,
3555                     x, y, r, r, 0, 64*360);
3556 }
3557
3558 void
3559 DrawOneSquare (int x, int y, ChessSquare piece, int square_color, int marker, char *string, int align)
3560 {   // basic front-end board-draw function: takes care of everything that can be in square:
3561     // piece, background, coordinate/count, marker dot
3562     int direction, font_ascent, font_descent;
3563     XCharStruct overall;
3564     DrawFunc drawfunc;
3565
3566     if (piece == EmptySquare) {
3567         BlankSquare(x, y, square_color, piece, xBoardWindow, 1);
3568     } else {
3569         drawfunc = ChooseDrawFunc();
3570         drawfunc(piece, square_color, x, y, xBoardWindow);
3571     }
3572
3573     if(align) { // square carries inscription (coord or piece count)
3574         int xx = x, yy = y;
3575         GC hGC = align < 3 ? coordGC : countGC;
3576         // first calculate where it goes
3577         XTextExtents(countFontStruct, string, 1, &direction,
3578                          &font_ascent, &font_descent, &overall);
3579         if (align == 1) {
3580             xx += squareSize - overall.width - 2;
3581             yy += squareSize - font_descent - 1;
3582         } else if (align == 2) {
3583             xx += 2, yy += font_ascent + 1;
3584         } else if (align == 3) {
3585             xx += squareSize - overall.width - 2;
3586             yy += font_ascent + 1;
3587         } else if (align == 4) {
3588             xx += 2, yy += font_ascent + 1;
3589         }
3590         // then draw it
3591         if (appData.monoMode) {
3592             XDrawImageString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
3593         } else {
3594             XDrawString(xDisplay, xBoardWindow, hGC, xx, yy, string, 1);
3595         }
3596     }
3597
3598     if(marker) { // print fat marker dot, if requested
3599         DrawDot(marker, x + squareSize/4, y+squareSize/4, squareSize/2);
3600     }
3601 }
3602
3603 void
3604 FlashDelay (int flash_delay)
3605 {
3606         XSync(xDisplay, False);
3607         if(flash_delay) do_flash_delay(flash_delay);
3608 }
3609
3610 double
3611 Fraction (int x, int start, int stop)
3612 {
3613    double f = ((double) x - start)/(stop - start);
3614    if(f > 1.) f = 1.; else if(f < 0.) f = 0.;
3615    return f;
3616 }
3617
3618 static WindowPlacement wpNew;
3619
3620 void
3621 CoDrag (Widget sh, WindowPlacement *wp)
3622 {
3623     Arg args[16];
3624     int j=0, touch=0, fudge = 2;
3625     GetActualPlacement(sh, wp);
3626     if(abs(wpMain.x + wpMain.width + 2*frameX - wp->x)         < fudge) touch = 1; else // right touch
3627     if(abs(wp->x + wp->width + 2*frameX - wpMain.x)            < fudge) touch = 2; else // left touch
3628     if(abs(wpMain.y + wpMain.height + frameX + frameY - wp->y) < fudge) touch = 3; else // bottom touch
3629     if(abs(wp->y + wp->height + frameX + frameY - wpMain.y)    < fudge) touch = 4;      // top touch
3630     if(!touch ) return; // only windows that touch co-move
3631     if(touch < 3 && wpNew.height != wpMain.height) { // left or right and height changed
3632         int heightInc = wpNew.height - wpMain.height;
3633         double fracTop = Fraction(wp->y, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
3634         double fracBot = Fraction(wp->y + wp->height + frameX + frameY + 1, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
3635         wp->y += fracTop * heightInc;
3636         heightInc = (int) (fracBot * heightInc) - (int) (fracTop * heightInc);
3637         if(heightInc) XtSetArg(args[j], XtNheight, wp->height + heightInc), j++;
3638     } else if(touch > 2 && wpNew.width != wpMain.width) { // top or bottom and width changed
3639         int widthInc = wpNew.width - wpMain.width;
3640         double fracLeft = Fraction(wp->x, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
3641         double fracRght = Fraction(wp->x + wp->width + 2*frameX + 1, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
3642         wp->y += fracLeft * widthInc;
3643         widthInc = (int) (fracRght * widthInc) - (int) (fracLeft * widthInc);
3644         if(widthInc) XtSetArg(args[j], XtNwidth, wp->width + widthInc), j++;
3645     }
3646     wp->x += wpNew.x - wpMain.x;
3647     wp->y += wpNew.y - wpMain.y;
3648     if(touch == 1) wp->x += wpNew.width - wpMain.width; else
3649     if(touch == 3) wp->y += wpNew.height - wpMain.height;
3650     XtSetArg(args[j], XtNx, wp->x); j++;
3651     XtSetArg(args[j], XtNy, wp->y); j++;
3652     XtSetValues(sh, args, j);
3653 }
3654
3655 static XtIntervalId delayedDragID = 0;
3656
3657 void
3658 DragProc ()
3659 {
3660         GetActualPlacement(shellWidget, &wpNew);
3661         if(wpNew.x == wpMain.x && wpNew.y == wpMain.y && // not moved
3662            wpNew.width == wpMain.width && wpNew.height == wpMain.height) // not sized
3663             return; // false alarm
3664         if(EngineOutputIsUp()) CoDrag(engineOutputShell, &wpEngineOutput);
3665         if(MoveHistoryIsUp()) CoDrag(shells[7], &wpMoveHistory);
3666         if(EvalGraphIsUp()) CoDrag(evalGraphShell, &wpEvalGraph);
3667         if(GameListIsUp()) CoDrag(gameListShell, &wpGameList);
3668         wpMain = wpNew;
3669         DrawPosition(True, NULL);
3670         delayedDragID = 0; // now drag executed, make sure next DelayedDrag will not cancel timer event (which could now be used by other)
3671 }
3672
3673
3674 void
3675 DelayedDrag ()
3676 {
3677     if(delayedDragID) XtRemoveTimeOut(delayedDragID); // cancel pending
3678     delayedDragID =
3679       XtAppAddTimeOut(appContext, 50, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
3680 }
3681
3682 /* Why is this needed on some versions of X? */
3683 void
3684 EventProc (Widget widget, caddr_t unused, XEvent *event)
3685 {
3686     if (!XtIsRealized(widget))
3687       return;
3688     switch (event->type) {
3689       case ConfigureNotify: // main window is being dragged: drag attached windows with it
3690         if(appData.useStickyWindows)
3691             DelayedDrag(); // as long as events keep coming in faster than 50 msec, they destroy each other
3692         break;
3693       case Expose:
3694         if (event->xexpose.count > 0) return;  /* no clipping is done */
3695         DrawPosition(True, NULL);
3696         if(twoBoards) { // [HGM] dual: draw other board in other orientation
3697             flipView = !flipView; partnerUp = !partnerUp;
3698             DrawPosition(True, NULL);
3699             flipView = !flipView; partnerUp = !partnerUp;
3700         }
3701         break;
3702       case MotionNotify:
3703         if(SeekGraphClick(Press, event->xbutton.x, event->xbutton.y, 1)) break;
3704       default:
3705         return;
3706     }
3707 }
3708 /* end why */
3709
3710 // [HGM] seekgraph: some low-level drawing routines cloned from xevalgraph
3711 void
3712 DrawSeekAxis (int x, int y, int xTo, int yTo)
3713 {
3714       XDrawLine(xDisplay, xBoardWindow, lineGC, x, y, xTo, yTo);
3715 }
3716
3717 void
3718 DrawSeekBackground (int left, int top, int right, int bottom)
3719 {
3720     XFillRectangle(xDisplay, xBoardWindow, lightSquareGC, left, top, right-left, bottom-top);
3721 }
3722
3723 void
3724 DrawSeekText (char *buf, int x, int y)
3725 {
3726     XDrawString(xDisplay, xBoardWindow, coordGC, x, y+4, buf, strlen(buf));
3727 }
3728
3729 void
3730 DrawSeekDot (int x, int y, int colorNr)
3731 {
3732     int square = colorNr & 0x80;
3733     GC color;
3734     colorNr &= 0x7F;
3735     color = colorNr == 0 ? prelineGC : colorNr == 1 ? darkSquareGC : highlineGC;
3736     if(square)
3737         XFillRectangle(xDisplay, xBoardWindow, color,
3738                 x-squareSize/9, y-squareSize/9, 2*squareSize/9, 2*squareSize/9);
3739     else
3740         XFillArc(xDisplay, xBoardWindow, color,
3741                 x-squareSize/8, y-squareSize/8, squareSize/4, squareSize/4, 0, 64*360);
3742 }
3743
3744 void
3745 DrawGrid (int second)
3746 {
3747           XDrawSegments(xDisplay, xBoardWindow, lineGC,
3748                         second ? secondSegments : // [HGM] dual
3749                         gridSegments, BOARD_HEIGHT + BOARD_WIDTH + 2);
3750 }
3751
3752
3753 /*
3754  * event handler for redrawing the board
3755  */
3756 void
3757 DrawPositionProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3758 {
3759     DrawPosition(True, NULL);
3760 }
3761
3762
3763 /*
3764  * event handler for parsing user moves
3765  */
3766 // [HGM] This routine will need quite some reworking. Although the backend still supports the old
3767 //       way of doing things, by calling UserMoveEvent() to test the legality of the move and then perform
3768 //       it at the end, and doing all kind of preliminary tests here (e.g. to weed out self-captures), it
3769 //       should be made to use the new way, of calling UserMoveTest early  to determine the legality of the
3770 //       move, (which will weed out the illegal selfcaptures and moves into the holdings, and flag promotions),
3771 //       and at the end FinishMove() to perform the move after optional promotion popups.
3772 //       For now I patched it to allow self-capture with King, and suppress clicks between board and holdings.
3773 void
3774 HandleUserMove (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3775 {
3776     if (w != boardWidget || errorExitStatus != -1) return;
3777     if(nprms) shiftKey = !strcmp(prms[0], "1");
3778
3779     if (promotionUp) {
3780         if (event->type == ButtonPress) {
3781             XtPopdown(promotionShell);
3782             XtDestroyWidget(promotionShell);
3783             promotionUp = False;
3784             ClearHighlights();
3785             fromX = fromY = -1;
3786         } else {
3787             return;
3788         }
3789     }
3790
3791     // [HGM] mouse: the rest of the mouse handler is moved to the backend, and called here
3792     if(event->type == ButtonPress)   LeftClick(Press,   event->xbutton.x, event->xbutton.y);
3793     if(event->type == ButtonRelease) LeftClick(Release, event->xbutton.x, event->xbutton.y);
3794 }
3795
3796 void
3797 AnimateUserMove (Widget w, XEvent *event, String *params, Cardinal *nParams)
3798 {
3799     if(!PromoScroll(event->xmotion.x, event->xmotion.y))
3800     DragPieceMove(event->xmotion.x, event->xmotion.y);
3801 }
3802
3803 void
3804 HandlePV (Widget w, XEvent * event, String * params, Cardinal * nParams)
3805 {   // [HGM] pv: walk PV
3806     MovePV(event->xmotion.x, event->xmotion.y, lineGap + BOARD_HEIGHT * (squareSize + lineGap));
3807 }
3808
3809 static int savedIndex;  /* gross that this is global */
3810
3811 void
3812 CommentClick (Widget w, XEvent * event, String * params, Cardinal * nParams)
3813 {
3814         String val;
3815         XawTextPosition index, dummy;
3816         Arg arg;
3817
3818         XawTextGetSelectionPos(w, &index, &dummy);
3819         XtSetArg(arg, XtNstring, &val);
3820         XtGetValues(w, &arg, 1);
3821         ReplaceComment(savedIndex, val);
3822         if(savedIndex != currentMove) ToNrEvent(savedIndex);
3823         LoadVariation( index, val ); // [HGM] also does the actual moving to it, now
3824 }
3825
3826 void
3827 EditCommentPopUp (int index, char *title, char *text)
3828 {
3829     savedIndex = index;
3830     if (text == NULL) text = "";
3831     NewCommentPopup(title, text, index);
3832 }
3833
3834 void
3835 ICSInputBoxPopUp ()
3836 {
3837     InputBoxPopup();
3838 }
3839
3840 extern Option boxOptions[];
3841
3842 void
3843 ICSInputSendText ()
3844 {
3845     Widget edit;
3846     int j;
3847     Arg args[16];
3848     String val;
3849
3850     edit = boxOptions[0].handle;
3851     j = 0;
3852     XtSetArg(args[j], XtNstring, &val); j++;
3853     XtGetValues(edit, args, j);
3854     SaveInHistory(val);
3855     SendMultiLineToICS(val);
3856     XtCallActionProc(edit, "select-all", NULL, NULL, 0);
3857     XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);
3858 }
3859
3860 void
3861 ICSInputBoxPopDown ()
3862 {
3863     PopDown(4);
3864 }
3865
3866 void
3867 CommentPopUp (char *title, char *text)
3868 {
3869     savedIndex = currentMove; // [HGM] vari
3870     NewCommentPopup(title, text, currentMove);
3871 }
3872
3873 void
3874 CommentPopDown ()
3875 {
3876     PopDown(1);
3877 }
3878
3879 static char *openName;
3880 FILE *openFP;
3881
3882 void
3883 DelayedLoad ()
3884 {
3885   (void) (*fileProc)(openFP, 0, openName);
3886 }
3887
3888 void
3889 FileNamePopUp (char *label, char *def, char *filter, FileProc proc, char *openMode)
3890 {
3891     fileProc = proc;            /* I can't see a way not */
3892     fileOpenMode = openMode;    /*   to use globals here */
3893     {   // [HGM] use file-selector dialog stolen from Ghostview
3894         int index; // this is not supported yet
3895         if(openFP = XsraSelFile(shellWidget, label, NULL, NULL, _("could not open: "),
3896                            (def[0] ? def : NULL), filter, openMode, NULL, &openName))
3897           // [HGM] delay to give expose event opportunity to redraw board after browser-dialog popdown before lengthy load starts
3898           ScheduleDelayedEvent(&DelayedLoad, 50);
3899     }
3900 }
3901
3902 void
3903 FileNamePopDown ()
3904 {
3905     if (!filenameUp) return;
3906     XtPopdown(fileNameShell);
3907     XtDestroyWidget(fileNameShell);
3908     filenameUp = False;
3909     ModeHighlight();
3910 }
3911
3912 void
3913 FileNameCallback (Widget w, XtPointer client_data, XtPointer call_data)
3914 {
3915     String name;
3916     Arg args[16];
3917
3918     XtSetArg(args[0], XtNlabel, &name);
3919     XtGetValues(w, args, 1);
3920
3921     if (strcmp(name, _("cancel")) == 0) {
3922         FileNamePopDown();
3923         return;
3924     }
3925
3926     FileNameAction(w, NULL, NULL, NULL);
3927 }
3928
3929 void
3930 FileNameAction (Widget w, XEvent *event, String *prms, Cardinal *nprms)
3931 {
3932     char buf[MSG_SIZ];
3933     String name;
3934     FILE *f;
3935     char *p, *fullname;
3936     int index;
3937
3938     name = XawDialogGetValueString(w = XtParent(w));
3939
3940     if ((name != NULL) && (*name != NULLCHAR)) {
3941         safeStrCpy(buf, name, sizeof(buf)/sizeof(buf[0]) );
3942         XtPopdown(w = XtParent(XtParent(w)));
3943         XtDestroyWidget(w);
3944         filenameUp = False;
3945
3946         p = strrchr(buf, ' ');
3947         if (p == NULL) {
3948             index = 0;
3949         } else {
3950             *p++ = NULLCHAR;
3951             index = atoi(p);
3952         }
3953         fullname = ExpandPathName(buf);
3954         if (!fullname) {
3955             ErrorPopUp(_("Error"), _("Can't open file"), FALSE);
3956         }
3957         else {
3958             f = fopen(fullname, fileOpenMode);
3959             if (f == NULL) {
3960                 DisplayError(_("Failed to open file"), errno);
3961             } else {
3962                 (void) (*fileProc)(f, index, buf);
3963             }
3964         }
3965         ModeHighlight();
3966         return;
3967     }
3968
3969     XtPopdown(w = XtParent(XtParent(w)));
3970     XtDestroyWidget(w);
3971     filenameUp = False;
3972     ModeHighlight();
3973 }
3974
3975 void
3976 PromotionPopUp ()
3977 {
3978     Arg args[16];
3979     Widget dialog, layout;
3980     Position x, y;
3981     Dimension bw_width, pw_width;
3982     int j;
3983     char *PromoChars = "wglcqrbnkac+=\0";
3984
3985     j = 0;
3986     XtSetArg(args[j], XtNwidth, &bw_width); j++;
3987     XtGetValues(boardWidget, args, j);
3988
3989     j = 0;
3990     XtSetArg(args[j], XtNresizable, True); j++;
3991     XtSetArg(args[j], XtNtitle, XtNewString(_("Promotion"))); j++;
3992     promotionShell =
3993       XtCreatePopupShell("Promotion", transientShellWidgetClass,
3994                          shellWidget, args, j);
3995     layout =
3996       XtCreateManagedWidget(layoutName, formWidgetClass, promotionShell,
3997                             layoutArgs, XtNumber(layoutArgs));
3998
3999     j = 0;
4000     XtSetArg(args[j], XtNlabel, _("Promote to what?")); j++;
4001     XtSetArg(args[j], XtNborderWidth, 0); j++;
4002     dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
4003                                    layout, args, j);
4004
4005   if(gameInfo.variant != VariantShogi) {
4006    if(gameInfo.variant == VariantSpartan && !WhiteOnMove(currentMove)) {
4007       XawDialogAddButton(dialog, _("Warlord"), PromotionCallback, PromoChars + 0);
4008       XawDialogAddButton(dialog, _("General"), PromotionCallback, PromoChars + 1);
4009       XawDialogAddButton(dialog, _("Lieutenant"), PromotionCallback, PromoChars + 2);
4010       XawDialogAddButton(dialog, _("Captain"), PromotionCallback, PromoChars + 3);
4011     } else {
4012     XawDialogAddButton(dialog, _("Queen"), PromotionCallback, PromoChars + 4);
4013     XawDialogAddButton(dialog, _("Rook"), PromotionCallback, PromoChars + 5);
4014     XawDialogAddButton(dialog, _("Bishop"), PromotionCallback, PromoChars + 6);
4015     XawDialogAddButton(dialog, _("Knight"), PromotionCallback, PromoChars + 7);
4016     }
4017     if (!appData.testLegality || gameInfo.variant == VariantSuicide ||
4018         gameInfo.variant == VariantSpartan && !WhiteOnMove(currentMove) ||
4019         gameInfo.variant == VariantGiveaway) {
4020       XawDialogAddButton(dialog, _("King"), PromotionCallback, PromoChars + 8);
4021     }
4022     if(gameInfo.variant == VariantCapablanca ||
4023        gameInfo.variant == VariantGothic ||
4024        gameInfo.variant == VariantCapaRandom) {
4025       XawDialogAddButton(dialog, _("Archbishop"), PromotionCallback, PromoChars + 9);
4026       XawDialogAddButton(dialog, _("Chancellor"), PromotionCallback, PromoChars + 10);
4027     }
4028   } else // [HGM] shogi
4029   {
4030       XawDialogAddButton(dialog, _("Promote"), PromotionCallback, PromoChars + 11);
4031       XawDialogAddButton(dialog, _("Defer"), PromotionCallback, PromoChars + 12);
4032   }
4033     XawDialogAddButton(dialog, _("cancel"), PromotionCallback, PromoChars + 13);
4034
4035     XtRealizeWidget(promotionShell);
4036     CatchDeleteWindow(promotionShell, "PromotionPopDown");
4037
4038     j = 0;
4039     XtSetArg(args[j], XtNwidth, &pw_width); j++;
4040     XtGetValues(promotionShell, args, j);
4041
4042     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
4043                       lineGap + squareSize/3 +
4044                       ((toY == BOARD_HEIGHT-1) ^ (flipView) ?
4045                        0 : 6*(squareSize + lineGap)), &x, &y);
4046
4047     j = 0;
4048     XtSetArg(args[j], XtNx, x); j++;
4049     XtSetArg(args[j], XtNy, y); j++;
4050     XtSetValues(promotionShell, args, j);
4051
4052     XtPopup(promotionShell, XtGrabNone);
4053
4054     promotionUp = True;
4055 }
4056
4057 void
4058 PromotionPopDown ()
4059 {
4060     if (!promotionUp) return;
4061     XtPopdown(promotionShell);
4062     XtDestroyWidget(promotionShell);
4063     promotionUp = False;
4064 }
4065
4066 void
4067 PromotionCallback (Widget w, XtPointer client_data, XtPointer call_data)
4068 {
4069     int promoChar = * (const char *) client_data;
4070
4071     PromotionPopDown();
4072
4073     if (fromX == -1) return;
4074
4075     if (! promoChar) {
4076         fromX = fromY = -1;
4077         ClearHighlights();
4078         return;
4079     }
4080     UserMoveEvent(fromX, fromY, toX, toY, promoChar);
4081
4082     if (!appData.highlightLastMove || gotPremove) ClearHighlights();
4083     if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
4084     fromX = fromY = -1;
4085 }
4086
4087
4088 void
4089 ErrorCallback (Widget w, XtPointer client_data, XtPointer call_data)
4090 {
4091     dialogError = errorUp = False;
4092     XtPopdown(w = XtParent(XtParent(XtParent(w))));
4093     XtDestroyWidget(w);
4094     if (errorExitStatus != -1) ExitEvent(errorExitStatus);
4095 }
4096
4097
4098 void
4099 ErrorPopDown ()
4100 {
4101     if (!errorUp) return;
4102     dialogError = errorUp = False;
4103     XtPopdown(errorShell);
4104     XtDestroyWidget(errorShell);
4105     if (errorExitStatus != -1) ExitEvent(errorExitStatus);
4106 }
4107
4108 void
4109 ErrorPopUp (char *title, char *label, int modal)
4110 {
4111     Arg args[16];
4112     Widget dialog, layout;
4113     Position x, y;
4114     int xx, yy;
4115     Window junk;
4116     Dimension bw_width, pw_width;
4117     Dimension pw_height;
4118     int i;
4119
4120     i = 0;
4121     XtSetArg(args[i], XtNresizable, True);  i++;
4122     XtSetArg(args[i], XtNtitle, title); i++;
4123     errorShell =
4124       XtCreatePopupShell("errorpopup", transientShellWidgetClass,
4125                          shellUp[0] ? (dialogError = modal = TRUE, shells[0]) : shellWidget, args, i);
4126     layout =
4127       XtCreateManagedWidget(layoutName, formWidgetClass, errorShell,
4128                             layoutArgs, XtNumber(layoutArgs));
4129
4130     i = 0;
4131     XtSetArg(args[i], XtNlabel, label); i++;
4132     XtSetArg(args[i], XtNborderWidth, 0); i++;
4133     dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
4134                                    layout, args, i);
4135
4136     XawDialogAddButton(dialog, _("ok"), ErrorCallback, (XtPointer) dialog);
4137
4138     XtRealizeWidget(errorShell);
4139     CatchDeleteWindow(errorShell, "ErrorPopDown");
4140
4141     i = 0;
4142     XtSetArg(args[i], XtNwidth, &bw_width);  i++;
4143     XtGetValues(boardWidget, args, i);
4144     i = 0;
4145     XtSetArg(args[i], XtNwidth, &pw_width);  i++;
4146     XtSetArg(args[i], XtNheight, &pw_height);  i++;
4147     XtGetValues(errorShell, args, i);
4148
4149 #ifdef NOTDEF
4150     /* This code seems to tickle an X bug if it is executed too soon
4151        after xboard starts up.  The coordinates get transformed as if
4152        the main window was positioned at (0, 0).
4153        */
4154     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
4155                       0 - pw_height + squareSize / 3, &x, &y);
4156 #else
4157     XTranslateCoordinates(xDisplay, XtWindow(boardWidget),
4158                           RootWindowOfScreen(XtScreen(boardWidget)),
4159                           (bw_width - pw_width) / 2,
4160                           0 - pw_height + squareSize / 3, &xx, &yy, &junk);
4161     x = xx;
4162     y = yy;
4163 #endif
4164     if (y < 0) y = 0; /*avoid positioning top offscreen*/
4165
4166     i = 0;
4167     XtSetArg(args[i], XtNx, x);  i++;
4168     XtSetArg(args[i], XtNy, y);  i++;
4169     XtSetValues(errorShell, args, i);
4170
4171     errorUp = True;
4172     XtPopup(errorShell, modal ? XtGrabExclusive : XtGrabNone);
4173 }
4174
4175 /* Disable all user input other than deleting the window */
4176 static int frozen = 0;
4177
4178 void
4179 FreezeUI ()
4180 {
4181   if (frozen) return;
4182   /* Grab by a widget that doesn't accept input */
4183   XtAddGrab(messageWidget, TRUE, FALSE);
4184   frozen = 1;
4185 }
4186
4187 /* Undo a FreezeUI */
4188 void
4189 ThawUI ()
4190 {
4191   if (!frozen) return;
4192   XtRemoveGrab(messageWidget);
4193   frozen = 0;
4194 }
4195
4196 void
4197 ModeHighlight ()
4198 {
4199     Arg args[16];
4200     static int oldPausing = FALSE;
4201     static GameMode oldmode = (GameMode) -1;
4202     char *wname;
4203
4204     if (!boardWidget || !XtIsRealized(boardWidget)) return;
4205
4206     if (pausing != oldPausing) {
4207         oldPausing = pausing;
4208         MarkMenuItem("Pause", pausing);
4209
4210         if (appData.showButtonBar) {
4211           /* Always toggle, don't set.  Previous code messes up when
4212              invoked while the button is pressed, as releasing it
4213              toggles the state again. */
4214           {
4215             Pixel oldbg, oldfg;
4216             XtSetArg(args[0], XtNbackground, &oldbg);
4217             XtSetArg(args[1], XtNforeground, &oldfg);
4218             XtGetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON),
4219                         args, 2);
4220             XtSetArg(args[0], XtNbackground, oldfg);
4221             XtSetArg(args[1], XtNforeground, oldbg);
4222           }
4223           XtSetValues(XtNameToWidget(buttonBarWidget, PAUSE_BUTTON), args, 2);
4224         }
4225     }
4226
4227     wname = ModeToWidgetName(oldmode);
4228     if (wname != NULL) {
4229         MarkMenuItem(wname, False);
4230     }
4231     wname = ModeToWidgetName(gameMode);
4232     if (wname != NULL) {
4233         MarkMenuItem(wname, True);
4234     }
4235     oldmode = gameMode;
4236     MarkMenuItem("Machine Match", matchMode && matchGame < appData.matchGames);
4237
4238     /* Maybe all the enables should be handled here, not just this one */
4239     EnableMenuItem("Training", gameMode == Training || gameMode == PlayFromGameFile);
4240 }
4241
4242
4243 /*
4244  * Button/menu procedures
4245  */
4246 int
4247 LoadGamePopUp (FILE *f, int gameNumber, char *title)
4248 {
4249     cmailMsgLoaded = FALSE;
4250     if (gameNumber == 0) {
4251         int error = GameListBuild(f);
4252         if (error) {
4253             DisplayError(_("Cannot build game list"), error);
4254         } else if (!ListEmpty(&gameList) &&
4255                    ((ListGame *) gameList.tailPred)->number > 1) {
4256             GameListPopUp(f, title);
4257             return TRUE;
4258         }
4259         GameListDestroy();
4260         gameNumber = 1;
4261     }
4262     return LoadGame(f, gameNumber, title, FALSE);
4263 }
4264
4265 /* this variable is shared between CopyPositionProc and SendPositionSelection */
4266 char *selected_fen_position=NULL;
4267
4268 Boolean
4269 SendPositionSelection (Widget w, Atom *selection, Atom *target,
4270                        Atom *type_return, XtPointer *value_return,
4271                        unsigned long *length_return, int *format_return)
4272 {
4273   char *selection_tmp;
4274
4275   if (!selected_fen_position) return False; /* should never happen */
4276   if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
4277     /* note: since no XtSelectionDoneProc was registered, Xt will
4278      * automatically call XtFree on the value returned.  So have to
4279      * make a copy of it allocated with XtMalloc */
4280     selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
4281     safeStrCpy(selection_tmp, selected_fen_position, strlen(selected_fen_position)+16 );
4282
4283     *value_return=selection_tmp;
4284     *length_return=strlen(selection_tmp);
4285     *type_return=*target;
4286     *format_return = 8; /* bits per byte */
4287     return True;
4288   } else if (*target == XA_TARGETS(xDisplay)) {
4289     Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
4290     targets_tmp[0] = XA_UTF8_STRING(xDisplay);
4291     targets_tmp[1] = XA_STRING;
4292     *value_return = targets_tmp;
4293     *type_return = XA_ATOM;
4294     *length_return = 2;
4295 #if 0
4296     // This code leads to a read of value_return out of bounds on 64-bit systems.
4297     // Other code which I have seen always sets *format_return to 32 independent of
4298     // sizeof(Atom) without adjusting *length_return. For instance see TextConvertSelection()
4299     // at http://cgit.freedesktop.org/xorg/lib/libXaw/tree/src/Text.c -- BJ
4300     *format_return = 8 * sizeof(Atom);
4301     if (*format_return > 32) {
4302       *length_return *= *format_return / 32;
4303       *format_return = 32;
4304     }
4305 #else
4306     *format_return = 32;
4307 #endif
4308     return True;
4309   } else {
4310     return False;
4311   }
4312 }
4313
4314 /* note: when called from menu all parameters are NULL, so no clue what the
4315  * Widget which was clicked on was, or what the click event was
4316  */
4317 void
4318 CopyPositionProc ()
4319 {
4320     /*
4321      * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
4322      * have a notion of a position that is selected but not copied.
4323      * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
4324      */
4325     if(gameMode == EditPosition) EditPositionDone(TRUE);
4326     if (selected_fen_position) free(selected_fen_position);
4327     selected_fen_position = (char *)PositionToFEN(currentMove, NULL);
4328     if (!selected_fen_position) return;
4329     XtOwnSelection(menuBarWidget, XA_PRIMARY,
4330                    CurrentTime,
4331                    SendPositionSelection,
4332                    NULL/* lose_ownership_proc */ ,
4333        &nbs