Update sr.po translation
[xboard.git] / xaw / 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, 2013, 2014, 2015, 2016 Free
9  * Software Foundation, Inc.
10  *
11  * The following terms apply to Digital Equipment Corporation's copyright
12  * interest in XBoard:
13  * ------------------------------------------------------------------------
14  * All Rights Reserved
15  *
16  * Permission to use, copy, modify, and distribute this software and its
17  * documentation for any purpose and without fee is hereby granted,
18  * provided that the above copyright notice appear in all copies and that
19  * both that copyright notice and this permission notice appear in
20  * supporting documentation, and that the name of Digital not be
21  * used in advertising or publicity pertaining to distribution of the
22  * software without specific, written prior permission.
23  *
24  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
25  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
26  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
27  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
28  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
29  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
30  * SOFTWARE.
31  * ------------------------------------------------------------------------
32  *
33  * The following terms apply to the enhanced version of XBoard
34  * distributed by the Free Software Foundation:
35  * ------------------------------------------------------------------------
36  *
37  * GNU XBoard is free software: you can redistribute it and/or modify
38  * it under the terms of the GNU General Public License as published by
39  * the Free Software Foundation, either version 3 of the License, or (at
40  * your option) any later version.
41  *
42  * GNU XBoard is distributed in the hope that it will be useful, but
43  * WITHOUT ANY WARRANTY; without even the implied warranty of
44  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
45  * General Public License for more details.
46  *
47  * You should have received a copy of the GNU General Public License
48  * along with this program. If not, see http://www.gnu.org/licenses/.  *
49  *
50  *------------------------------------------------------------------------
51  ** See the file ChangeLog for a revision history.  */
52
53 #define HIGHDRAG 1
54
55 #include "config.h"
56
57 #include <stdio.h>
58 #include <ctype.h>
59 #include <signal.h>
60 #include <errno.h>
61 #include <sys/types.h>
62 #include <sys/stat.h>
63 #include <pwd.h>
64 #include <math.h>
65 #include <cairo/cairo.h>
66 #include <cairo/cairo-xlib.h>
67
68 #if !OMIT_SOCKETS
69 # if HAVE_SYS_SOCKET_H
70 #  include <sys/socket.h>
71 #  include <netinet/in.h>
72 #  include <netdb.h>
73 # else /* not HAVE_SYS_SOCKET_H */
74 #  if HAVE_LAN_SOCKET_H
75 #   include <lan/socket.h>
76 #   include <lan/in.h>
77 #   include <lan/netdb.h>
78 #  else /* not HAVE_LAN_SOCKET_H */
79 #   define OMIT_SOCKETS 1
80 #  endif /* not HAVE_LAN_SOCKET_H */
81 # endif /* not HAVE_SYS_SOCKET_H */
82 #endif /* !OMIT_SOCKETS */
83
84 #if STDC_HEADERS
85 # include <stdlib.h>
86 # include <string.h>
87 #else /* not STDC_HEADERS */
88 extern char *getenv();
89 # if HAVE_STRING_H
90 #  include <string.h>
91 # else /* not HAVE_STRING_H */
92 #  include <strings.h>
93 # endif /* not HAVE_STRING_H */
94 #endif /* not STDC_HEADERS */
95
96 #if HAVE_SYS_FCNTL_H
97 # include <sys/fcntl.h>
98 #else /* not HAVE_SYS_FCNTL_H */
99 # if HAVE_FCNTL_H
100 #  include <fcntl.h>
101 # endif /* HAVE_FCNTL_H */
102 #endif /* not HAVE_SYS_FCNTL_H */
103
104 #if HAVE_SYS_SYSTEMINFO_H
105 # include <sys/systeminfo.h>
106 #endif /* HAVE_SYS_SYSTEMINFO_H */
107
108 #if TIME_WITH_SYS_TIME
109 # include <sys/time.h>
110 # include <time.h>
111 #else
112 # if HAVE_SYS_TIME_H
113 #  include <sys/time.h>
114 # else
115 #  include <time.h>
116 # endif
117 #endif
118
119 #if HAVE_UNISTD_H
120 # include <unistd.h>
121 #endif
122
123 #if HAVE_SYS_WAIT_H
124 # include <sys/wait.h>
125 #endif
126
127 #if HAVE_DIRENT_H
128 # include <dirent.h>
129 # define NAMLEN(dirent) strlen((dirent)->d_name)
130 # define HAVE_DIR_STRUCT
131 #else
132 # define dirent direct
133 # define NAMLEN(dirent) (dirent)->d_namlen
134 # if HAVE_SYS_NDIR_H
135 #  include <sys/ndir.h>
136 #  define HAVE_DIR_STRUCT
137 # endif
138 # if HAVE_SYS_DIR_H
139 #  include <sys/dir.h>
140 #  define HAVE_DIR_STRUCT
141 # endif
142 # if HAVE_NDIR_H
143 #  include <ndir.h>
144 #  define HAVE_DIR_STRUCT
145 # endif
146 #endif
147
148 #if ENABLE_NLS
149 #include <locale.h>
150 #endif
151
152 #include <X11/keysym.h>
153 #include <X11/Intrinsic.h>
154 #include <X11/StringDefs.h>
155 #include <X11/Shell.h>
156 #include <X11/cursorfont.h>
157 #include <X11/Xatom.h>
158 #include <X11/Xmu/Atoms.h>
159 #if USE_XAW3D
160 #include <X11/Xaw3d/Dialog.h>
161 #include <X11/Xaw3d/Form.h>
162 #include <X11/Xaw3d/List.h>
163 #include <X11/Xaw3d/Label.h>
164 #include <X11/Xaw3d/SimpleMenu.h>
165 #include <X11/Xaw3d/SmeBSB.h>
166 #include <X11/Xaw3d/SmeLine.h>
167 #include <X11/Xaw3d/Box.h>
168 #include <X11/Xaw3d/MenuButton.h>
169 #include <X11/Xaw3d/Text.h>
170 #include <X11/Xaw3d/AsciiText.h>
171 #else
172 #include <X11/Xaw/Dialog.h>
173 #include <X11/Xaw/Form.h>
174 #include <X11/Xaw/List.h>
175 #include <X11/Xaw/Label.h>
176 #include <X11/Xaw/SimpleMenu.h>
177 #include <X11/Xaw/SmeBSB.h>
178 #include <X11/Xaw/SmeLine.h>
179 #include <X11/Xaw/Box.h>
180 #include <X11/Xaw/MenuButton.h>
181 #include <X11/Xaw/Text.h>
182 #include <X11/Xaw/AsciiText.h>
183 #endif
184
185 // [HGM] bitmaps: put before incuding the bitmaps / pixmaps, to know how many piece types there are.
186 #include "common.h"
187
188 #include "bitmaps/icon_white.bm"
189 #include "bitmaps/icon_black.bm"
190 #include "bitmaps/checkmark.bm"
191
192 #include "frontend.h"
193 #include "backend.h"
194 #include "backendz.h"
195 #include "moves.h"
196 #include "xboard.h"
197 #include "childio.h"
198 #include "xgamelist.h"
199 #include "xhistory.h"
200 #include "menus.h"
201 #include "board.h"
202 #include "dialogs.h"
203 #include "engineoutput.h"
204 #include "usystem.h"
205 #include "gettext.h"
206 #include "draw.h"
207
208 #define SLASH '/'
209
210 #ifdef __EMX__
211 #ifndef HAVE_USLEEP
212 #define HAVE_USLEEP
213 #endif
214 #define usleep(t)   _sleep2(((t)+500)/1000)
215 #endif
216
217 #ifdef ENABLE_NLS
218 # define  _(s) gettext (s)
219 # define N_(s) gettext_noop (s)
220 #else
221 # define  _(s) (s)
222 # define N_(s)  s
223 #endif
224
225 int main P((int argc, char **argv));
226 RETSIGTYPE CmailSigHandler P((int sig));
227 RETSIGTYPE IntSigHandler P((int sig));
228 RETSIGTYPE TermSizeSigHandler P((int sig));
229 Widget CreateMenuBar P((Menu *mb, int boardWidth));
230 #if ENABLE_NLS
231 char *InsertPxlSize P((char *pattern, int targetPxlSize));
232 XFontSet CreateFontSet P((char *base_fnt_lst));
233 #else
234 char *FindFont P((char *pattern, int targetPxlSize));
235 #endif
236 void ReadBitmap P((Pixmap *pm, String name, unsigned char bits[],
237                    u_int wreq, u_int hreq));
238 void EventProc P((Widget widget, caddr_t unused, XEvent *event));
239 void DelayedDrag P((void));
240 static void MoveTypeInProc P((Widget widget, caddr_t unused, XEvent *event));
241 void HandlePV P((Widget w, XEvent * event,
242                      String * params, Cardinal * nParams));
243 void DrawPositionProc P((Widget w, XEvent *event,
244                      String *prms, Cardinal *nprms));
245 void CommentClick P((Widget w, XEvent * event,
246                    String * params, Cardinal * nParams));
247 void ICSInputBoxPopUp P((void));
248 void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
249 void KeyBindingProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
250 void QuitWrapper P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
251 static void EnterKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
252 static void UpKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
253 static void DownKeyProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
254 void TempBackwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
255 void TempForwardProc P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
256 Boolean TempBackwardActive = False;
257 void ManInner P((Widget w, XEvent *event, String *prms, Cardinal *nprms));
258 void DisplayMove P((int moveNumber));
259 void update_ics_width P(());
260 int CopyMemoProc P(());
261 static int FindLogo P((char *place, char *name, char *buf));
262
263 /*
264 * XBoard depends on Xt R4 or higher
265 */
266 int xtVersion = XtSpecificationRelease;
267
268 int xScreen;
269 Display *xDisplay;
270 Window xBoardWindow;
271 Pixel lowTimeWarningColor, dialogColor, buttonColor; // used in widgets
272 Pixmap iconPixmap, wIconPixmap, bIconPixmap, xMarkPixmap;
273 Widget shellWidget, formWidget, boardWidget, titleWidget, dropMenu, menuBarWidget;
274 Option *optList; // contains all widgets of main window
275 #if ENABLE_NLS
276 XFontSet fontSet, clockFontSet;
277 #else
278 Font clockFontID;
279 XFontStruct *clockFontStruct;
280 #endif
281 Font coordFontID, countFontID;
282 XFontStruct *coordFontStruct, *countFontStruct;
283 XtAppContext appContext;
284 char *layoutName;
285
286 char installDir[] = "."; // [HGM] UCI: needed for UCI; probably needs run-time initializtion
287
288 Position commentX = -1, commentY = -1;
289 Dimension commentW, commentH;
290 typedef unsigned int BoardSize;
291 BoardSize boardSize;
292 Boolean chessProgram;
293
294 int  minX, minY; // [HGM] placement: volatile limits on upper-left corner
295 int smallLayout = 0, tinyLayout = 0,
296   marginW, marginH, // [HGM] for run-time resizing
297   fromX = -1, fromY = -1, toX, toY, commentUp = False,
298   errorExitStatus = -1, defaultLineGap;
299 Dimension textHeight;
300 Pixel timerForegroundPixel, timerBackgroundPixel;
301 Pixel buttonForegroundPixel, buttonBackgroundPixel;
302 char *chessDir, *programName, *programVersion;
303 Boolean alwaysOnTop = False;
304 char *icsTextMenuString;
305 char *icsNames;
306 char *firstChessProgramNames;
307 char *secondChessProgramNames;
308
309 WindowPlacement wpMain;
310 WindowPlacement wpConsole;
311 WindowPlacement wpComment;
312 WindowPlacement wpMoveHistory;
313 WindowPlacement wpEvalGraph;
314 WindowPlacement wpEngineOutput;
315 WindowPlacement wpGameList;
316 WindowPlacement wpTags;
317 WindowPlacement wpDualBoard;
318
319
320 /* This magic number is the number of intermediate frames used
321    in each half of the animation. For short moves it's reduced
322    by 1. The total number of frames will be factor * 2 + 1.  */
323 #define kFactor    4
324
325 SizeDefaults sizeDefaults[] = SIZE_DEFAULTS;
326
327 typedef struct {
328     char piece;
329     char* widget;
330 } DropMenuEnables;
331
332 DropMenuEnables dmEnables[] = {
333     { 'P', "Pawn" },
334     { 'N', "Knight" },
335     { 'B', "Bishop" },
336     { 'R', "Rook" },
337     { 'Q', "Queen" }
338 };
339
340 Arg shellArgs[] = {
341     { XtNwidth, 0 },
342     { XtNheight, 0 },
343     { XtNminWidth, 0 },
344     { XtNminHeight, 0 },
345     { XtNmaxWidth, 0 },
346     { XtNmaxHeight, 0 }
347 };
348
349 XtResource clientResources[] = {
350     { "flashCount", "flashCount", XtRInt, sizeof(int),
351         XtOffset(AppDataPtr, flashCount), XtRImmediate,
352         (XtPointer) FLASH_COUNT  },
353 };
354
355 XrmOptionDescRec shellOptions[] = {
356     { "-flashCount", "flashCount", XrmoptionSepArg, NULL },
357     { "-flash", "flashCount", XrmoptionNoArg, "3" },
358     { "-xflash", "flashCount", XrmoptionNoArg, "0" },
359 };
360
361 XtActionsRec boardActions[] = {
362     { "DrawPosition", DrawPositionProc },
363     { "HandlePV", HandlePV },
364     { "SelectPV", SelectPV },
365     { "StopPV", StopPV },
366     { "MenuItem", KeyBindingProc }, // [HGM] generic handler for key bindings
367     { "QuitProc", QuitWrapper },
368     { "ManProc", ManInner },
369     { "TempBackwardProc", TempBackwardProc },
370     { "TempForwardProc", TempForwardProc },
371     { "CommentClick", (XtActionProc) CommentClick },
372     { "GenericPopDown", (XtActionProc) GenericPopDown },
373     { "ErrorPopDown", (XtActionProc) ErrorPopDown },
374     { "CopyMemoProc", (XtActionProc) CopyMemoProc },
375     { "SelectMove", (XtActionProc) SelectMoveX },
376     { "LoadSelectedProc", LoadSelectedProc },
377     { "SetFilterProc", SetFilterProc },
378     { "TypeInProc", TypeInProc },
379     { "EnterKeyProc", EnterKeyProc },
380     { "UpKeyProc", UpKeyProc },
381     { "DownKeyProc", DownKeyProc },
382     { "WheelProc", WheelProc },
383     { "TabProc", TabProc },
384 };
385
386 char globalTranslations[] =
387   ":Meta<Key>Next: MenuItem(LoadNextGameProc) \n \
388    :Meta<Key>Prior: MenuItem(LoadPrevGameProc) \n \
389    :Ctrl<Key>Down: LoadSelectedProc(3) \n \
390    :Ctrl<Key>Up: LoadSelectedProc(-3) \n \
391    :Shift<Key>Next: MenuItem(LoadNextPositionProc) \n \
392    :Shift<Key>Prior: MenuItem(LoadPrevPositionProc) \n \
393    :<Key>Pause: MenuItem(Mode.Pause) \n \
394    :Ctrl<Key>d: MenuItem(DebugProc) \n \
395    :Meta Ctrl<Key>F12: MenuItem(DebugProc) \n \
396    :<Key>Left: MenuItem(Edit.Backward) \n \
397    :<Key>Right: MenuItem(Edit.Forward) \n \
398    :Ctrl<Key>P: MenuItem(PonderNextMove) \n "
399 #ifndef OPTIONSDIALOG
400     "\
401    :Ctrl<Key>Q: MenuItem(AlwaysQueenProc) \n \
402    :Ctrl<Key>F: MenuItem(AutoflagProc) \n \
403    :Ctrl<Key>A: MenuItem(AnimateMovingProc) \n \
404    :Ctrl<Key>L: MenuItem(TestLegalityProc) \n \
405    :Ctrl<Key>H: MenuItem(HideThinkingProc) \n "
406 #endif
407    "\
408    :<KeyDown>Return: TempBackwardProc() \n \
409    :<KeyUp>Return: TempForwardProc() \n";
410
411 char ICSInputTranslations[] =
412     "<Key>Up: UpKeyProc() \n "
413     "<Key>Down: DownKeyProc() \n "
414     "<Key>Return: EnterKeyProc() \n";
415
416 // [HGM] vari: another hideous kludge: call extend-end first so we can be sure select-start works,
417 //             as the widget is destroyed before the up-click can call extend-end
418 char commentTranslations[] = "<Btn3Down>: extend-end(PRIMARY) select-start() CommentClick() \n";
419
420 String xboardResources[] = {
421     "*Error*translations: #override\\n <Key>Return: ErrorPopDown()",
422     NULL
423   };
424
425
426 /* Max possible square size */
427 #define MAXSQSIZE 256
428
429 /* Arrange to catch delete-window events */
430 Atom wm_delete_window;
431 void
432 CatchDeleteWindow (Widget w, String procname)
433 {
434   char buf[MSG_SIZ];
435   XSetWMProtocols(xDisplay, XtWindow(w), &wm_delete_window, 1);
436   snprintf(buf, sizeof(buf), "<Message>WM_PROTOCOLS: %s() \n", procname);
437   XtAugmentTranslations(w, XtParseTranslationTable(buf));
438 }
439
440 void
441 BoardToTop ()
442 {
443   Arg args[16];
444   XtSetArg(args[0], XtNiconic, False);
445   XtSetValues(shellWidget, args, 1);
446
447   XtPopup(shellWidget, XtGrabNone); /* Raise if lowered  */
448 }
449
450 //---------------------------------------------------------------------------------------------------------
451 // some symbol definitions to provide the proper (= XBoard) context for the code in args.h
452 #define XBOARD True
453 #define JAWS_ARGS
454 #define CW_USEDEFAULT (1<<31)
455 #define ICS_TEXT_MENU_SIZE 90
456 #define DEBUG_FILE "xboard.debug"
457 #define SetCurrentDirectory chdir
458 #define GetCurrentDirectory(SIZE, NAME) getcwd(NAME, SIZE)
459 #define OPTCHAR "-"
460 #define SEPCHAR " "
461
462 // The option definition and parsing code common to XBoard and WinBoard is collected in this file
463 #include "args.h"
464
465 // front-end part of option handling
466
467 // [HGM] This platform-dependent table provides the location for storing the color info
468 extern char *crWhite, * crBlack;
469
470 void *
471 colorVariable[] = {
472   &appData.whitePieceColor,
473   &appData.blackPieceColor,
474   &appData.lightSquareColor,
475   &appData.darkSquareColor,
476   &appData.highlightSquareColor,
477   &appData.premoveHighlightColor,
478   &appData.lowTimeWarningColor,
479   NULL,
480   NULL,
481   NULL,
482   NULL,
483   NULL,
484   &crWhite,
485   &crBlack,
486   NULL
487 };
488
489 // [HGM] font: keep a font for each square size, even non-stndard ones
490 #define NUM_SIZES 18
491 #define MAX_SIZE 130
492 Boolean fontIsSet[NUM_FONTS], fontValid[NUM_FONTS][MAX_SIZE];
493 char *fontTable[NUM_FONTS][MAX_SIZE];
494
495 void
496 ParseFont (char *name, int number)
497 { // in XBoard, only 2 of the fonts are currently implemented, and we just copy their name
498   int size;
499   if(sscanf(name, "size%d:", &size)) {
500     // [HGM] font: font is meant for specific boardSize (likely from settings file);
501     //       defer processing it until we know if it matches our board size
502     if(strstr(name, "-*-") &&        // only pay attention to things that look like X-fonts
503        size >= 0 && size<MAX_SIZE) { // for now, fixed limit
504         fontTable[number][size] = strdup(strchr(name, ':')+1);
505         fontValid[number][size] = True;
506     }
507     return;
508   }
509   switch(number) {
510     case 0: // CLOCK_FONT
511         appData.clockFont = strdup(name);
512       break;
513     case 1: // MESSAGE_FONT
514         appData.font = strdup(name);
515       break;
516     case 2: // COORD_FONT
517         appData.coordFont = strdup(name);
518       break;
519     default:
520       return;
521   }
522   fontIsSet[number] = True; // [HGM] font: indicate a font was specified (not from settings file)
523 }
524
525 void
526 SetFontDefaults ()
527 { // only 2 fonts currently
528   appData.clockFont = CLOCK_FONT_NAME;
529   appData.coordFont = COORD_FONT_NAME;
530   appData.font  =   DEFAULT_FONT_NAME;
531 }
532
533 void
534 CreateFonts ()
535 { // no-op, until we identify the code for this already in XBoard and move it here
536 }
537
538 void
539 ParseColor (int n, char *name)
540 { // in XBoard, just copy the color-name string
541   if(colorVariable[n] && *name == '#') *(char**)colorVariable[n] = strdup(name);
542 }
543
544 char *
545 Col2Text (int n)
546 {
547     return *(char**)colorVariable[n];
548 }
549
550 void
551 ParseTextAttribs (ColorClass cc, char *s)
552 {
553     (&appData.colorShout)[cc] = strdup(s);
554 }
555
556 void
557 ParseBoardSize (void *addr, char *name)
558 {
559     appData.boardSize = strdup(name);
560 }
561
562 void
563 LoadAllSounds ()
564 { // In XBoard the sound-playing program takes care of obtaining the actual sound
565 }
566
567 void
568 SetCommPortDefaults ()
569 { // for now, this is a no-op, as the corresponding option does not exist in XBoard
570 }
571
572 // [HGM] args: these three cases taken out to stay in front-end
573 void
574 SaveFontArg (FILE *f, ArgDescriptor *ad)
575 {
576   char *name;
577   int i, n = (int)(intptr_t)ad->argLoc;
578   switch(n) {
579     case 0: // CLOCK_FONT
580         name = appData.clockFont;
581       break;
582     case 1: // MESSAGE_FONT
583         name = appData.font;
584       break;
585     case 2: // COORD_FONT
586         name = appData.coordFont;
587       break;
588     default:
589       return;
590   }
591   for(i=0; i<NUM_SIZES; i++) // [HGM] font: current font becomes standard for current size
592     if(sizeDefaults[i].squareSize == squareSize) { // only for standard sizes!
593         fontTable[n][squareSize] = strdup(name);
594         fontValid[n][squareSize] = True;
595         break;
596   }
597   for(i=0; i<MAX_SIZE; i++) if(fontValid[n][i]) // [HGM] font: store all standard fonts
598     fprintf(f, OPTCHAR "%s" SEPCHAR "\"size%d:%s\"\n", ad->argName, i, fontTable[n][i]);
599 }
600
601 void
602 ExportSounds ()
603 { // nothing to do, as the sounds are at all times represented by their text-string names already
604 }
605
606 void
607 SaveAttribsArg (FILE *f, ArgDescriptor *ad)
608 {       // here the "argLoc" defines a table index. It could have contained the 'ta' pointer itself, though
609         fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, (&appData.colorShout)[(int)(intptr_t)ad->argLoc]);
610 }
611
612 void
613 SaveColor (FILE *f, ArgDescriptor *ad)
614 {       // in WinBoard the color is an int and has to be converted to text. In X it would be a string already?
615         if(colorVariable[(int)(intptr_t)ad->argLoc])
616         fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", ad->argName, *(char**)colorVariable[(int)(intptr_t)ad->argLoc]);
617 }
618
619 void
620 SaveBoardSize (FILE *f, char *name, void *addr)
621 { // wrapper to shield back-end from BoardSize & sizeInfo
622   fprintf(f, OPTCHAR "%s" SEPCHAR "%s\n", name, appData.boardSize);
623 }
624
625 void
626 ParseCommPortSettings (char *s)
627 { // no such option in XBoard (yet)
628 }
629
630 int frameX, frameY;
631
632 void
633 GetActualPlacement (Widget wg, WindowPlacement *wp)
634 {
635   XWindowAttributes winAt;
636   Window win, dummy;
637   int rx, ry;
638
639   if(!wg) return;
640
641   win = XtWindow(wg);
642   XGetWindowAttributes(xDisplay, win, &winAt); // this works, where XtGetValues on XtNx, XtNy does not!
643   XTranslateCoordinates (xDisplay, win, winAt.root, -winAt.border_width, -winAt.border_width, &rx, &ry, &dummy);
644   wp->x = rx - winAt.x;
645   wp->y = ry - winAt.y;
646   wp->height = winAt.height;
647   wp->width = winAt.width;
648   frameX = winAt.x; frameY = winAt.y; // remember to decide if windows touch
649 }
650
651 void
652 GetPlacement (DialogClass dlg, WindowPlacement *wp)
653 { // wrapper to shield back-end from widget type
654   if(shellUp[dlg]) GetActualPlacement(shells[dlg], wp);
655 }
656
657 void
658 GetWindowCoords ()
659 { // wrapper to shield use of window handles from back-end (make addressible by number?)
660   // In XBoard this will have to wait until awareness of window parameters is implemented
661   GetActualPlacement(shellWidget, &wpMain);
662   if(shellUp[EngOutDlg]) GetActualPlacement(shells[EngOutDlg], &wpEngineOutput);
663   if(shellUp[HistoryDlg]) GetActualPlacement(shells[HistoryDlg], &wpMoveHistory);
664   if(shellUp[EvalGraphDlg]) GetActualPlacement(shells[EvalGraphDlg], &wpEvalGraph);
665   if(shellUp[GameListDlg]) GetActualPlacement(shells[GameListDlg], &wpGameList);
666   if(shellUp[CommentDlg]) GetActualPlacement(shells[CommentDlg], &wpComment);
667   if(shellUp[TagsDlg]) GetActualPlacement(shells[TagsDlg], &wpTags);
668 }
669
670 void
671 PrintCommPortSettings (FILE *f, char *name)
672 { // This option does not exist in XBoard
673 }
674
675 void
676 EnsureOnScreen (int *x, int *y, int minX, int minY)
677 {
678   return;
679 }
680
681 int
682 MainWindowUp ()
683 { // [HGM] args: allows testing if main window is realized from back-end
684   return xBoardWindow != 0;
685 }
686
687 void
688 PopUpStartupDialog ()
689 {  // start menu not implemented in XBoard
690 }
691
692 char *
693 ConvertToLine (int argc, char **argv)
694 {
695   static char line[128*1024], buf[1024];
696   int i;
697
698   line[0] = NULLCHAR;
699   for(i=1; i<argc; i++)
700     {
701       if( (strchr(argv[i], ' ') || strchr(argv[i], '\n') ||strchr(argv[i], '\t') || argv[i][0] == NULLCHAR)
702           && argv[i][0] != '{' )
703         snprintf(buf, sizeof(buf)/sizeof(buf[0]), "{%s} ", argv[i]);
704       else
705         snprintf(buf, sizeof(buf)/sizeof(buf[0]), "%s ", argv[i]);
706       strncat(line, buf, 128*1024 - strlen(line) - 1 );
707     }
708
709   line[strlen(line)-1] = NULLCHAR;
710   return line;
711 }
712
713 //--------------------------------------------------------------------------------------------
714
715 void
716 ResizeBoardWindow (int w, int h, int inhibit)
717 {
718     w += marginW + 1; // [HGM] not sure why the +1 is (sometimes) needed...
719     h += marginH;
720     shellArgs[0].value = w;
721     shellArgs[1].value = h;
722     shellArgs[4].value = shellArgs[2].value = w;
723     shellArgs[5].value = shellArgs[3].value = h;
724     XtSetValues(shellWidget, &shellArgs[0], inhibit ? 6 : 2);
725
726     XSync(xDisplay, False);
727 }
728
729 static int
730 MakeOneColor (char *name, Pixel *color)
731 {
732     XrmValue vFrom, vTo;
733     if (!appData.monoMode) {
734         vFrom.addr = (caddr_t) name;
735         vFrom.size = strlen(name);
736         XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
737         if (vTo.addr == NULL) {
738           appData.monoMode = True;
739           return True;
740         } else {
741           *color = *(Pixel *) vTo.addr;
742         }
743     }
744     return False;
745 }
746
747 int
748 MakeColors ()
749 {   // [HGM] taken out of main(), so it can be called from BoardOptions dialog
750     int forceMono = False;
751
752     if (appData.lowTimeWarning)
753         forceMono |= MakeOneColor(appData.lowTimeWarningColor, &lowTimeWarningColor);
754     if(appData.dialogColor[0]) MakeOneColor(appData.dialogColor, &dialogColor);
755     if(appData.buttonColor[0]) MakeOneColor(appData.buttonColor, &buttonColor);
756
757     return forceMono;
758 }
759
760 void
761 InitializeFonts (int clockFontPxlSize, int coordFontPxlSize, int fontPxlSize)
762 {   // detervtomine what fonts to use, and create them
763     XrmValue vTo;
764     XrmDatabase xdb;
765
766     if(!fontIsSet[CLOCK_FONT] && fontValid[CLOCK_FONT][squareSize])
767         appData.clockFont = fontTable[CLOCK_FONT][squareSize];
768     if(!fontIsSet[MESSAGE_FONT] && fontValid[MESSAGE_FONT][squareSize])
769         appData.font = fontTable[MESSAGE_FONT][squareSize];
770     if(!fontIsSet[COORD_FONT] && fontValid[COORD_FONT][squareSize])
771         appData.coordFont = fontTable[COORD_FONT][squareSize];
772
773 #if ENABLE_NLS
774     appData.font = InsertPxlSize(appData.font, fontPxlSize);
775     appData.clockFont = InsertPxlSize(appData.clockFont, clockFontPxlSize);
776     appData.coordFont = InsertPxlSize(appData.coordFont, coordFontPxlSize);
777     fontSet = CreateFontSet(appData.font);
778     clockFontSet = CreateFontSet(appData.clockFont);
779     {
780       /* For the coordFont, use the 0th font of the fontset. */
781       XFontSet coordFontSet = CreateFontSet(appData.coordFont);
782       XFontStruct **font_struct_list;
783       XFontSetExtents *fontSize;
784       char **font_name_list;
785       XFontsOfFontSet(coordFontSet, &font_struct_list, &font_name_list);
786       coordFontID = XLoadFont(xDisplay, font_name_list[0]);
787       coordFontStruct = XQueryFont(xDisplay, coordFontID);
788       fontSize = XExtentsOfFontSet(fontSet); // [HGM] figure out how much vertical space font takes
789       textHeight = fontSize->max_logical_extent.height + 5; // add borderWidth
790     }
791 #else
792     appData.font = FindFont(appData.font, fontPxlSize);
793     appData.clockFont = FindFont(appData.clockFont, clockFontPxlSize);
794     appData.coordFont = FindFont(appData.coordFont, coordFontPxlSize);
795     clockFontID = XLoadFont(xDisplay, appData.clockFont);
796     clockFontStruct = XQueryFont(xDisplay, clockFontID);
797     coordFontID = XLoadFont(xDisplay, appData.coordFont);
798     coordFontStruct = XQueryFont(xDisplay, coordFontID);
799     // textHeight in !NLS mode!
800 #endif
801     countFontID = coordFontID;  // [HGM] holdings
802     countFontStruct = coordFontStruct;
803
804     xdb = XtDatabase(xDisplay);
805 #if ENABLE_NLS
806     XrmPutLineResource(&xdb, "*international: True");
807     vTo.size = sizeof(XFontSet);
808     vTo.addr = (XtPointer) &fontSet;
809     XrmPutResource(&xdb, "*fontSet", XtRFontSet, &vTo);
810 #else
811     XrmPutStringResource(&xdb, "*font", appData.font);
812 #endif
813 }
814
815 char *
816 PrintArg (ArgType t)
817 {
818   char *p="";
819   switch(t) {
820     case ArgZ:
821     case ArgInt:      p = " N"; break;
822     case ArgString:   p = " STR"; break;
823     case ArgBoolean:  p = " TF"; break;
824     case ArgSettingsFilename:
825     case ArgBackupSettingsFile:
826     case ArgFilename: p = " FILE"; break;
827     case ArgX:        p = " Nx"; break;
828     case ArgY:        p = " Ny"; break;
829     case ArgAttribs:  p = " TEXTCOL"; break;
830     case ArgColor:    p = " COL"; break;
831     case ArgFont:     p = " FONT"; break;
832     case ArgBoardSize: p = " SIZE"; break;
833     case ArgFloat: p = " FLOAT"; break;
834     case ArgTrue:
835     case ArgFalse:
836     case ArgTwo:
837     case ArgNone:
838     case ArgCommSettings:
839     case ArgMaster:
840     case ArgInstall:
841       break;
842   }
843   return p;
844 }
845
846 char *
847 GenerateGlobalTranslationTable (void)
848 {
849   /* go through all menu items and extract the keyboard shortcuts, so that X11 can load them */
850   char *output[2];
851
852   int i,j,n=0;
853   MenuItem *mi;
854
855   output[0] = strdup(""); // build keystrokes with and wo mod keys separately
856   output[1] = strdup(""); // so the more specific can preceed the other
857
858   /* loop over all menu entries */
859   for( i=0; menuBar[i-n].mi || !n++; i++)
860     {
861       mi = menuBar[i+n].mi; // kludge to access 'noMenu' behind sentinel
862       for(j=0; mi[j].proc; j++)
863         {
864           if (mi[j].accel)
865             {
866               int ctrl  = 0;
867               int shift = 0;
868               int alt   = 0;
869
870               char *key,*test, *mods;
871
872               /* check for Ctrl/Alt */
873               if( strstr(mi[j].accel, "<Ctrl>")  ) ctrl  = 1;
874               if( strstr(mi[j].accel, "<Shift>") ) shift = 1;
875               if( strstr(mi[j].accel, "<Alt>")   ) alt   = 1;
876
877               /* remove all <...> */
878               test = strrchr(mi[j].accel, '>');
879               if ( test==NULL )
880                 key = strdup(mi[j].accel);
881               else
882                 key = strdup(++test); // remove ">"
883
884               /* instead of shift X11 uses the uppercase letter directly*/
885               if (shift && strlen(key)==1 )
886                 {
887                   *key  = toupper(*key);
888                   shift = 0;
889                 }
890
891               /* handle some special cases which have different names in X11 */
892               if ( strncmp(key, "Page_Down", 9) == 0 )
893                 {
894                   free(key);
895                   key=strdup("Next");
896                 }
897               else if ( strncmp(key, "Page_Up", 7) == 0 )
898                 {
899                   free(key);
900                   key=strdup("Prior");
901                 };
902
903               /* create string of mods */
904               if (ctrl)
905                 mods = strdup("Ctrl ");
906               else
907                 mods = strdup("");
908
909               if(alt)
910                 {
911                   mods = realloc(mods, strlen(mods) + strlen("Meta ")+1);
912                   strncat(mods, "Meta ", 5);
913                 };
914
915               if(shift)
916                 {
917                   mods = realloc(mods, strlen(mods) + strlen("Shift ")+1);
918                   strncat(mods, "Shift ", 6);
919                 };
920
921               // remove trailing space
922               if( isspace(mods[strlen(mods)-1]) )
923                 mods[strlen(mods)-1]='\0';
924
925               /* get the name for the callback, we can use MenuItem() here that will call KeyBindingProc */
926               char *name = malloc(MSG_SIZ);
927               if(n) snprintf(name, MSG_SIZ, "%s", mi[j].ref);
928               else  snprintf(name, MSG_SIZ, "%s.%s", menuBar[i].ref, mi[j].ref);
929
930               char *buffer = malloc(MSG_SIZ);
931               snprintf(buffer, MSG_SIZ, ":%s<Key>%s: MenuItem(%s) \n ", mods, key, name);
932
933               /* add string to the output */
934               output[shift|alt|ctrl] = realloc(output[shift|alt|ctrl], strlen(output[shift|alt|ctrl]) + strlen(buffer)+1);
935               strncat(output[shift|alt|ctrl], buffer, strlen(buffer));
936
937               /* clean up */
938               free(key);
939               free(buffer);
940               free(name);
941               free(mods);
942             }
943         }
944     }
945   output[1] = realloc(output[1], strlen(output[1]) + strlen(output[0])+1);
946   strncat(output[1], output[0], strlen(output[0]));
947   free(output[0]);
948   return output[1];
949 }
950
951
952 void
953 PrintOptions ()
954 {
955   char buf[MSG_SIZ];
956   int len=0;
957   ArgDescriptor *q, *p = argDescriptors+5;
958   printf("\nXBoard accepts the following options:\n"
959          "(N = integer, TF = true or false, STR = text string, FILE = filename,\n"
960          " Nx, Ny = relative coordinates, COL = color, FONT = X-font spec,\n"
961          " SIZE = board-size spec(s)\n"
962          " Within parentheses are short forms, or options to set to true or false.\n"
963          " Persistent options (saved in the settings file) are marked with *)\n\n");
964   while(p->argName) {
965     if(p->argType == ArgCommSettings) { p++; continue; } // XBoard has no comm port
966     snprintf(buf+len, MSG_SIZ, "-%s%s", p->argName, PrintArg(p->argType));
967     if(p->save) strcat(buf+len, "*");
968     for(q=p+1; q->argLoc == p->argLoc; q++) {
969       if(q->argName[0] == '-') continue;
970       strcat(buf+len, q == p+1 ? " (" : " ");
971       sprintf(buf+strlen(buf), "-%s%s", q->argName, PrintArg(q->argType));
972     }
973     if(q != p+1) strcat(buf+len, ")");
974     len = strlen(buf);
975     if(len > 39) len = 0, printf("%s\n", buf); else while(len < 39) buf[len++] = ' ';
976     p = q;
977   }
978   if(len) buf[len] = NULLCHAR, printf("%s\n", buf);
979 }
980
981 void
982 SlaveResize (Option *opt)
983 {
984 }
985
986 int
987 main (int argc, char **argv)
988 {
989     int i, clockFontPxlSize, coordFontPxlSize, fontPxlSize;
990     XSetWindowAttributes window_attributes;
991     Arg args[16];
992     Dimension boardWidth, boardHeight, w, h;
993     char *p;
994     int forceMono = False;
995
996     extern Option chatOptions[]; // FIXME: adapt Chat window, removing ICS pane and Hide button
997     chatOptions[6].type = chatOptions[10].type = Skip;
998
999     srandom(time(0)); // [HGM] book: make random truly random
1000
1001     setbuf(stdout, NULL);
1002     setbuf(stderr, NULL);
1003     debugFP = stderr;
1004
1005     if(argc > 1 && (!strcmp(argv[1], "-v" ) || !strcmp(argv[1], "--version" ))) {
1006       printf("%s version %s\n\n  configure options: %s\n", PACKAGE_NAME, PACKAGE_VERSION, CONFIGURE_OPTIONS);
1007         exit(0);
1008     }
1009
1010     if(argc > 1 && !strcmp(argv[1], "--help" )) {
1011         PrintOptions();
1012         exit(0);
1013     }
1014
1015     if(argc > 1 && !strcmp(argv[1], "--show-config")) { // [HGM] install: called to print config info
1016         typedef struct {char *name, *value; } Config;
1017         static Config configList[] = {
1018           { "Datadir", DATADIR },
1019           { "Sysconfdir", SYSCONFDIR },
1020           { NULL }
1021         };
1022         int i;
1023
1024         for(i=0; configList[i].name; i++) {
1025             if(argc > 2 && strcmp(argv[2], configList[i].name)) continue;
1026             if(argc > 2) printf("%s", configList[i].value);
1027             else printf("%-12s: %s\n", configList[i].name, configList[i].value);
1028         }
1029         exit(0);
1030     }
1031
1032     programName = strrchr(argv[0], '/');
1033     if (programName == NULL)
1034       programName = argv[0];
1035     else
1036       programName++;
1037
1038 #ifdef ENABLE_NLS
1039     XtSetLanguageProc(NULL, NULL, NULL);
1040     if (appData.debugMode) {
1041       fprintf(debugFP, "locale = %s\n", setlocale(LC_ALL, NULL));
1042     }
1043
1044     bindtextdomain(PACKAGE, LOCALEDIR);
1045     textdomain(PACKAGE);
1046 #endif
1047
1048     appData.boardSize = "";
1049     InitAppData(ConvertToLine(argc, argv));
1050     p = getenv("HOME");
1051     if (p == NULL) p = "/tmp";
1052     i = strlen(p) + strlen("/.xboardXXXXXx.pgn") + 1;
1053     gameCopyFilename = (char*) malloc(i);
1054     gamePasteFilename = (char*) malloc(i);
1055     snprintf(gameCopyFilename,i, "%s/.xboard%05uc.pgn", p, getpid());
1056     snprintf(gamePasteFilename,i, "%s/.xboard%05up.pgn", p, getpid());
1057
1058     { // [HGM] initstring: kludge to fix bad bug. expand '\n' characters in init string and computer string.
1059         static char buf[MSG_SIZ];
1060         EscapeExpand(buf, appData.firstInitString);
1061         appData.firstInitString = strdup(buf);
1062         EscapeExpand(buf, appData.secondInitString);
1063         appData.secondInitString = strdup(buf);
1064         EscapeExpand(buf, appData.firstComputerString);
1065         appData.firstComputerString = strdup(buf);
1066         EscapeExpand(buf, appData.secondComputerString);
1067         appData.secondComputerString = strdup(buf);
1068     }
1069
1070     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
1071         chessDir = ".";
1072     } else {
1073         if (chdir(chessDir) != 0) {
1074             fprintf(stderr, _("%s: can't cd to CHESSDIR: "), programName);
1075             perror(chessDir);
1076             exit(1);
1077         }
1078     }
1079
1080     if (appData.debugMode && appData.nameOfDebugFile && strcmp(appData.nameOfDebugFile, "stderr")) {
1081         /* [DM] debug info to file [HGM] make the filename a command-line option, and allow it to remain stderr */
1082         if ((debugFP = fopen(appData.nameOfDebugFile, "w")) == NULL)  {
1083            printf(_("Failed to open file '%s'\n"), appData.nameOfDebugFile);
1084            exit(errno);
1085         }
1086         setbuf(debugFP, NULL);
1087     }
1088
1089     /* [HGM,HR] make sure board size is acceptable */
1090     if(appData.NrFiles > BOARD_FILES ||
1091        appData.NrRanks > BOARD_RANKS   )
1092          DisplayFatalError(_("Recompile with larger BOARD_RANKS or BOARD_FILES to support this size"), 0, 2);
1093
1094 #if !HIGHDRAG
1095     /* This feature does not work; animation needs a rewrite */
1096     appData.highlightDragging = FALSE;
1097 #endif
1098     InitBackEnd1();
1099
1100         gameInfo.variant = StringToVariant(appData.variant);
1101         InitPosition(FALSE);
1102
1103     shellWidget =
1104       XtAppInitialize(&appContext, "XBoard", shellOptions,
1105                       XtNumber(shellOptions),
1106                       &argc, argv, xboardResources, NULL, 0);
1107
1108     XtGetApplicationResources(shellWidget, (XtPointer) &appData,
1109                               clientResources, XtNumber(clientResources),
1110                               NULL, 0);
1111
1112     xDisplay = XtDisplay(shellWidget);
1113     xScreen = DefaultScreen(xDisplay);
1114     wm_delete_window = XInternAtom(xDisplay, "WM_DELETE_WINDOW", True);
1115
1116     /*
1117      * determine size, based on supplied or remembered -size, or screen size
1118      */
1119     if (isdigit(appData.boardSize[0])) {
1120         i = sscanf(appData.boardSize, "%d,%d,%d,%d,%d,%d,%d", &squareSize,
1121                    &lineGap, &clockFontPxlSize, &coordFontPxlSize,
1122                    &fontPxlSize, &smallLayout, &tinyLayout);
1123         if (i == 0) {
1124             fprintf(stderr, _("%s: bad boardSize syntax %s\n"),
1125                     programName, appData.boardSize);
1126             exit(2);
1127         }
1128         if(BOARD_WIDTH > 8)
1129             squareSize = (squareSize*8 + BOARD_WIDTH/2)/BOARD_WIDTH; // scale height
1130         if (i < 7) {
1131             /* Find some defaults; use the nearest known size */
1132             SizeDefaults *szd, *nearest;
1133             int distance = 99999;
1134             nearest = szd = sizeDefaults;
1135             while (szd->name != NULL) {
1136                 if (abs(szd->squareSize - squareSize) < distance) {
1137                     nearest = szd;
1138                     distance = abs(szd->squareSize - squareSize);
1139                     if (distance == 0) break;
1140                 }
1141                 szd++;
1142             }
1143             if (i < 2) lineGap = nearest->lineGap;
1144             if (i < 3) clockFontPxlSize = nearest->clockFontPxlSize;
1145             if (i < 4) coordFontPxlSize = nearest->coordFontPxlSize;
1146             if (i < 5) fontPxlSize = nearest->fontPxlSize;
1147             if (i < 6) smallLayout = nearest->smallLayout;
1148             if (i < 7) tinyLayout = nearest->tinyLayout;
1149         }
1150     } else {
1151         SizeDefaults *szd = sizeDefaults;
1152         if (*appData.boardSize == NULLCHAR) {
1153             while (DisplayWidth(xDisplay, xScreen)  < (szd->minScreenSize*BOARD_WIDTH  + 4)/8 ||
1154                    DisplayHeight(xDisplay, xScreen) < (szd->minScreenSize*BOARD_HEIGHT + 4)/8) {
1155               szd++;
1156             }
1157             if (szd->name == NULL) szd--;
1158             appData.boardSize = strdup(szd->name); // [HGM] settings: remember name for saving settings
1159         } else {
1160             while (szd->name != NULL &&
1161                    StrCaseCmp(szd->name, appData.boardSize) != 0) szd++;
1162             if (szd->name == NULL) {
1163                 fprintf(stderr, _("%s: unrecognized boardSize name %s\n"),
1164                         programName, appData.boardSize);
1165                 exit(2);
1166             }
1167         }
1168         squareSize = szd->squareSize;
1169         lineGap = szd->lineGap;
1170         clockFontPxlSize = szd->clockFontPxlSize;
1171         coordFontPxlSize = szd->coordFontPxlSize;
1172         fontPxlSize = szd->fontPxlSize;
1173         smallLayout = szd->smallLayout;
1174         tinyLayout = szd->tinyLayout;
1175         // [HGM] font: use defaults from settings file if available and not overruled
1176     }
1177
1178     defaultLineGap = lineGap;
1179     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap;
1180
1181     /* [HR] height treated separately (hacked) */
1182     boardWidth = lineGap + BOARD_WIDTH * (squareSize + lineGap);
1183     boardHeight = lineGap + BOARD_HEIGHT * (squareSize + lineGap);
1184
1185     /*
1186      * Determine what fonts to use.
1187      */
1188     InitializeFonts(clockFontPxlSize, coordFontPxlSize, fontPxlSize);
1189
1190     /*
1191      * Detect if there are not enough colors available and adapt.
1192      */
1193     if (DefaultDepth(xDisplay, xScreen) <= 2) {
1194       appData.monoMode = True;
1195     }
1196
1197     forceMono = MakeColors();
1198
1199     if (forceMono) {
1200       fprintf(stderr, _("%s: too few colors available; trying monochrome mode\n"),
1201               programName);
1202         appData.monoMode = True;
1203     }
1204
1205     if (appData.monoMode && appData.debugMode) {
1206         fprintf(stderr, _("white pixel = 0x%lx, black pixel = 0x%lx\n"),
1207                 (unsigned long) XWhitePixel(xDisplay, xScreen),
1208                 (unsigned long) XBlackPixel(xDisplay, xScreen));
1209     }
1210
1211     ParseIcsTextColors();
1212
1213     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
1214
1215     /*
1216      * widget hierarchy
1217      */
1218     if (tinyLayout) {
1219         layoutName = "tinyLayout";
1220     } else if (smallLayout) {
1221         layoutName = "smallLayout";
1222     } else {
1223         layoutName = "normalLayout";
1224     }
1225
1226     optList = BoardPopUp(squareSize, lineGap, (void*)
1227 #if ENABLE_NLS
1228                                                 &clockFontSet);
1229 #else
1230                                                 clockFontStruct);
1231 #endif
1232     InitDrawingHandle(optList + W_BOARD);
1233     currBoard        = &optList[W_BOARD];
1234     boardWidget      = optList[W_BOARD].handle;
1235     menuBarWidget    = optList[W_MENU].handle;
1236     dropMenu         = optList[W_DROP].handle;
1237     titleWidget = optList[optList[W_TITLE].type != Skip ? W_TITLE : W_SMALL].handle;
1238     formWidget  = XtParent(boardWidget);
1239     XtSetArg(args[0], XtNbackground, &timerBackgroundPixel);
1240     XtSetArg(args[1], XtNforeground, &timerForegroundPixel);
1241     XtGetValues(optList[W_WHITE].handle, args, 2);
1242     if (appData.showButtonBar) { // can't we use timer pixels for this? (Or better yet, just black & white?)
1243       XtSetArg(args[0], XtNbackground, &buttonBackgroundPixel);
1244       XtSetArg(args[1], XtNforeground, &buttonForegroundPixel);
1245       XtGetValues(optList[W_PAUSE].handle, args, 2);
1246     }
1247
1248     xBoardWindow = XtWindow(boardWidget);
1249
1250     // [HGM] it seems the layout code ends here, but perhaps the color stuff is size independent and would
1251     //       not need to go into InitDrawingSizes().
1252
1253     /*
1254      * Create X checkmark bitmap and initialize option menu checks.
1255      */
1256     ReadBitmap(&xMarkPixmap, "checkmark.bm",
1257                checkmark_bits, checkmark_width, checkmark_height);
1258     InitMenuMarkers();
1259
1260     /*
1261      * Create an icon.
1262      */
1263     ReadBitmap(&wIconPixmap, "icon_white.bm",
1264                icon_white_bits, icon_white_width, icon_white_height);
1265     ReadBitmap(&bIconPixmap, "icon_black.bm",
1266                icon_black_bits, icon_black_width, icon_black_height);
1267     iconPixmap = wIconPixmap;
1268     i = 0;
1269     XtSetArg(args[i], XtNiconPixmap, iconPixmap);  i++;
1270     XtSetValues(shellWidget, args, i);
1271
1272     /*
1273      * Create a cursor for the board widget.
1274      */
1275     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
1276     XChangeWindowAttributes(xDisplay, xBoardWindow,
1277                             CWCursor, &window_attributes);
1278
1279     /*
1280      * Inhibit shell resizing.
1281      */
1282     shellArgs[0].value = (XtArgVal) &w;
1283     shellArgs[1].value = (XtArgVal) &h;
1284     XtGetValues(shellWidget, shellArgs, 2);
1285     shellArgs[4].value = shellArgs[2].value = w;
1286     shellArgs[5].value = shellArgs[3].value = h;
1287 //    XtSetValues(shellWidget, &shellArgs[2], 4);
1288     marginW =  w - boardWidth; // [HGM] needed to set new shellWidget size when we resize board
1289     marginH =  h - boardHeight;
1290
1291     CatchDeleteWindow(shellWidget, "QuitProc");
1292
1293     CreateAnyPieces(1);
1294     CreateGrid();
1295
1296     if(appData.logoSize)
1297     {   // locate and read user logo
1298         char buf[MSG_SIZ], name[MSG_SIZ];
1299         snprintf(name, MSG_SIZ, "/home/%s", UserName());
1300         if(!FindLogo(name, ".logo", buf))
1301             FindLogo(appData.logoDir, name + 6, buf);
1302         ASSIGN(userLogo, buf);
1303     }
1304
1305     if (appData.animate || appData.animateDragging)
1306       CreateAnimVars();
1307
1308
1309     char *TranslationsTableMenus=GenerateGlobalTranslationTable ();
1310
1311     XtAugmentTranslations(formWidget,
1312                           XtParseTranslationTable(globalTranslations));
1313     XtAugmentTranslations(formWidget,
1314                           XtParseTranslationTable(TranslationsTableMenus));
1315
1316     XtAddEventHandler(formWidget, KeyPressMask, False,
1317                       (XtEventHandler) MoveTypeInProc, NULL);
1318     XtAddEventHandler(shellWidget, StructureNotifyMask, False,
1319                       (XtEventHandler) EventProc, NULL);
1320
1321     /* [AS] Restore layout */
1322     if( wpMoveHistory.visible ) {
1323       HistoryPopUp();
1324     }
1325
1326     if( wpEvalGraph.visible )
1327       {
1328         EvalGraphPopUp();
1329       };
1330
1331     if( wpEngineOutput.visible ) {
1332       EngineOutputPopUp();
1333     }
1334
1335     gameInfo.boardWidth = 0; // [HGM] pieces: kludge to ensure InitPosition() calls InitDrawingSizes()
1336     InitPosition(TRUE);
1337
1338     InitBackEnd2();
1339
1340     if (errorExitStatus == -1) {
1341         if (appData.icsActive) {
1342             /* We now wait until we see "login:" from the ICS before
1343                sending the logon script (problems with timestamp otherwise) */
1344             /*ICSInitScript();*/
1345             if (appData.icsInputBox) ICSInputBoxPopUp();
1346         }
1347
1348     #ifdef SIGWINCH
1349     signal(SIGWINCH, TermSizeSigHandler);
1350     #endif
1351         signal(SIGINT, IntSigHandler);
1352         signal(SIGTERM, IntSigHandler);
1353         if (*appData.cmailGameName != NULLCHAR) {
1354             signal(SIGUSR1, CmailSigHandler);
1355         }
1356     }
1357
1358     UpdateLogos(TRUE);
1359 //    XtSetKeyboardFocus(shellWidget, formWidget);
1360     XSetInputFocus(xDisplay, XtWindow(formWidget), RevertToPointerRoot, CurrentTime);
1361
1362     XtAppMainLoop(appContext);
1363     if (appData.debugMode) fclose(debugFP); // [DM] debug
1364     return 0;
1365 }
1366
1367 void
1368 DoEvents ()
1369 {
1370     XtInputMask m;
1371     while((m = XtAppPending(appContext))) XtAppProcessEvent(appContext, m);
1372 }
1373
1374 RETSIGTYPE
1375 TermSizeSigHandler (int sig)
1376 {
1377     update_ics_width();
1378 }
1379
1380 RETSIGTYPE
1381 IntSigHandler (int sig)
1382 {
1383     ExitEvent(sig);
1384 }
1385
1386 RETSIGTYPE
1387 CmailSigHandler (int sig)
1388 {
1389     int dummy = 0;
1390     int error;
1391
1392     signal(SIGUSR1, SIG_IGN);   /* suspend handler     */
1393
1394     /* Activate call-back function CmailSigHandlerCallBack()             */
1395     OutputToProcess(cmailPR, (char *)(&dummy), sizeof(int), &error);
1396
1397     signal(SIGUSR1, CmailSigHandler); /* re-activate handler */
1398 }
1399
1400 void
1401 CmailSigHandlerCallBack (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
1402 {
1403     BoardToTop();
1404     ReloadCmailMsgEvent(TRUE);  /* Reload cmail msg  */
1405 }
1406 /**** end signal code ****/
1407
1408
1409 #define Abs(n) ((n)<0 ? -(n) : (n))
1410
1411 #ifdef ENABLE_NLS
1412 char *
1413 InsertPxlSize (char *pattern, int targetPxlSize)
1414 {
1415     char *base_fnt_lst, strInt[12], *p, *q;
1416     int alternatives, i, len, strIntLen;
1417
1418     /*
1419      * Replace the "*" (if present) in the pixel-size slot of each
1420      * alternative with the targetPxlSize.
1421      */
1422     p = pattern;
1423     alternatives = 1;
1424     while ((p = strchr(p, ',')) != NULL) {
1425       alternatives++;
1426       p++;
1427     }
1428     snprintf(strInt, sizeof(strInt), "%d", targetPxlSize);
1429     strIntLen = strlen(strInt);
1430     base_fnt_lst = calloc(1, strlen(pattern) + strIntLen * alternatives + 1);
1431
1432     p = pattern;
1433     q = base_fnt_lst;
1434     while (alternatives--) {
1435       char *comma = strchr(p, ',');
1436       for (i=0; i<14; i++) {
1437         char *hyphen = strchr(p, '-');
1438         if (!hyphen) break;
1439         if (comma && hyphen > comma) break;
1440         len = hyphen + 1 - p;
1441         if (i == 7 && *p == '*' && len == 2) {
1442           p += len;
1443           memcpy(q, strInt, strIntLen);
1444           q += strIntLen;
1445           *q++ = '-';
1446         } else {
1447           memcpy(q, p, len);
1448           p += len;
1449           q += len;
1450         }
1451       }
1452       if (!comma) break;
1453       len = comma + 1 - p;
1454       memcpy(q, p, len);
1455       p += len;
1456       q += len;
1457     }
1458     strcpy(q, p);
1459
1460     return base_fnt_lst;
1461 }
1462
1463 XFontSet
1464 CreateFontSet (char *base_fnt_lst)
1465 {
1466     XFontSet fntSet;
1467     char **missing_list;
1468     int missing_count;
1469     char *def_string;
1470
1471     fntSet = XCreateFontSet(xDisplay, base_fnt_lst,
1472                             &missing_list, &missing_count, &def_string);
1473     if (appData.debugMode) {
1474       int i, count;
1475       XFontStruct **font_struct_list;
1476       char **font_name_list;
1477       fprintf(debugFP, "Requested font set for list %s\n", base_fnt_lst);
1478       if (fntSet) {
1479         fprintf(debugFP, " got list %s, locale %s\n",
1480                 XBaseFontNameListOfFontSet(fntSet),
1481                 XLocaleOfFontSet(fntSet));
1482         count = XFontsOfFontSet(fntSet, &font_struct_list, &font_name_list);
1483         for (i = 0; i < count; i++) {
1484           fprintf(debugFP, " got charset %s\n", font_name_list[i]);
1485         }
1486       }
1487       for (i = 0; i < missing_count; i++) {
1488         fprintf(debugFP, " missing charset %s\n", missing_list[i]);
1489       }
1490     }
1491     if (fntSet == NULL) {
1492       fprintf(stderr, _("Unable to create font set for %s.\n"), base_fnt_lst);
1493       exit(2);
1494     }
1495     return fntSet;
1496 }
1497 #else // not ENABLE_NLS
1498 /*
1499  * Find a font that matches "pattern" that is as close as
1500  * possible to the targetPxlSize.  Prefer fonts that are k
1501  * pixels smaller to fonts that are k pixels larger.  The
1502  * pattern must be in the X Consortium standard format,
1503  * e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
1504  * The return value should be freed with XtFree when no
1505  * longer needed.
1506  */
1507 char *
1508 FindFont (char *pattern, int targetPxlSize)
1509 {
1510     char **fonts, *p, *best, *scalable, *scalableTail;
1511     int i, j, nfonts, minerr, err, pxlSize;
1512
1513     fonts = XListFonts(xDisplay, pattern, 999999, &nfonts);
1514     if (nfonts < 1) {
1515         fprintf(stderr, _("%s: no fonts match pattern %s\n"),
1516                 programName, pattern);
1517         exit(2);
1518     }
1519
1520     best = fonts[0];
1521     scalable = NULL;
1522     minerr = 999999;
1523     for (i=0; i<nfonts; i++) {
1524         j = 0;
1525         p = fonts[i];
1526         if (*p != '-') continue;
1527         while (j < 7) {
1528             if (*p == NULLCHAR) break;
1529             if (*p++ == '-') j++;
1530         }
1531         if (j < 7) continue;
1532         pxlSize = atoi(p);
1533         if (pxlSize == 0) {
1534             scalable = fonts[i];
1535             scalableTail = p;
1536         } else {
1537             err = pxlSize - targetPxlSize;
1538             if (Abs(err) < Abs(minerr) ||
1539                 (minerr > 0 && err < 0 && -err == minerr)) {
1540                 best = fonts[i];
1541                 minerr = err;
1542             }
1543         }
1544     }
1545     if (scalable && Abs(minerr) > appData.fontSizeTolerance) {
1546         /* If the error is too big and there is a scalable font,
1547            use the scalable font. */
1548         int headlen = scalableTail - scalable;
1549         p = (char *) XtMalloc(strlen(scalable) + 10);
1550         while (isdigit(*scalableTail)) scalableTail++;
1551         sprintf(p, "%.*s%d%s", headlen, scalable, targetPxlSize, scalableTail);
1552     } else {
1553         p = (char *) XtMalloc(strlen(best) + 2);
1554         safeStrCpy(p, best, strlen(best)+1 );
1555     }
1556     if (appData.debugMode) {
1557         fprintf(debugFP, "resolved %s at pixel size %d\n  to %s\n",
1558                 pattern, targetPxlSize, p);
1559     }
1560     XFreeFontNames(fonts);
1561     return p;
1562 }
1563 #endif
1564
1565 void
1566 ReadBitmap (Pixmap *pm, String name, unsigned char bits[], u_int wreq, u_int hreq)
1567 {
1568     if (bits != NULL) {
1569         *pm = XCreateBitmapFromData(xDisplay, xBoardWindow, (char *) bits,
1570                                     wreq, hreq);
1571     }
1572 }
1573
1574 void
1575 MarkMenuItem (char *menuRef, int state)
1576 {
1577     MenuItem *item = MenuNameToItem(menuRef);
1578
1579     if(item) {
1580         Arg args[2];
1581         XtSetArg(args[0], XtNleftBitmap, state ? xMarkPixmap : None);
1582         XtSetValues(item->handle, args, 1);
1583     }
1584 }
1585
1586 void
1587 EnableNamedMenuItem (char *menuRef, int state)
1588 {
1589     MenuItem *item = MenuNameToItem(menuRef);
1590
1591     if(item) XtSetSensitive(item->handle, state);
1592 }
1593
1594 void
1595 EnableButtonBar (int state)
1596 {
1597     XtSetSensitive(optList[W_BUTTON].handle, state);
1598 }
1599
1600
1601 void
1602 SetMenuEnables (Enables *enab)
1603 {
1604   while (enab->name != NULL) {
1605     EnableNamedMenuItem(enab->name, enab->value);
1606     enab++;
1607   }
1608 }
1609
1610 void
1611 KeyBindingProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
1612 {   // [HGM] new method of key binding: specify MenuItem(FlipView) in stead of FlipViewProc in translation string
1613     MenuItem *item;
1614     if(*nprms == 0) return;
1615     item = MenuNameToItem(prms[0]);
1616     if(item) ((MenuProc *) item->proc) ();
1617 }
1618
1619 void
1620 SetupDropMenu ()
1621 {
1622     int i, j, count;
1623     char label[32];
1624     Arg args[16];
1625     Widget entry;
1626     char* p;
1627
1628     for (i=0; i<sizeof(dmEnables)/sizeof(DropMenuEnables); i++) {
1629         entry = XtNameToWidget(dropMenu, dmEnables[i].widget);
1630         p = strchr(gameMode == IcsPlayingWhite ? white_holding : black_holding,
1631                    dmEnables[i].piece);
1632         XtSetSensitive(entry, p != NULL || !appData.testLegality
1633                        /*!!temp:*/ || (gameInfo.variant == VariantCrazyhouse
1634                                        && !appData.icsActive));
1635         count = 0;
1636         while (p && *p++ == dmEnables[i].piece) count++;
1637         snprintf(label, sizeof(label), "%s  %d", dmEnables[i].widget, count);
1638         j = 0;
1639         XtSetArg(args[j], XtNlabel, label); j++;
1640         XtSetValues(entry, args, j);
1641     }
1642 }
1643
1644 static void
1645 do_flash_delay (unsigned long msec)
1646 {
1647     TimeDelay(msec);
1648 }
1649
1650 void
1651 FlashDelay (int flash_delay)
1652 {
1653         XSync(xDisplay, False);
1654         if(flash_delay) do_flash_delay(flash_delay);
1655 }
1656
1657 double
1658 Fraction (int x, int start, int stop)
1659 {
1660    double f = ((double) x - start)/(stop - start);
1661    if(f > 1.) f = 1.; else if(f < 0.) f = 0.;
1662    return f;
1663 }
1664
1665 static WindowPlacement wpNew;
1666
1667 void
1668 CoDrag (Widget sh, WindowPlacement *wp)
1669 {
1670     Arg args[16];
1671     int j=0, touch=0, fudge = 2;
1672     GetActualPlacement(sh, wp);
1673     if(abs(wpMain.x + wpMain.width + 2*frameX - wp->x)         < fudge) touch = 1; else // right touch
1674     if(abs(wp->x + wp->width + 2*frameX - wpMain.x)            < fudge) touch = 2; else // left touch
1675     if(abs(wpMain.y + wpMain.height + frameX + frameY - wp->y) < fudge) touch = 3; else // bottom touch
1676     if(abs(wp->y + wp->height + frameX + frameY - wpMain.y)    < fudge) touch = 4;      // top touch
1677     if(!touch ) return; // only windows that touch co-move
1678     if(touch < 3 && wpNew.height != wpMain.height) { // left or right and height changed
1679         int heightInc = wpNew.height - wpMain.height;
1680         double fracTop = Fraction(wp->y, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
1681         double fracBot = Fraction(wp->y + wp->height + frameX + frameY + 1, wpMain.y, wpMain.y + wpMain.height + frameX + frameY);
1682         wp->y += fracTop * heightInc;
1683         heightInc = (int) (fracBot * heightInc) - (int) (fracTop * heightInc);
1684         if(heightInc) XtSetArg(args[j], XtNheight, wp->height + heightInc), j++;
1685     } else if(touch > 2 && wpNew.width != wpMain.width) { // top or bottom and width changed
1686         int widthInc = wpNew.width - wpMain.width;
1687         double fracLeft = Fraction(wp->x, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
1688         double fracRght = Fraction(wp->x + wp->width + 2*frameX + 1, wpMain.x, wpMain.x + wpMain.width + 2*frameX);
1689         wp->y += fracLeft * widthInc;
1690         widthInc = (int) (fracRght * widthInc) - (int) (fracLeft * widthInc);
1691         if(widthInc) XtSetArg(args[j], XtNwidth, wp->width + widthInc), j++;
1692     }
1693     wp->x += wpNew.x - wpMain.x;
1694     wp->y += wpNew.y - wpMain.y;
1695     if(touch == 1) wp->x += wpNew.width - wpMain.width; else
1696     if(touch == 3) wp->y += wpNew.height - wpMain.height;
1697     XtSetArg(args[j], XtNx, wp->x); j++;
1698     XtSetArg(args[j], XtNy, wp->y); j++;
1699     XtSetValues(sh, args, j);
1700 }
1701
1702 void
1703 ReSize (WindowPlacement *wp)
1704 {
1705         int sqx, sqy, w, h;
1706         if(wp->width == wpMain.width && wp->height == wpMain.height) return; // not sized
1707         sqx = (wp->width  - lineGap - marginW) / BOARD_WIDTH - lineGap;
1708         sqy = (wp->height - lineGap - marginH) / BOARD_HEIGHT - lineGap;
1709         if(sqy < sqx) sqx = sqy;
1710         if(sqx != squareSize) {
1711             squareSize = sqx; // adopt new square size
1712             CreatePNGPieces(appData.pieceDirectory); // make newly scaled pieces
1713             InitDrawingSizes(0, 0); // creates grid etc.
1714         } else ResizeBoardWindow(BOARD_WIDTH * (squareSize + lineGap) + lineGap, BOARD_HEIGHT * (squareSize + lineGap) + lineGap, 0);
1715         w = BOARD_WIDTH * (squareSize + lineGap) + lineGap;
1716         h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
1717         if(optList[W_BOARD].max   > w) optList[W_BOARD].max = w;
1718         if(optList[W_BOARD].value > h) optList[W_BOARD].value = h;
1719 }
1720
1721 static XtIntervalId delayedDragID = 0;
1722
1723 void
1724 DragProc ()
1725 {
1726         static int busy;
1727         if(busy) return;
1728
1729         busy = 1;
1730         GetActualPlacement(shellWidget, &wpNew);
1731         if(wpNew.x == wpMain.x && wpNew.y == wpMain.y && // not moved
1732            wpNew.width == wpMain.width && wpNew.height == wpMain.height) { // not sized
1733             busy = 0; return; // false alarm
1734         }
1735         ReSize(&wpNew);
1736         if(shellUp[EngOutDlg]) CoDrag(shells[EngOutDlg], &wpEngineOutput);
1737         if(shellUp[HistoryDlg]) CoDrag(shells[HistoryDlg], &wpMoveHistory);
1738         if(shellUp[EvalGraphDlg]) CoDrag(shells[EvalGraphDlg], &wpEvalGraph);
1739         if(shellUp[GameListDlg]) CoDrag(shells[GameListDlg], &wpGameList);
1740         wpMain = wpNew;
1741         DrawPosition(True, NULL);
1742         delayedDragID = 0; // now drag executed, make sure next DelayedDrag will not cancel timer event (which could now be used by other)
1743         busy = 0;
1744 }
1745
1746
1747 void
1748 DelayedDrag ()
1749 {
1750     if(delayedDragID) XtRemoveTimeOut(delayedDragID); // cancel pending
1751     delayedDragID =
1752       XtAppAddTimeOut(appContext, 200, (XtTimerCallbackProc) DragProc, (XtPointer) 0); // and schedule new one 50 msec later
1753 }
1754
1755 void
1756 EventProc (Widget widget, caddr_t unused, XEvent *event)
1757 {
1758     if(XtIsRealized(widget) && event->type == ConfigureNotify || appData.useStickyWindows)
1759         DelayedDrag(); // as long as events keep coming in faster than 50 msec, they destroy each other
1760 }
1761
1762 /*
1763  * event handler for redrawing the board
1764  */
1765 void
1766 DrawPositionProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
1767 {
1768     DrawPosition(True, NULL);
1769 }
1770
1771
1772 void
1773 HandlePV (Widget w, XEvent * event, String * params, Cardinal * nParams)
1774 {   // [HGM] pv: walk PV
1775     MovePV(event->xmotion.x, event->xmotion.y, lineGap + BOARD_HEIGHT * (squareSize + lineGap));
1776 }
1777
1778 extern int savedIndex;  /* gross that this is global */
1779
1780 void
1781 CommentClick (Widget w, XEvent * event, String * params, Cardinal * nParams)
1782 {
1783         String val;
1784         XawTextPosition index, dummy;
1785         Arg arg;
1786
1787         XawTextGetSelectionPos(w, &index, &dummy);
1788         XtSetArg(arg, XtNstring, &val);
1789         XtGetValues(w, &arg, 1);
1790         ReplaceComment(savedIndex, val);
1791         if(savedIndex != currentMove) ToNrEvent(savedIndex);
1792         LoadVariation( index, val ); // [HGM] also does the actual moving to it, now
1793 }
1794
1795
1796 /* Disable all user input other than deleting the window */
1797 static int frozen = 0;
1798
1799 void
1800 FreezeUI ()
1801 {
1802   if (frozen) return;
1803   /* Grab by a widget that doesn't accept input */
1804   XtAddGrab(optList[W_MESSG].handle, TRUE, FALSE);
1805   frozen = 1;
1806 }
1807
1808 /* Undo a FreezeUI */
1809 void
1810 ThawUI ()
1811 {
1812   if (!frozen) return;
1813   XtRemoveGrab(optList[W_MESSG].handle);
1814   frozen = 0;
1815 }
1816
1817 void
1818 ModeHighlight ()
1819 {
1820     Arg args[16];
1821     static int oldPausing = FALSE;
1822     static GameMode oldMode = (GameMode) -1;
1823     char *wname;
1824
1825     if (!boardWidget || !XtIsRealized(boardWidget)) return;
1826
1827     if (pausing != oldPausing) {
1828         oldPausing = pausing;
1829         MarkMenuItem("Mode.Pause", pausing);
1830
1831         if (appData.showButtonBar) {
1832           /* Always toggle, don't set.  Previous code messes up when
1833              invoked while the button is pressed, as releasing it
1834              toggles the state again. */
1835           {
1836             Pixel oldbg, oldfg;
1837             XtSetArg(args[0], XtNbackground, &oldbg);
1838             XtSetArg(args[1], XtNforeground, &oldfg);
1839             XtGetValues(optList[W_PAUSE].handle,
1840                         args, 2);
1841             XtSetArg(args[0], XtNbackground, oldfg);
1842             XtSetArg(args[1], XtNforeground, oldbg);
1843           }
1844           XtSetValues(optList[W_PAUSE].handle, args, 2);
1845         }
1846     }
1847
1848     wname = ModeToWidgetName(oldMode);
1849     if (wname != NULL) {
1850         MarkMenuItem(wname, False);
1851     }
1852     wname = ModeToWidgetName(gameMode);
1853     if (wname != NULL) {
1854         MarkMenuItem(wname, True);
1855     }
1856     if(oldMode == TwoMachinesPlay) EnableNamedMenuItem("Mode.MachineMatch", True);
1857     MarkMenuItem("Mode.MachineMatch", matchMode && matchGame < appData.matchGames);
1858     oldMode = gameMode;
1859
1860     /* Maybe all the enables should be handled here, not just this one */
1861     EnableNamedMenuItem("Mode.Training", gameMode == Training || gameMode == PlayFromGameFile);
1862
1863     DisplayLogos(&optList[W_WHITE-1], &optList[W_BLACK+1]);
1864 }
1865
1866
1867 /*
1868  * Button/menu procedures
1869  */
1870
1871 /* this variable is shared between CopyPositionProc and SendPositionSelection */
1872 char *selected_fen_position=NULL;
1873
1874 Boolean
1875 SendPositionSelection (Widget w, Atom *selection, Atom *target,
1876                        Atom *type_return, XtPointer *value_return,
1877                        unsigned long *length_return, int *format_return)
1878 {
1879   char *selection_tmp;
1880
1881 //  if (!selected_fen_position) return False; /* should never happen */
1882   if (*target == XA_STRING || *target == XA_UTF8_STRING(xDisplay)){
1883    if (!selected_fen_position) { // since it never happens, we use it for indicating a game is being sent
1884     FILE* f = fopen(gameCopyFilename, "r"); // This code, taken from SendGameSelection, now merges the two
1885     long len;
1886     size_t count;
1887     if (f == NULL) return False;
1888     fseek(f, 0, 2);
1889     len = ftell(f);
1890     rewind(f);
1891     selection_tmp = XtMalloc(len + 1);
1892     count = fread(selection_tmp, 1, len, f);
1893     fclose(f);
1894     if (len != count) {
1895       XtFree(selection_tmp);
1896       return False;
1897     }
1898     selection_tmp[len] = NULLCHAR;
1899    } else {
1900     /* note: since no XtSelectionDoneProc was registered, Xt will
1901      * automatically call XtFree on the value returned.  So have to
1902      * make a copy of it allocated with XtMalloc */
1903     selection_tmp= XtMalloc(strlen(selected_fen_position)+16);
1904     safeStrCpy(selection_tmp, selected_fen_position, strlen(selected_fen_position)+16 );
1905    }
1906
1907     *value_return=selection_tmp;
1908     *length_return=strlen(selection_tmp);
1909     *type_return=*target;
1910     *format_return = 8; /* bits per byte */
1911     return True;
1912   } else if (*target == XA_TARGETS(xDisplay)) {
1913     Atom *targets_tmp = (Atom *) XtMalloc(2 * sizeof(Atom));
1914     targets_tmp[0] = XA_UTF8_STRING(xDisplay);
1915     targets_tmp[1] = XA_STRING;
1916     *value_return = targets_tmp;
1917     *type_return = XA_ATOM;
1918     *length_return = 2;
1919 #if 0
1920     // This code leads to a read of value_return out of bounds on 64-bit systems.
1921     // Other code which I have seen always sets *format_return to 32 independent of
1922     // sizeof(Atom) without adjusting *length_return. For instance see TextConvertSelection()
1923     // at http://cgit.freedesktop.org/xorg/lib/libXaw/tree/src/Text.c -- BJ
1924     *format_return = 8 * sizeof(Atom);
1925     if (*format_return > 32) {
1926       *length_return *= *format_return / 32;
1927       *format_return = 32;
1928     }
1929 #else
1930     *format_return = 32;
1931 #endif
1932     return True;
1933   } else {
1934     return False;
1935   }
1936 }
1937
1938 /* note: when called from menu all parameters are NULL, so no clue what the
1939  * Widget which was clicked on was, or what the click event was
1940  */
1941 void
1942 CopySomething (char *src)
1943 {
1944     selected_fen_position = src;
1945     /*
1946      * Set both PRIMARY (the selection) and CLIPBOARD, since we don't
1947      * have a notion of a position that is selected but not copied.
1948      * See http://www.freedesktop.org/wiki/Specifications/ClipboardsWiki
1949      */
1950     XtOwnSelection(menuBarWidget, XA_PRIMARY,
1951                    CurrentTime,
1952                    SendPositionSelection,
1953                    NULL/* lose_ownership_proc */ ,
1954                    NULL/* transfer_done_proc */);
1955     XtOwnSelection(menuBarWidget, XA_CLIPBOARD(xDisplay),
1956                    CurrentTime,
1957                    SendPositionSelection,
1958                    NULL/* lose_ownership_proc */ ,
1959                    NULL/* transfer_done_proc */);
1960 }
1961
1962 /* function called when the data to Paste is ready */
1963 static void
1964 PastePositionCB (Widget w, XtPointer client_data, Atom *selection,
1965                  Atom *type, XtPointer value, unsigned long *len, int *format)
1966 {
1967   char *fenstr=value;
1968   if (value==NULL || *len==0) return; /* nothing had been selected to copy */
1969   fenstr[*len]='\0'; /* normally this string is terminated, but be safe */
1970   EditPositionPasteFEN(fenstr);
1971   XtFree(value);
1972 }
1973
1974 /* called when Paste Position button is pressed,
1975  * all parameters will be NULL */
1976 void
1977 PastePositionProc ()
1978 {
1979     XtGetSelectionValue(menuBarWidget,
1980       appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
1981       /* (XtSelectionCallbackProc) */ PastePositionCB,
1982       NULL, /* client_data passed to PastePositionCB */
1983
1984       /* better to use the time field from the event that triggered the
1985        * call to this function, but that isn't trivial to get
1986        */
1987       CurrentTime
1988     );
1989     return;
1990 }
1991
1992 /* note: when called from menu all parameters are NULL, so no clue what the
1993  * Widget which was clicked on was, or what the click event was
1994  */
1995 /* function called when the data to Paste is ready */
1996 static void
1997 PasteGameCB (Widget w, XtPointer client_data, Atom *selection,
1998              Atom *type, XtPointer value, unsigned long *len, int *format)
1999 {
2000   FILE* f;
2001   int flip = appData.flipView;
2002   if (value == NULL || *len == 0) {
2003     return; /* nothing had been selected to copy */
2004   }
2005   f = fopen(gamePasteFilename, "w");
2006   if (f == NULL) {
2007     DisplayError(_("Can't open temp file"), errno);
2008     return;
2009   }
2010   fwrite(value, 1, *len, f);
2011   fclose(f);
2012   XtFree(value);
2013   if(!appData.autoFlipView) appData.flipView = flipView;
2014   LoadGameFromFile(gamePasteFilename, 0, gamePasteFilename, TRUE);
2015   appData.flipView = flip;
2016 }
2017
2018 /* called when Paste Game button is pressed,
2019  * all parameters will be NULL */
2020 void
2021 PasteGameProc ()
2022 {
2023     XtGetSelectionValue(menuBarWidget,
2024       appData.pasteSelection ? XA_PRIMARY: XA_CLIPBOARD(xDisplay), XA_STRING,
2025       /* (XtSelectionCallbackProc) */ PasteGameCB,
2026       NULL, /* client_data passed to PasteGameCB */
2027
2028       /* better to use the time field from the event that triggered the
2029        * call to this function, but that isn't trivial to get
2030        */
2031       CurrentTime
2032     );
2033     return;
2034 }
2035
2036
2037 void
2038 QuitWrapper (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2039 {
2040     QuitProc();
2041 }
2042
2043 int
2044 ShiftKeys ()
2045 {   // bassic primitive for determining if modifier keys are pressed
2046     long int codes[] = { XK_Meta_L, XK_Meta_R, XK_Control_L, XK_Control_R, XK_Shift_L, XK_Shift_R };
2047     char keys[32];
2048     int i,j,  k=0;
2049     XQueryKeymap(xDisplay,keys);
2050     for(i=0; i<6; i++) {
2051         k <<= 1;
2052         j = XKeysymToKeycode(xDisplay, codes[i]);
2053         k += ( (keys[j>>3]&1<<(j&7)) != 0 );
2054     }
2055     return k;
2056 }
2057
2058 static void
2059 MoveTypeInProc (Widget widget, caddr_t unused, XEvent *event)
2060 {
2061     char buf[10];
2062     KeySym sym;
2063     int n = XLookupString(&(event->xkey), buf, 10, &sym, NULL);
2064     if ( n == 1 && *buf >= 32 // printable
2065          && !(ShiftKeys() & 0x3C) // no Alt, Ctrl
2066         ) BoxAutoPopUp (buf);
2067 }
2068
2069 static void
2070 UpKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2071 {   // [HGM] input: let up-arrow recall previous line from history
2072     IcsKey(1);
2073 }
2074
2075 static void
2076 DownKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2077 {   // [HGM] input: let down-arrow recall next line from history
2078     IcsKey(-1);
2079 }
2080
2081 static void
2082 EnterKeyProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2083 {
2084     IcsKey(0);
2085 }
2086
2087 void
2088 TempBackwardProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2089 {
2090         if (!TempBackwardActive) {
2091                 TempBackwardActive = True;
2092                 BackwardEvent();
2093         }
2094 }
2095
2096 void
2097 TempForwardProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2098 {
2099         /* Check to see if triggered by a key release event for a repeating key.
2100          * If so the next queued event will be a key press of the same key at the same time */
2101         if (XEventsQueued(xDisplay, QueuedAfterReading)) {
2102                 XEvent next;
2103                 XPeekEvent(xDisplay, &next);
2104                 if (next.type == KeyPress && next.xkey.time == event->xkey.time &&
2105                         next.xkey.keycode == event->xkey.keycode)
2106                                 return;
2107         }
2108     ForwardEvent();
2109         TempBackwardActive = False;
2110 }
2111
2112 void
2113 ManInner (Widget w, XEvent *event, String *prms, Cardinal *nprms)
2114 {   // called as key binding
2115     char buf[MSG_SIZ];
2116     String name;
2117     if (nprms && *nprms > 0)
2118       name = prms[0];
2119     else
2120       name = "xboard";
2121     snprintf(buf, sizeof(buf), "xterm -e man %s &", name);
2122     system(buf);
2123 }
2124
2125 void
2126 ManProc ()
2127 {   // called from menu
2128     ManInner(NULL, NULL, NULL, NULL);
2129 }
2130
2131 void
2132 InfoProc ()
2133 {
2134     char buf[MSG_SIZ];
2135     snprintf(buf, sizeof(buf), "xterm -e info --directory %s --directory . -f %s &",
2136              INFODIR, INFOFILE);
2137     system(buf);
2138 }
2139
2140 void
2141 SetWindowTitle (char *text, char *title, char *icon)
2142 {
2143     Arg args[16];
2144     int i;
2145     if (appData.titleInWindow) {
2146         i = 0;
2147         XtSetArg(args[i], XtNlabel, text);   i++;
2148         XtSetValues(titleWidget, args, i);
2149     }
2150     i = 0;
2151     XtSetArg(args[i], XtNiconName, (XtArgVal) icon);    i++;
2152     XtSetArg(args[i], XtNtitle, (XtArgVal) title);      i++;
2153     XtSetValues(shellWidget, args, i);
2154     XSync(xDisplay, False);
2155 }
2156
2157
2158 static int
2159 NullXErrorCheck (Display *dpy, XErrorEvent *error_event)
2160 {
2161     return 0;
2162 }
2163
2164 void
2165 DisplayIcsInteractionTitle (String message)
2166 {
2167   if (oldICSInteractionTitle == NULL) {
2168     /* Magic to find the old window title, adapted from vim */
2169     char *wina = getenv("WINDOWID");
2170     if (wina != NULL) {
2171       Window win = (Window) atoi(wina);
2172       Window root, parent, *children;
2173       unsigned int nchildren;
2174       int (*oldHandler)() = XSetErrorHandler(NullXErrorCheck);
2175       for (;;) {
2176         if (XFetchName(xDisplay, win, &oldICSInteractionTitle)) break;
2177         if (!XQueryTree(xDisplay, win, &root, &parent,
2178                         &children, &nchildren)) break;
2179         if (children) XFree((void *)children);
2180         if (parent == root || parent == 0) break;
2181         win = parent;
2182       }
2183       XSetErrorHandler(oldHandler);
2184     }
2185     if (oldICSInteractionTitle == NULL) {
2186       oldICSInteractionTitle = "xterm";
2187     }
2188   }
2189   printf("\033]0;%s\007", message);
2190   fflush(stdout);
2191 }
2192
2193
2194 XtIntervalId delayedEventTimerXID = 0;
2195 DelayedEventCallback delayedEventCallback = 0;
2196
2197 void
2198 FireDelayedEvent ()
2199 {
2200     delayedEventTimerXID = 0;
2201     delayedEventCallback();
2202 }
2203
2204 void
2205 ScheduleDelayedEvent (DelayedEventCallback cb, long millisec)
2206 {
2207     if(delayedEventTimerXID && delayedEventCallback == cb)
2208         // [HGM] alive: replace, rather than add or flush identical event
2209         XtRemoveTimeOut(delayedEventTimerXID);
2210     delayedEventCallback = cb;
2211     delayedEventTimerXID =
2212       XtAppAddTimeOut(appContext, millisec,
2213                       (XtTimerCallbackProc) FireDelayedEvent, (XtPointer) 0);
2214 }
2215
2216 DelayedEventCallback
2217 GetDelayedEvent ()
2218 {
2219   if (delayedEventTimerXID) {
2220     return delayedEventCallback;
2221   } else {
2222     return NULL;
2223   }
2224 }
2225
2226 void
2227 CancelDelayedEvent ()
2228 {
2229   if (delayedEventTimerXID) {
2230     XtRemoveTimeOut(delayedEventTimerXID);
2231     delayedEventTimerXID = 0;
2232   }
2233 }
2234
2235 XtIntervalId loadGameTimerXID = 0;
2236
2237 int
2238 LoadGameTimerRunning ()
2239 {
2240     return loadGameTimerXID != 0;
2241 }
2242
2243 int
2244 StopLoadGameTimer ()
2245 {
2246     if (loadGameTimerXID != 0) {
2247         XtRemoveTimeOut(loadGameTimerXID);
2248         loadGameTimerXID = 0;
2249         return TRUE;
2250     } else {
2251         return FALSE;
2252     }
2253 }
2254
2255 void
2256 LoadGameTimerCallback (XtPointer arg, XtIntervalId *id)
2257 {
2258     loadGameTimerXID = 0;
2259     AutoPlayGameLoop();
2260 }
2261
2262 void
2263 StartLoadGameTimer (long millisec)
2264 {
2265     loadGameTimerXID =
2266       XtAppAddTimeOut(appContext, millisec,
2267                       (XtTimerCallbackProc) LoadGameTimerCallback,
2268                       (XtPointer) 0);
2269 }
2270
2271 XtIntervalId analysisClockXID = 0;
2272
2273 void
2274 AnalysisClockCallback (XtPointer arg, XtIntervalId *id)
2275 {
2276     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
2277          || appData.icsEngineAnalyze) { // [DM]
2278         AnalysisPeriodicEvent(0);
2279         StartAnalysisClock();
2280     }
2281 }
2282
2283 void
2284 StartAnalysisClock ()
2285 {
2286     analysisClockXID =
2287       XtAppAddTimeOut(appContext, 2000,
2288                       (XtTimerCallbackProc) AnalysisClockCallback,
2289                       (XtPointer) 0);
2290 }
2291
2292 XtIntervalId clockTimerXID = 0;
2293
2294 int
2295 ClockTimerRunning ()
2296 {
2297     return clockTimerXID != 0;
2298 }
2299
2300 int
2301 StopClockTimer ()
2302 {
2303     if (clockTimerXID != 0) {
2304         XtRemoveTimeOut(clockTimerXID);
2305         clockTimerXID = 0;
2306         return TRUE;
2307     } else {
2308         return FALSE;
2309     }
2310 }
2311
2312 void
2313 ClockTimerCallback (XtPointer arg, XtIntervalId *id)
2314 {
2315     clockTimerXID = 0;
2316     DecrementClocks();
2317 }
2318
2319 void
2320 StartClockTimer (long millisec)
2321 {
2322     clockTimerXID =
2323       XtAppAddTimeOut(appContext, millisec,
2324                       (XtTimerCallbackProc) ClockTimerCallback,
2325                       (XtPointer) 0);
2326 }
2327
2328 void
2329 DisplayTimerLabel (Option *opt, char *color, long timer, int highlight)
2330 {
2331     char buf[MSG_SIZ];
2332     Arg args[16];
2333     Widget w = (Widget) opt->handle;
2334
2335     /* check for low time warning */
2336     Pixel foregroundOrWarningColor = timerForegroundPixel;
2337
2338     if (timer > 0 &&
2339         appData.lowTimeWarning &&
2340         (timer / 1000) < appData.icsAlarmTime)
2341       foregroundOrWarningColor = lowTimeWarningColor;
2342
2343     if (appData.clockMode) {
2344       snprintf(buf, MSG_SIZ, "%s:%s%s", color, appData.logoSize && !partnerUp ? "\n" : " ", TimeString(timer));
2345       XtSetArg(args[0], XtNlabel, buf);
2346     } else {
2347       snprintf(buf, MSG_SIZ, "%s  ", color);
2348       XtSetArg(args[0], XtNlabel, buf);
2349     }
2350
2351     if (highlight) {
2352
2353         XtSetArg(args[1], XtNbackground, foregroundOrWarningColor);
2354         XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
2355     } else {
2356         XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
2357         XtSetArg(args[2], XtNforeground, foregroundOrWarningColor);
2358     }
2359
2360     XtSetValues(w, args, 3);
2361 }
2362
2363 static Pixmap *clockIcons[] = { &wIconPixmap, &bIconPixmap };
2364
2365 void
2366 SetClockIcon (int color)
2367 {
2368     Arg args[16];
2369     Pixmap pm = *clockIcons[color];
2370     if (iconPixmap != pm) {
2371         iconPixmap = pm;
2372         XtSetArg(args[0], XtNiconPixmap, iconPixmap);
2373         XtSetValues(shellWidget, args, 1);
2374     }
2375 }
2376
2377 #define INPUT_SOURCE_BUF_SIZE 8192
2378
2379 typedef struct {
2380     CPKind kind;
2381     int fd;
2382     int lineByLine;
2383     char *unused;
2384     InputCallback func;
2385     XtInputId xid;
2386     char buf[INPUT_SOURCE_BUF_SIZE];
2387     VOIDSTAR closure;
2388 } InputSource;
2389
2390 void
2391 DoInputCallback (caddr_t closure, int *source, XtInputId *xid)
2392 {
2393     InputSource *is = (InputSource *) closure;
2394     int count;
2395     int error;
2396     char *p, *q;
2397
2398     if (is->lineByLine) {
2399         count = read(is->fd, is->unused,
2400                      INPUT_SOURCE_BUF_SIZE - (is->unused - is->buf));
2401         if (count <= 0) {
2402             (is->func)(is, is->closure, is->buf, count, count ? errno : 0);
2403             return;
2404         }
2405         is->unused += count;
2406         p = is->buf;
2407         while (p < is->unused) {
2408             q = memchr(p, '\n', is->unused - p);
2409             if (q == NULL) break;
2410             q++;
2411             (is->func)(is, is->closure, p, q - p, 0);
2412             p = q;
2413         }
2414         q = is->buf;
2415         while (p < is->unused) {
2416             *q++ = *p++;
2417         }
2418         is->unused = q;
2419     } else {
2420         count = read(is->fd, is->buf, INPUT_SOURCE_BUF_SIZE);
2421         if (count == -1)
2422           error = errno;
2423         else
2424           error = 0;
2425         (is->func)(is, is->closure, is->buf, count, error);
2426     }
2427 }
2428
2429 InputSourceRef
2430 AddInputSource (ProcRef pr, int lineByLine, InputCallback func, VOIDSTAR closure)
2431 {
2432     InputSource *is;
2433     ChildProc *cp = (ChildProc *) pr;
2434
2435     is = (InputSource *) calloc(1, sizeof(InputSource));
2436     is->lineByLine = lineByLine;
2437     is->func = func;
2438     if (pr == NoProc) {
2439         is->kind = CPReal;
2440         is->fd = fileno(stdin);
2441     } else {
2442         is->kind = cp->kind;
2443         is->fd = cp->fdFrom;
2444     }
2445     if (lineByLine) {
2446         is->unused = is->buf;
2447     }
2448
2449     is->xid = XtAppAddInput(appContext, is->fd,
2450                             (XtPointer) (XtInputReadMask),
2451                             (XtInputCallbackProc) DoInputCallback,
2452                             (XtPointer) is);
2453     is->closure = closure;
2454     return (InputSourceRef) is;
2455 }
2456
2457 void
2458 RemoveInputSource (InputSourceRef isr)
2459 {
2460     InputSource *is = (InputSource *) isr;
2461
2462     if (is->xid == 0) return;
2463     XtRemoveInput(is->xid);
2464     is->xid = 0;
2465 }
2466
2467 #ifndef HAVE_USLEEP
2468
2469 static Boolean frameWaiting;
2470
2471 static RETSIGTYPE
2472 FrameAlarm (int sig)
2473 {
2474   frameWaiting = False;
2475   /* In case System-V style signals.  Needed?? */
2476   signal(SIGALRM, FrameAlarm);
2477 }
2478
2479 void
2480 FrameDelay (int time)
2481 {
2482   struct itimerval delay;
2483
2484   XSync(xDisplay, False);
2485
2486   if (time > 0) {
2487     frameWaiting = True;
2488     signal(SIGALRM, FrameAlarm);
2489     delay.it_interval.tv_sec =
2490       delay.it_value.tv_sec = time / 1000;
2491     delay.it_interval.tv_usec =
2492       delay.it_value.tv_usec = (time % 1000) * 1000;
2493     setitimer(ITIMER_REAL, &delay, NULL);
2494     while (frameWaiting) pause();
2495     delay.it_interval.tv_sec = delay.it_value.tv_sec = 0;
2496     delay.it_interval.tv_usec = delay.it_value.tv_usec = 0;
2497     setitimer(ITIMER_REAL, &delay, NULL);
2498   }
2499 }
2500
2501 #else
2502
2503 void
2504 FrameDelay (int time)
2505 {
2506   XSync(xDisplay, False);
2507   if (time > 0)
2508     usleep(time * 1000);
2509 }
2510
2511 #endif
2512
2513 static int
2514 FindLogo (char *place, char *name, char *buf)
2515 {   // check if file exists in given place
2516     FILE *f;
2517     if(!place) return 0;
2518     snprintf(buf, MSG_SIZ, "%s/%s.png", place, name);
2519     if(*place && strcmp(place, ".") && (f = fopen(buf, "r")) ) {
2520         fclose(f);
2521         return 1;
2522     }
2523     return 0;
2524 }
2525
2526 static void
2527 LoadLogo (ChessProgramState *cps, int n, Boolean ics)
2528 {
2529     char buf[MSG_SIZ], *logoName = buf;
2530     if(appData.logo[n][0]) {
2531         logoName = appData.logo[n];
2532     } else if(appData.autoLogo) {
2533         if(ics) { // [HGM] logo: in ICS mode second can be used for ICS
2534             sprintf(buf, "%s/%s.png", appData.logoDir, appData.icsHost);
2535         } else { // engine; cascade
2536             if(!FindLogo(appData.logoDir, cps->tidy, buf) &&   // first try user log folder
2537                !FindLogo(appData.directory[n], "logo", buf) && // then engine directory
2538                !FindLogo("/usr/local/share/games/plugins/logos", cps->tidy, buf) ) // then system folders
2539                 FindLogo("/usr/share/games/plugins/logos", cps->tidy, buf);
2540         }
2541     }
2542     if(logoName[0])
2543         { ASSIGN(cps->programLogo, logoName); }
2544 }
2545
2546 void
2547 UpdateLogos (int displ)
2548 {
2549     if(optList[W_WHITE-1].handle == NULL) return;
2550     LoadLogo(&first, 0, 0);
2551     LoadLogo(&second, 1, appData.icsActive);
2552     if(displ) DisplayLogos(&optList[W_WHITE-1], &optList[W_BLACK+1]);
2553     return;
2554 }
2555