PageRenderTime 64ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

/xboard-4.5.2a/xoptions.c

#
C | 1873 lines | 1653 code | 158 blank | 62 comment | 301 complexity | 7b4439034da70a23c3519959c048c411 MD5 | raw file
Possible License(s): GPL-3.0, MPL-2.0-no-copyleft-exception 
    

  1. /*
    2. 

  2.  * xoptions.c -- Move list window, part of X front end for XBoard
    3. 

  3.  *
    4. 

  4.  * Copyright 2000, 2009, 2010, 2011 Free Software Foundation, Inc.
    5. 

  5.  * ------------------------------------------------------------------------
    6. 

  6.  *
    7. 

  7.  * GNU XBoard is free software: you can redistribute it and/or modify
    8. 

  8.  * it under the terms of the GNU General Public License as published by
    9. 

  9.  * the Free Software Foundation, either version 3 of the License, or (at
    10. 

  10.  * your option) any later version.
    11. 

  11.  *
    12. 

  12.  * GNU XBoard is distributed in the hope that it will be useful, but
    13. 

  13.  * WITHOUT ANY WARRANTY; without even the implied warranty of
    14. 

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    15. 

  15.  * General Public License for more details.
    16. 

  16.  *
    17. 

  17.  * You should have received a copy of the GNU General Public License
    18. 

  18.  * along with this program. If not, see http://www.gnu.org/licenses/.  *
    19. 

  19.  *
    20. 

  20.  *------------------------------------------------------------------------
    21. 

  21.  ** See the file ChangeLog for a revision history.  */
    22. 

  22. 

  23. // [HGM] this file is the counterpart of woptions.c, containing xboard popup menus
    24. 

  24. // similar to those of WinBoard, to set the most common options interactively.
    25. 

  25. 

  26. #include "config.h"
    27. 

  27. 

  28. #include <stdio.h>
    29. 

  29. #include <ctype.h>
    30. 

  30. #include <errno.h>
    31. 

  31. #include <sys/types.h>
    32. 

  32. 

  33. #if STDC_HEADERS
    34. 

  34. # include <stdlib.h>
    35. 

  35. # include <string.h>
    36. 

  36. #else /* not STDC_HEADERS */
    37. 

  37. extern char *getenv();
    38. 

  38. # if HAVE_STRING_H
    39. 

  39. #  include <string.h>
    40. 

  40. # else /* not HAVE_STRING_H */
    41. 

  41. #  include <strings.h>
    42. 

  42. # endif /* not HAVE_STRING_H */
    43. 

  43. #endif /* not STDC_HEADERS */
    44. 

  44. 

  45. #if HAVE_UNISTD_H
    46. 

  46. # include <unistd.h>
    47. 

  47. #endif
    48. 

  48. #include <stdint.h>
    49. 

  49. 

  50. #include <X11/Intrinsic.h>
    51. 

  51. #include <X11/StringDefs.h>
    52. 

  52. #include <X11/Shell.h>
    53. 

  53. #include <X11/Xatom.h>
    54. 

  54. #include <X11/Xaw/Dialog.h>
    55. 

  55. #include <X11/Xaw/Form.h>
    56. 

  56. #include <X11/Xaw/List.h>
    57. 

  57. #include <X11/Xaw/Label.h>
    58. 

  58. #include <X11/Xaw/SimpleMenu.h>
    59. 

  59. #include <X11/Xaw/SmeBSB.h>
    60. 

  60. #include <X11/Xaw/SmeLine.h>
    61. 

  61. #include <X11/Xaw/Box.h>
    62. 

  62. #include <X11/Xaw/Paned.h>
    63. 

  63. #include <X11/Xaw/MenuButton.h>
    64. 

  64. #include <X11/cursorfont.h>
    65. 

  65. #include <X11/Xaw/Text.h>
    66. 

  66. #include <X11/Xaw/AsciiText.h>
    67. 

  67. #include <X11/Xaw/Viewport.h>
    68. 

  68. #include <X11/Xaw/Toggle.h>
    69. 

  69. 

  70. #include "common.h"
    71. 

  71. #include "backend.h"
    72. 

  72. #include "xboard.h"
    73. 

  73. #include "gettext.h"
    74. 

  74. 

  75. #ifdef ENABLE_NLS
    76. 

  76. # define  _(s) gettext (s)
    77. 

  77. # define N_(s) gettext_noop (s)
    78. 

  78. #else
    79. 

  79. # define  _(s) (s)
    80. 

  80. # define N_(s)  s
    81. 

  81. #endif
    82. 

  82. 

  83. extern void SendToProgram P((char *message, ChessProgramState *cps));
    84. 

  84. FILE * XsraSelFile P((Widget w, char *prompt, char *ok, char *cancel, char *failed,
    85. 

  85. 		char *init_path, char *filter, char *mode, int (*show_entry)(), char **name_return));
    86. 

  86. 

  87. extern Widget formWidget, shellWidget, boardWidget, menuBarWidget;
    88. 

  88. extern Display *xDisplay;
    89. 

  89. extern int squareSize;
    90. 

  90. extern Pixmap xMarkPixmap;
    91. 

  91. extern char *layoutName;
    92. 

  92. extern Window xBoardWindow;
    93. 

  93. extern Arg layoutArgs[2], formArgs[2];
    94. 

  94. Pixel timerForegroundPixel, timerBackgroundPixel;
    95. 

  95. extern int searchTime;
    96. 

  96. extern Atom wm_delete_window;
    97. 

  97. extern int lineGap;
    98. 

  98. 

  99. // [HGM] the following code for makng menu popups was cloned from the FileNamePopUp routines
    100. 

  100. 

  101. static Widget previous = NULL;
    102. 

  102. 

  103. void SetFocus(Widget w, XtPointer data, XEvent *event, Boolean *b)
    104. 

  104. {
    105. 

  105.     Arg args[2];
    106. 

  106.     char *s;
    107. 

  107. 

  108.     if(previous) {
    109. 

  109. 	XtSetArg(args[0], XtNdisplayCaret, False);
    110. 

  110. 	XtSetValues(previous, args, 1);
    111. 

  111.     }
    112. 

  112.     XtSetArg(args[0], XtNstring, &s);
    113. 

  113.     XtGetValues(w, args, 1);
    114. 

  114.     XtSetArg(args[0], XtNdisplayCaret, True);
    115. 

  115.     XtSetArg(args[1], XtNinsertPosition, strlen(s));
    116. 

  116.     XtSetValues(w, args, 2);
    117. 

  117.     XtSetKeyboardFocus((Widget) data, w);
    118. 

  118.     previous = w;
    119. 

  119. }
    120. 

  120. 

  121. //--------------------------- New Shuffle Game --------------------------------------------
    122. 

  122. extern int shuffleOpenings;
    123. 

  123. extern int startedFromPositionFile;
    124. 

  124. int shuffleUp;
    125. 

  125. Widget shuffleShell;
    126. 

  126. 

  127. void ShufflePopDown()
    128. 

  128. {
    129. 

  129.     if (!shuffleUp) return;
    130. 

  130.     XtPopdown(shuffleShell);
    131. 

  131.     XtDestroyWidget(shuffleShell);
    132. 

  132.     shuffleUp = False;
    133. 

  133.     ModeHighlight();
    134. 

  134. }
    135. 

  135. 

  136. void ShuffleCallback(w, client_data, call_data)
    137. 

  137.      Widget w;
    138. 

  138.      XtPointer client_data, call_data;
    139. 

  139. {
    140. 

  140.     String name;
    141. 

  141.     Widget w2;
    142. 

  142.     Arg args[16];
    143. 

  143.     char buf[MSG_SIZ];
    144. 

  144. 

  145.     XtSetArg(args[0], XtNlabel, &name);
    146. 

  146.     XtGetValues(w, args, 1);
    147. 

  147. 

  148.     if (strcmp(name, _("cancel")) == 0) {
    149. 

  149.         ShufflePopDown();
    150. 

  150.         return;
    151. 

  151.     }
    152. 

  152.     if (strcmp(name, _("off")) == 0) {
    153. 

  153.         ShufflePopDown();
    154. 

  154. 	shuffleOpenings = False; // [HGM] should be moved to New Variant menu, once we have it!
    155. 

  155. 	ResetGameEvent();
    156. 

  156.         return;
    157. 

  157.     }
    158. 

  158.     if (strcmp(name, _("random")) == 0) {
    159. 

  159.       snprintf(buf, MSG_SIZ,  "%d", rand());
    160. 

  160. 	XtSetArg(args[0],XtNvalue, buf); // erase bad (non-numeric) value
    161. 

  161. 	XtSetValues(XtParent(w), args, 1);
    162. 

  162.         return;
    163. 

  163.     }
    164. 

  164.     if (strcmp(name, _("ok")) == 0) {
    165. 

  165. 	int nr; String name;
    166. 

  166.         name = XawDialogGetValueString(w2 = XtParent(w));
    167. 

  167. 	if(sscanf(name ,"%d",&nr) != 1) {
    168. 

  168. 	  snprintf(buf, MSG_SIZ,  "%d", appData.defaultFrcPosition);
    169. 

  169. 	    XtSetArg(args[0],XtNvalue, buf); // erase bad (non-numeric) value
    170. 

  170. 	    XtSetValues(w2, args, 1);
    171. 

  171. 	    return;
    172. 

  172. 	}
    173. 

  173. 	appData.defaultFrcPosition = nr;
    174. 

  174. 	shuffleOpenings = True;
    175. 

  175.         ShufflePopDown();
    176. 

  176. 	ResetGameEvent();
    177. 

  177.         return;
    178. 

  178.     }
    179. 

  179. }
    180. 

  180. 

  181. void ShufflePopUp()
    182. 

  182. {
    183. 

  183.     Arg args[16];
    184. 

  184.     Widget popup, layout, dialog, edit;
    185. 

  185.     Window root, child;
    186. 

  186.     int x, y, i;
    187. 

  187.     int win_x, win_y;
    188. 

  188.     unsigned int mask;
    189. 

  189.     char def[MSG_SIZ];
    190. 

  190. 

  191.     i = 0;
    192. 

  192.     XtSetArg(args[i], XtNresizable, True); i++;
    193. 

  193.     XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
    194. 

  194.     shuffleShell = popup =
    195. 

  195.       XtCreatePopupShell(_("New Shuffle Game"), transientShellWidgetClass,
    196. 

  196. 			 shellWidget, args, i);
    197. 

  197. 

  198.     layout =
    199. 

  199.       XtCreateManagedWidget(layoutName, formWidgetClass, popup,
    200. 

  200. 			    layoutArgs, XtNumber(layoutArgs));
    201. 

  201. 

  202.     snprintf(def, MSG_SIZ,  "%d\n", appData.defaultFrcPosition);
    203. 

  203.     i = 0;
    204. 

  204.     XtSetArg(args[i], XtNlabel, _("Start-position number:")); i++;
    205. 

  205.     XtSetArg(args[i], XtNvalue, def); i++;
    206. 

  206.     XtSetArg(args[i], XtNborderWidth, 0); i++;
    207. 

  207.     dialog = XtCreateManagedWidget(_("Shuffle"), dialogWidgetClass,
    208. 

  208. 				   layout, args, i);
    209. 

  209. 

  210. //    XtSetArg(args[0], XtNeditType, XawtextEdit);  // [HGM] can't get edit to work decently
    211. 

  211. //    XtSetArg(args[1], XtNuseStringInPlace, False);
    212. 

  212. //    XtSetValues(dialog, args, 2);
    213. 

  213. 

  214.     XawDialogAddButton(dialog, _("ok"), ShuffleCallback, (XtPointer) dialog);
    215. 

  215.     XawDialogAddButton(dialog, _("cancel"), ShuffleCallback, (XtPointer) dialog);
    216. 

  216.     XawDialogAddButton(dialog, _("random"), ShuffleCallback, (XtPointer) dialog);
    217. 

  217.     XawDialogAddButton(dialog, _("off"), ShuffleCallback, (XtPointer) dialog);
    218. 

  218. 

  219.     XtRealizeWidget(popup);
    220. 

  220.     CatchDeleteWindow(popup, "ShufflePopDown");
    221. 

  221. 

  222.     XQueryPointer(xDisplay, xBoardWindow, &root, &child,
    223. 

  223. 		  &x, &y, &win_x, &win_y, &mask);
    224. 

  224. 

  225.     XtSetArg(args[0], XtNx, x - 10);
    226. 

  226.     XtSetArg(args[1], XtNy, y - 30);
    227. 

  227.     XtSetValues(popup, args, 2);
    228. 

  228. 

  229.     XtPopup(popup, XtGrabExclusive);
    230. 

  230.     shuffleUp = True;
    231. 

  231. 

  232.     edit = XtNameToWidget(dialog, "*value");
    233. 

  233. 

  234.     XtSetKeyboardFocus(popup, edit);
    235. 

  235. }
    236. 

  236. 

  237. void ShuffleMenuProc(w, event, prms, nprms)
    238. 

  238.      Widget w;
    239. 

  239.      XEvent *event;
    240. 

  240.      String *prms;
    241. 

  241.      Cardinal *nprms;
    242. 

  242. {
    243. 

  243. //    if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
    244. 

  244. //	Reset(FALSE, TRUE);
    245. 

  245. //    }
    246. 

  246.     ShufflePopUp();
    247. 

  247. }
    248. 

  248. 

  249. //--------------------------- Time-Control Menu Popup ----------------------------------
    250. 

  250. int TimeControlUp;
    251. 

  251. Widget TimeControlShell;
    252. 

  252. int tcInc;
    253. 

  253. Widget tcMess1, tcMess2, tcData, tcTime, tcOdds1, tcOdds2;
    254. 

  254. int tcIncrement, tcMoves;
    255. 

  255. 

  256. void TimeControlPopDown()
    257. 

  257. {
    258. 

  258.     if (!TimeControlUp) return;
    259. 

  259.     previous = NULL;
    260. 

  260.     XtPopdown(TimeControlShell);
    261. 

  261.     XtDestroyWidget(TimeControlShell);
    262. 

  262.     TimeControlUp = False;
    263. 

  263.     ModeHighlight();
    264. 

  264. }
    265. 

  265. 

  266. void TimeControlCallback(w, client_data, call_data)
    267. 

  267.      Widget w;
    268. 

  268.      XtPointer client_data, call_data;
    269. 

  269. {
    270. 

  270.     String name, txt;
    271. 

  271.     Arg args[16];
    272. 

  272.     char buf[MSG_SIZ];
    273. 

  273.     int j;
    274. 

  274. 

  275.     XtSetArg(args[0], XtNlabel, &name);
    276. 

  276.     XtGetValues(w, args, 1);
    277. 

  277. 

  278.     if (strcmp(name, _("classical")) == 0) {
    279. 

  279. 	if(tcInc == 0) return;
    280. 

  280. 	j=0;
    281. 

  281. 	XtSetArg(args[j], XtNlabel, _("minutes for each")); j++;
    282. 

  282. 	XtSetValues(tcMess1, args, j);
    283. 

  283. 	j=0;
    284. 

  284. 	XtSetArg(args[j], XtNlabel, _("moves")); j++;
    285. 

  285. 	XtSetValues(tcMess2, args, j);
    286. 

  286. 	if(tcInc == 1) {
    287. 

  287. 	    j=0;
    288. 

  288. 	    XtSetArg(args[j], XtNstring, &name); j++;
    289. 

  289. 	    XtGetValues(tcData, args, j);
    290. 

  290. 	    tcIncrement = 0; sscanf(name, "%d", &tcIncrement);
    291. 

  291. 	}
    292. 

  292. 	snprintf(buf, MSG_SIZ,  "%d", tcMoves);
    293. 

  293. 	j=0;
    294. 

  294. 	XtSetArg(args[j], XtNstring, buf); j++;
    295. 

  295. 	XtSetValues(tcData, args, j);
    296. 

  296. 	tcInc = 0;
    297. 

  297.         return;
    298. 

  298.     }
    299. 

  299.     if (strcmp(name, _("incremental")) == 0) {
    300. 

  300. 	if(tcInc == 1) return;
    301. 

  301. 	j=0;
    302. 

  302. 	XtSetArg(args[j], XtNlabel, _("minutes, plus")); j++;
    303. 

  303. 	XtSetValues(tcMess1, args, j);
    304. 

  304. 	j=0;
    305. 

  305. 	XtSetArg(args[j], XtNlabel, _("sec/move")); j++;
    306. 

  306. 	XtSetValues(tcMess2, args, j);
    307. 

  307. 	if(tcInc == 0) {
    308. 

  308. 	    j=0;
    309. 

  309. 	    XtSetArg(args[j], XtNstring, &name); j++;
    310. 

  310. 	    XtGetValues(tcData, args, j);
    311. 

  311. 	    tcMoves = appData.movesPerSession; sscanf(name, "%d", &tcMoves);
    312. 

  312. 	}
    313. 

  313. 	snprintf(buf, MSG_SIZ,  "%d", tcIncrement);
    314. 

  314. 	j=0;
    315. 

  315. 	XtSetArg(args[j], XtNstring, buf); j++;
    316. 

  316. 	XtSetValues(tcData, args, j);
    317. 

  317. 	tcInc = 1;
    318. 

  318.         return;
    319. 

  319.     }
    320. 

  320.     if (strcmp(name, _("fixed time")) == 0) {
    321. 

  321. 	if(tcInc == 2) return;
    322. 

  322. 	j=0;
    323. 

  323. 	XtSetArg(args[j], XtNlabel, _("sec/move (max)")); j++;
    324. 

  324. 	XtSetValues(tcMess1, args, j);
    325. 

  325. 	j=0;
    326. 

  326. 	XtSetArg(args[j], XtNlabel, _("")); j++;
    327. 

  327. 	XtSetValues(tcMess2, args, j);
    328. 

  328. 	j=0;
    329. 

  329. 	XtSetArg(args[j], XtNstring, ""); j++;
    330. 

  330. 	XtSetValues(tcData, args, j);
    331. 

  331. 	tcInc = 2;
    332. 

  332.         return;
    333. 

  333.     }
    334. 

  334.     if (strcmp(name, _(" OK ")) == 0) {
    335. 

  335. 	int inc, mps, ok;
    336. 

  336. 	XtSetArg(args[0], XtNstring, &txt);
    337. 

  337. 	XtGetValues(tcData, args, 1);
    338. 

  338. 	switch(tcInc) {
    339. 

  339. 	  case 1:
    340. 

  340. 	    ok = sscanf(txt, "%d", &inc); mps = 0;
    341. 

  341. 	    if(!ok && txt[0] == 0) { inc = 0; ok = 1; } // accept empty string as zero
    342. 

  342. 	    ok &= (inc >= 0);
    343. 

  343. 	    break;
    344. 

  344. 	  case 0:
    345. 

  345. 	    ok = sscanf(txt, "%d", &mps); inc = -1;
    346. 

  346. 	    ok &= (mps > 0);
    347. 

  347. 	    break;
    348. 

  348. 	  case 2:
    349. 

  349. 	    ok = 1; inc = -1; mps = 40;
    350. 

  350. 	}
    351. 

  351. 	if(ok != 1) {
    352. 

  352. 	    XtSetArg(args[0], XtNstring, ""); // erase any offending input
    353. 

  353. 	    XtSetValues(tcData, args, 1);
    354. 

  354. 	    return;
    355. 

  355. 	}
    356. 

  356. 	XtSetArg(args[0], XtNstring, &txt);
    357. 

  357. 	XtGetValues(tcTime, args, 1);
    358. 

  358. 	if(tcInc == 2) {
    359. 

  359. 	    if(sscanf(txt, "%d", &inc) != 1) {
    360. 

  360. 		XtSetArg(args[0], XtNstring, ""); // erase any offending input
    361. 

  361. 		XtSetValues(tcTime, args, 1);
    362. 

  362. 		DisplayError(_("Bad Time-Control String"), 0);
    363. 

  363. 		return;
    364. 

  364. 	    }
    365. 

  365. 	    searchTime = inc;
    366. 

  366. 	} else {
    367. 

  367. 	    if(!ParseTimeControl(txt, inc, mps)) {
    368. 

  368. 		XtSetArg(args[0], XtNstring, ""); // erase any offending input
    369. 

  369. 		XtSetValues(tcTime, args, 1);
    370. 

  370. 		DisplayError(_("Bad Time-Control String"), 0);
    371. 

  371. 		return;
    372. 

  372. 	    }
    373. 

  373. 	    searchTime = 0;
    374. 

  374. 	    appData.movesPerSession = mps;
    375. 

  375. 	    appData.timeIncrement = inc;
    376. 

  376. 	    appData.timeControl = strdup(txt);
    377. 

  377. 	}
    378. 

  378. 	XtSetArg(args[0], XtNstring, &txt);
    379. 

  379. 	XtGetValues(tcOdds1, args, 1);
    380. 

  380. 	appData.firstTimeOdds = first.timeOdds
    381. 

  381. 		= (sscanf(txt, "%d", &j) == 1 && j > 0) ? j : 1;
    382. 

  382. 	XtGetValues(tcOdds2, args, 1);
    383. 

  383. 	appData.secondTimeOdds = second.timeOdds
    384. 

  384. 		= (sscanf(txt, "%d", &j) == 1 && j > 0) ? j : 1;
    385. 

  385. 

  386. 	Reset(True, True);
    387. 

  387.         TimeControlPopDown();
    388. 

  388.         return;
    389. 

  389.     }
    390. 

  390. }
    391. 

  391. 

  392. void TimeControlPopUp()
    393. 

  393. {
    394. 

  394.     Arg args[16];
    395. 

  395.     Widget popup, layout, form,  b_ok, b_cancel, b_clas, b_inc, mess;
    396. 

  396.     Window root, child;
    397. 

  397.     int x, y, i, j;
    398. 

  398.     int win_x, win_y;
    399. 

  399.     unsigned int mask;
    400. 

  400.     char def[MSG_SIZ];
    401. 

  401. 

  402.     tcInc = searchTime > 0 ? 2 : (appData.timeIncrement >= 0);
    403. 

  403.     tcMoves = appData.movesPerSession; tcIncrement = appData.timeIncrement;
    404. 

  404.     if(!tcInc) tcIncrement = 0;
    405. 

  405.     snprintf(def, MSG_SIZ,  "%d", tcInc ? tcIncrement : tcMoves);
    406. 

  406. 

  407.     i = 0;
    408. 

  408.     XtSetArg(args[i], XtNresizable, True); i++;
    409. 

  409. //    XtSetArg(args[i], XtNwidth, DIALOG_SIZE); i++;
    410. 

  410.     TimeControlShell = popup =
    411. 

  411.       XtCreatePopupShell(_("TimeControl Menu"), transientShellWidgetClass,
    412. 

  412. 			 shellWidget, args, i);
    413. 

  413. 

  414.     layout =
    415. 

  415.       XtCreateManagedWidget(layoutName, formWidgetClass, popup,
    416. 

  416. 			    layoutArgs, XtNumber(layoutArgs));
    417. 

  417. 

  418.     form =
    419. 

  419.       XtCreateManagedWidget(layoutName, formWidgetClass, layout,
    420. 

  420. 			    formArgs, XtNumber(formArgs));
    421. 

  421. 

  422.     j = 0;
    423. 

  423. //    XtSetArg(args[j], XtNwidth,     (XtArgVal) 300); j++;
    424. 

  424. //    XtSetArg(args[j], XtNheight,    (XtArgVal) 85); j++;
    425. 

  425.     XtSetValues(popup, args, j);
    426. 

  426. 

  427.     j= 0;
    428. 

  428.     XtSetArg(args[j], XtNborderWidth, 1); j++;
    429. 

  429.     XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
    430. 

  430.     XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
    431. 

  431.     XtSetArg(args[j], XtNstring, appData.timeControl);  j++;
    432. 

  432.     XtSetArg(args[j], XtNdisplayCaret, False);  j++;
    433. 

  433.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    434. 

  434.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    435. 

  435.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    436. 

  436.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    437. 

  437.     XtSetArg(args[j], XtNresizable, True);  j++;
    438. 

  438.     XtSetArg(args[j], XtNwidth,  85);  j++;
    439. 

  439.     XtSetArg(args[j], XtNinsertPosition, 9999);  j++;
    440. 

  440.     tcTime = XtCreateManagedWidget("TC", asciiTextWidgetClass, form, args, j);
    441. 

  441.     XtAddEventHandler(tcTime, ButtonPressMask, False, SetFocus, (XtPointer) popup);
    442. 

  442. 

  443.     j= 0;
    444. 

  444.     XtSetArg(args[j], XtNlabel, tcInc ? tcInc == 2 ? _("sec/move (max)   ") : _("   minutes, plus   ") : _("minutes for each")); j++;
    445. 

  445.     XtSetArg(args[j], XtNborderWidth, 0); j++;
    446. 

  446.     XtSetArg(args[j], XtNfromHoriz, tcTime); j++;
    447. 

  447.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    448. 

  448.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    449. 

  449.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    450. 

  450.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    451. 

  451.   //  XtSetArg(args[j], XtNwidth,  100);  j++;
    452. 

  452.   //  XtSetArg(args[j], XtNheight, 20);  j++;
    453. 

  453.     tcMess1 = XtCreateManagedWidget("TCtext", labelWidgetClass, form, args, j);
    454. 

  454. 

  455.     j= 0;
    456. 

  456.     XtSetArg(args[j], XtNborderWidth, 1); j++;
    457. 

  457.     XtSetArg(args[j], XtNfromHoriz, tcMess1); j++;
    458. 

  458.     XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
    459. 

  459.     XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
    460. 

  460.     XtSetArg(args[j], XtNstring, def);  j++;
    461. 

  461.     XtSetArg(args[j], XtNdisplayCaret, False);  j++;
    462. 

  462.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    463. 

  463.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    464. 

  464.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    465. 

  465.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    466. 

  466.     XtSetArg(args[j], XtNresizable, True);  j++;
    467. 

  467.     XtSetArg(args[j], XtNwidth,  40);  j++;
    468. 

  468. //    XtSetArg(args[j], XtNheight, 20);  j++;
    469. 

  469.     tcData = XtCreateManagedWidget("MPS", asciiTextWidgetClass, form, args, j);
    470. 

  470.     XtAddEventHandler(tcData, ButtonPressMask, False, SetFocus, (XtPointer) popup);
    471. 

  471. 

  472.     j= 0;
    473. 

  473.     XtSetArg(args[j], XtNlabel, tcInc ? tcInc == 2 ? _("             ") : _("sec/move") : _("moves     ")); j++;
    474. 

  474.     XtSetArg(args[j], XtNjustify, XtJustifyLeft); j++;
    475. 

  475.     XtSetArg(args[j], XtNborderWidth, 0); j++;
    476. 

  476.     XtSetArg(args[j], XtNfromHoriz, tcData); j++;
    477. 

  477.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    478. 

  478.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    479. 

  479.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    480. 

  480.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    481. 

  481. //    XtSetArg(args[j], XtNwidth,  80);  j++;
    482. 

  482. //    XtSetArg(args[j], XtNheight, 20);  j++;
    483. 

  483.     tcMess2 = XtCreateManagedWidget("MPStext", labelWidgetClass,
    484. 

  484. 				   form, args, j);
    485. 

  485. 

  486.     j= 0;
    487. 

  487.     XtSetArg(args[j], XtNborderWidth, 1); j++;
    488. 

  488.     XtSetArg(args[j], XtNfromVert, tcTime); j++;
    489. 

  489.     XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
    490. 

  490.     XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
    491. 

  491.     XtSetArg(args[j], XtNstring, "1");  j++;
    492. 

  492.     XtSetArg(args[j], XtNdisplayCaret, False);  j++;
    493. 

  493.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    494. 

  494.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    495. 

  495.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    496. 

  496.     XtSetArg(args[j], XtNright, XtChainLeft);  j++;
    497. 

  497.     XtSetArg(args[j], XtNresizable, True);  j++;
    498. 

  498.     XtSetArg(args[j], XtNwidth,  40);  j++;
    499. 

  499. //    XtSetArg(args[j], XtNheight, 20);  j++;
    500. 

  500.     tcOdds1 = XtCreateManagedWidget("Odds1", asciiTextWidgetClass, form, args, j);
    501. 

  501.     XtAddEventHandler(tcOdds1, ButtonPressMask, False, SetFocus, (XtPointer) popup);
    502. 

  502. 

  503.     j= 0;
    504. 

  504.     XtSetArg(args[j], XtNborderWidth, 1); j++;
    505. 

  505.     XtSetArg(args[j], XtNfromVert, tcTime); j++;
    506. 

  506.     XtSetArg(args[j], XtNfromHoriz, tcOdds1); j++;
    507. 

  507.     XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
    508. 

  508.     XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
    509. 

  509.     XtSetArg(args[j], XtNstring, "1");  j++;
    510. 

  510.     XtSetArg(args[j], XtNdisplayCaret, False);  j++;
    511. 

  511.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    512. 

  512.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    513. 

  513.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    514. 

  514.     XtSetArg(args[j], XtNright, XtChainLeft);  j++;
    515. 

  515.     XtSetArg(args[j], XtNresizable, True);  j++;
    516. 

  516.     XtSetArg(args[j], XtNwidth,  40);  j++;
    517. 

  517. //    XtSetArg(args[j], XtNheight, 20);  j++;
    518. 

  518.     tcOdds2 = XtCreateManagedWidget("Odds2", asciiTextWidgetClass, form, args, j);
    519. 

  519.     XtAddEventHandler(tcOdds2, ButtonPressMask, False, SetFocus, (XtPointer) popup);
    520. 

  520. 

  521.     j= 0;
    522. 

  522.     XtSetArg(args[j], XtNlabel, _("Engine #1 and #2 Time-Odds Factors")); j++;
    523. 

  523.     XtSetArg(args[j], XtNjustify, XtJustifyLeft); j++;
    524. 

  524.     XtSetArg(args[j], XtNborderWidth, 0); j++;
    525. 

  525.     XtSetArg(args[j], XtNfromVert, tcTime); j++;
    526. 

  526.     XtSetArg(args[j], XtNfromHoriz, tcOdds2); j++;
    527. 

  527.     XtSetArg(args[j], XtNtop, XtChainTop);  j++;
    528. 

  528.     XtSetArg(args[j], XtNbottom, XtChainTop);  j++;
    529. 

  529.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    530. 

  530.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    531. 

  531. //    XtSetArg(args[j], XtNwidth,  200);  j++;
    532. 

  532. //    XtSetArg(args[j], XtNheight, 20);  j++;
    533. 

  533.     mess = XtCreateManagedWidget("Oddstext", labelWidgetClass,
    534. 

  534. 				   form, args, j);
    535. 

  535.     j=0;
    536. 

  536.     XtSetArg(args[j], XtNfromVert, tcOdds1);  j++;
    537. 

  537.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    538. 

  538.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    539. 

  539.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    540. 

  540.     XtSetArg(args[j], XtNright, XtChainLeft);  j++;
    541. 

  541.     XtSetArg(args[j], XtNstate, tcInc==0); j++;
    542. 

  542.     b_clas= XtCreateManagedWidget(_("classical"), toggleWidgetClass,
    543. 

  543. 				   form, args, j);
    544. 

  544.     XtAddCallback(b_clas, XtNcallback, TimeControlCallback, (XtPointer) 0);
    545. 

  545. 

  546.     j=0;
    547. 

  547.     XtSetArg(args[j], XtNradioGroup, b_clas); j++;
    548. 

  548.     XtSetArg(args[j], XtNfromVert, tcOdds1);  j++;
    549. 

  549.     XtSetArg(args[j], XtNfromHoriz, b_clas);  j++;
    550. 

  550.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    551. 

  551.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    552. 

  552.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    553. 

  553.     XtSetArg(args[j], XtNright, XtChainLeft);  j++;
    554. 

  554.     XtSetArg(args[j], XtNstate, tcInc==1); j++;
    555. 

  555.     b_inc = XtCreateManagedWidget(_("incremental"), toggleWidgetClass,
    556. 

  556. 				   form, args, j);
    557. 

  557.     XtAddCallback(b_inc, XtNcallback, TimeControlCallback, (XtPointer) 0);
    558. 

  558. 

  559.     j=0;
    560. 

  560.     XtSetArg(args[j], XtNradioGroup, b_inc); j++;
    561. 

  561.     XtSetArg(args[j], XtNfromVert, tcOdds1);  j++;
    562. 

  562.     XtSetArg(args[j], XtNfromHoriz, b_inc);  j++;
    563. 

  563.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    564. 

  564.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    565. 

  565.     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;
    566. 

  566.     XtSetArg(args[j], XtNright, XtChainLeft);  j++;
    567. 

  567.     XtSetArg(args[j], XtNstate, tcInc==2); j++;
    568. 

  568.     b_inc = XtCreateManagedWidget(_("fixed time"), toggleWidgetClass,
    569. 

  569. 				   form, args, j);
    570. 

  570.     XtAddCallback(b_inc, XtNcallback, TimeControlCallback, (XtPointer) 0);
    571. 

  571. 

  572.     j=0;
    573. 

  573.     XtSetArg(args[j], XtNfromVert, tcOdds1);  j++;
    574. 

  574.     XtSetArg(args[j], XtNfromHoriz, tcData);  j++;
    575. 

  575.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    576. 

  576.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    577. 

  577.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    578. 

  578.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    579. 

  579.     b_ok= XtCreateManagedWidget(_(" OK "), commandWidgetClass,
    580. 

  580. 				   form, args, j);
    581. 

  581.     XtAddCallback(b_ok, XtNcallback, TimeControlCallback, (XtPointer) 0);
    582. 

  582. 

  583.     j=0;
    584. 

  584.     XtSetArg(args[j], XtNfromVert, tcOdds1);  j++;
    585. 

  585.     XtSetArg(args[j], XtNfromHoriz, b_ok);  j++;
    586. 

  586.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    587. 

  587.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    588. 

  588.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    589. 

  589.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    590. 

  590.     b_cancel= XtCreateManagedWidget(_("cancel"), commandWidgetClass,
    591. 

  591. 				   form, args, j);
    592. 

  592.     XtAddCallback(b_cancel, XtNcallback, TimeControlPopDown, (XtPointer) 0);
    593. 

  593. 

  594.     XtRealizeWidget(popup);
    595. 

  595.     CatchDeleteWindow(popup, "TimeControlPopDown");
    596. 

  596. 

  597.     XQueryPointer(xDisplay, xBoardWindow, &root, &child,
    598. 

  598. 		  &x, &y, &win_x, &win_y, &mask);
    599. 

  599. 

  600.     XtSetArg(args[0], XtNx, x - 10);
    601. 

  601.     XtSetArg(args[1], XtNy, y - 30);
    602. 

  602.     XtSetValues(popup, args, 2);
    603. 

  603. 

  604.     XtPopup(popup, XtGrabExclusive);
    605. 

  605.     TimeControlUp = True;
    606. 

  606. 

  607.     previous = NULL;
    608. 

  608.     SetFocus(tcTime, popup, (XEvent*) NULL, False);
    609. 

  609. //    XtSetKeyboardFocus(popup, tcTime);
    610. 

  610. }
    611. 

  611. 

  612. void TimeControlProc(w, event, prms, nprms)
    613. 

  613.      Widget w;
    614. 

  614.      XEvent *event;
    615. 

  615.      String *prms;
    616. 

  616.      Cardinal *nprms;
    617. 

  617. {
    618. 

  618.    TimeControlPopUp();
    619. 

  619. }
    620. 

  620. 

  621. //--------------------------- Engine-specific options menu ----------------------------------
    622. 

  622. 

  623. int values[MAX_OPTIONS];
    624. 

  624. ChessProgramState *currentCps;
    625. 

  625. static Option *currentOption;
    626. 

  626. extern Widget shells[];
    627. 

  627. static Boolean browserUp;
    628. 

  628. 

  629. void CheckCallback(Widget ww, XtPointer data, XEvent *event, Boolean *b)
    630. 

  630. {
    631. 

  631.     Widget w = currentOption[(int)(intptr_t)data].handle;
    632. 

  632.     Boolean s;
    633. 

  633.     Arg args[16];
    634. 

  634. 

  635.     XtSetArg(args[0], XtNstate, &s);
    636. 

  636.     XtGetValues(w, args, 1);
    637. 

  637.     XtSetArg(args[0], XtNstate, !s);
    638. 

  638.     XtSetValues(w, args, 1);
    639. 

  639. }
    640. 

  640. 

  641. void SpinCallback(w, client_data, call_data)
    642. 

  642.      Widget w;
    643. 

  643.      XtPointer client_data, call_data;
    644. 

  644. {
    645. 

  645.     String name, val;
    646. 

  646.     Arg args[16];
    647. 

  647.     char buf[MSG_SIZ], *p;
    648. 

  648.     int j;
    649. 

  649.     int data = (intptr_t) client_data;
    650. 

  650. 

  651.     XtSetArg(args[0], XtNlabel, &name);
    652. 

  652.     XtGetValues(w, args, 1);
    653. 

  653. 

  654.     j = 0;
    655. 

  655.     XtSetArg(args[0], XtNstring, &val);
    656. 

  656.     XtGetValues(currentOption[data].handle, args, 1);
    657. 

  657.     sscanf(val, "%d", &j);
    658. 

  658.     if (strcmp(name, "browse") == 0) {
    659. 

  659. 	char *q, *r;
    660. 

  660. 	XtSetArg(args[0], XtNstring, &q);
    661. 

  661. 	XtGetValues(currentOption[data].handle, args, 1);
    662. 

  662. 	for(r = ""; *q; q++) if(*q == '.') r = q; else if(*q == '/') r = ""; // last dot after last slash
    663. 

  663. 	browserUp = True;
    664. 

  664. 	if(XsraSelFile(shells[0], currentOption[data].name, NULL, NULL, "", "", r,
    665. 

  665. 			 	  currentOption[data].type == PathName ? "p" : "f", NULL, &p)) {
    666. 

  666. 		int len = strlen(p);
    667. 

  667. 		if(len && p[len-1] == '/') p[len-1] = NULLCHAR;
    668. 

  668. 		XtSetArg(args[0], XtNstring, p);
    669. 

  669. 		XtSetValues(currentOption[data].handle, args, 1);
    670. 

  670. 	}
    671. 

  671. 	browserUp = False;
    672. 

  672. 	SetFocus(currentOption[data].handle, shells[0], (XEvent*) NULL, False);
    673. 

  673. 	return;
    674. 

  674.     } else
    675. 

  675.     if (strcmp(name, "+") == 0) {
    676. 

  676. 	if(++j > currentOption[data].max) return;
    677. 

  677.     } else
    678. 

  678.     if (strcmp(name, "-") == 0) {
    679. 

  679. 	if(--j < currentOption[data].min) return;
    680. 

  680.     } else return;
    681. 

  681.     snprintf(buf, MSG_SIZ,  "%d", j);
    682. 

  682.     XtSetArg(args[0], XtNstring, buf);
    683. 

  683.     XtSetValues(currentOption[data].handle, args, 1);
    684. 

  684.     SetFocus(currentOption[data].handle, shells[0], NULL, False);
    685. 

  685. }
    686. 

  686. 

  687. void ComboSelect(w, addr, index) // callback for all combo items
    688. 

  688.      Widget w;
    689. 

  689.      caddr_t addr;
    690. 

  690.      caddr_t index;
    691. 

  691. {
    692. 

  692.     Arg args[16];
    693. 

  693.     int i = ((intptr_t)addr)>>8;
    694. 

  694.     int j = 255 & (intptr_t) addr;
    695. 

  695. 

  696.     values[i] = j; // store in temporary, for transfer at OK
    697. 

  697.     XtSetArg(args[0], XtNlabel, ((char**)currentOption[i].textValue)[j]);
    698. 

  698.     XtSetValues(currentOption[i].handle, args, 1);
    699. 

  699. }
    700. 

  700. 

  701. void CreateComboPopup(parent, name, n, mb)
    702. 

  702.      Widget parent;
    703. 

  703.      String name;
    704. 

  704.      int n;
    705. 

  705.      char *mb[];
    706. 

  706. {
    707. 

  707.     int i=0, j;
    708. 

  708.     Widget menu, entry;
    709. 

  709.     Arg args[16];
    710. 

  710. 

  711.     menu = XtCreatePopupShell(name, simpleMenuWidgetClass,
    712. 

  712. 			      parent, NULL, 0);
    713. 

  713.     j = 0;
    714. 

  714.     XtSetArg(args[j], XtNwidth, 100);  j++;
    715. 

  715. //    XtSetArg(args[j], XtNright, XtChainRight);  j++;
    716. 

  716.     while (mb[i] != NULL) {
    717. 

  717. 	    entry = XtCreateManagedWidget(mb[i], smeBSBObjectClass,
    718. 

  718. 					  menu, args, j);
    719. 

  719. 	    XtAddCallback(entry, XtNcallback,
    720. 

  720. 			  (XtCallbackProc) ComboSelect,
    721. 

  721. 			  (caddr_t)(intptr_t) (256*n+i));
    722. 

  722. 	i++;
    723. 

  723.     }
    724. 

  724. }
    725. 

  725. 

  726. 

  727. //----------------------------Generic dialog --------------------------------------------
    728. 

  728. 

  729. // cloned from Engine Settings dialog (and later merged with it)
    730. 

  730. 

  731. typedef void ButtonCallback(int n);
    732. 

  732. 

  733. char *trialSound;
    734. 

  734. static int oldCores, oldPonder;
    735. 

  735. int MakeColors P((void));
    736. 

  736. void CreateGCs P((int redo));
    737. 

  737. void CreateAnyPieces P((void));
    738. 

  738. void GenericReadout P((int selected));
    739. 

  739. Widget shells[10];
    740. 

  740. Widget marked[10];
    741. 

  741. Boolean shellUp[10];
    742. 

  742. WindowPlacement *wp[10];
    743. 

  743. Option *dialogOptions[10];
    744. 

  744. 

  745. void MarkMenu(char *item, int dlgNr)
    746. 

  746. {
    747. 

  747.     Arg args[2];
    748. 

  748.     XtSetArg(args[0], XtNleftBitmap, xMarkPixmap);
    749. 

  749.     XtSetValues(marked[dlgNr] = XtNameToWidget(menuBarWidget, item), args, 1);
    750. 

  750. }
    751. 

  751. 

  752. int PopDown(int n)
    753. 

  753. {
    754. 

  754.     int j;
    755. 

  755.     Arg args[10];
    756. 

  756.     Dimension windowH, windowW; Position windowX, windowY;
    757. 

  757.     if (!shellUp[n]) return 0;
    758. 

  758.     if(n && wp[n]) { // remember position
    759. 

  759. 	j = 0;
    760. 

  760. 	XtSetArg(args[j], XtNx, &windowX); j++;
    761. 

  761. 	XtSetArg(args[j], XtNy, &windowY); j++;
    762. 

  762. 	XtSetArg(args[j], XtNheight, &windowH); j++;
    763. 

  763. 	XtSetArg(args[j], XtNwidth, &windowW); j++;
    764. 

  764. 	XtGetValues(shells[n], args, j);
    765. 

  765. 	wp[n]->x = windowX;
    766. 

  766. 	wp[n]->x = windowY;
    767. 

  767. 	wp[n]->width  = windowW;
    768. 

  768. 	wp[n]->height = windowH;
    769. 

  769.     }
    770. 

  770.     previous = NULL;
    771. 

  771.     XtPopdown(shells[n]);
    772. 

  772.     if(n == 0) XtDestroyWidget(shells[n]);
    773. 

  773.     shellUp[n] = False;
    774. 

  774.     if(marked[n]) {
    775. 

  775. 	XtSetArg(args[0], XtNleftBitmap, None);
    776. 

  776. 	XtSetValues(marked[n], args, 1);
    777. 

  777.     }
    778. 

  778.     if(!n) currentCps = NULL; // if an Engine Settings dialog was up, we must be popping it down now
    779. 

  779.     return 1;
    780. 

  780. }
    781. 

  781. 

  782. void GenericPopDown(w, event, prms, nprms)
    783. 

  783.      Widget w;
    784. 

  784.      XEvent *event;
    785. 

  785.      String *prms;
    786. 

  786.      Cardinal *nprms;
    787. 

  787. {
    788. 

  788.     int n;
    789. 

  789.     if(browserUp) return; // prevent closing dialog when it has an open file-browse daughter
    790. 

  790.     PopDown(prms[0][0] - '0');
    791. 

  791. }
    792. 

  792. 

  793. Option matchOptions[] = {
    794. 

  794. { 0,  2, 1000000000, NULL, (void*) &appData.defaultMatchGames, "", NULL, Spin, N_("Default Number of Games in Match:") },
    795. 

  795. { 0,  0, 1000000000, NULL, (void*) &appData.matchPause, "", NULL, Spin, N_("Pause between Match Games (msec):") },
    796. 

  796. { 0,  0,          0, NULL, (void*) &appData.loadGameFile, "", NULL, FileName, N_("Game File with Opening Lines:") },
    797. 

  797. { 0, -2, 1000000000, NULL, (void*) &appData.loadGameIndex, "", NULL, Spin, N_("Game Number (-1 or -2 = Auto-Increment):") },
    798. 

  798. { 0,  0,          0, NULL, (void*) &appData.loadPositionFile, "", NULL, FileName, N_("File with Start Positions:") },
    799. 

  799. { 0, -2, 1000000000, NULL, (void*) &appData.loadPositionIndex, "", NULL, Spin, N_("Position Number (-1 or -2 = Auto-Increment):") },
    800. 

  800. { 0,  0, 1000000000, NULL, (void*) &appData.rewindIndex, "", NULL, Spin, N_("Rewind Index after this many Games (0 = never):") },
    801. 

  801. { 0, 0, 0, NULL, NULL, "", NULL, EndMark , "" }
    802. 

  802. };
    803. 

  803. 

  804. void GeneralOptionsOK(int n)
    805. 

  805. {
    806. 

  806. 	int newPonder = appData.ponderNextMove;
    807. 

  807. 	appData.ponderNextMove = oldPonder;
    808. 

  808. 	PonderNextMoveEvent(newPonder);
    809. 

  809. }
    810. 

  810. 

  811. Option generalOptions[] = {
    812. 

  812. { 0,  0, 0, NULL, (void*) &appData.alwaysPromoteToQueen, "", NULL, CheckBox, N_("Always Queen") },
    813. 

  813. { 0,  0, 0, NULL, (void*) &appData.animateDragging, "", NULL, CheckBox, N_("Animate Dragging") },
    814. 

  814. { 0,  0, 0, NULL, (void*) &appData.animate, "", NULL, CheckBox, N_("Animate Moving") },
    815. 

  815. { 0,  0, 0, NULL, (void*) &appData.autoCallFlag, "", NULL, CheckBox, N_("Auto Flag") },
    816. 

  816. { 0,  0, 0, NULL, (void*) &appData.autoFlipView, "", NULL, CheckBox, N_("Auto Flip View") },
    817. 

  817. { 0,  0, 0, NULL, (void*) &appData.blindfold, "", NULL, CheckBox, N_("Blindfold") },
    818. 

  818. { 0,  0, 0, NULL, (void*) &appData.dropMenu, "", NULL, CheckBox, N_("Drop Menu") },
    819. 

  819. { 0,  0, 0, NULL, (void*) &appData.highlightDragging, "", NULL, CheckBox, N_("Highlight Dragging (Show Move Targets)") },
    820. 

  820. { 0,  0, 0, NULL, (void*) &appData.highlightLastMove, "", NULL, CheckBox, N_("Highlight Last Move") },
    821. 

  821. { 0,  0, 0, NULL, (void*) &appData.highlightMoveWithArrow, "", NULL, CheckBox, N_("Highlight with Arrow") },
    822. 

  822. { 0,  0, 0, NULL, (void*) &appData.ringBellAfterMoves, "", NULL, CheckBox, N_("Move Sound") },
    823. 

  823. { 0,  0, 0, NULL, (void*) &appData.oneClick, "", NULL, CheckBox, N_("One-Click Moving") },
    824. 

  824. { 0,  0, 0, NULL, (void*) &appData.periodicUpdates, "", NULL, CheckBox, N_("Periodic Updates (in Analysis Mode)") },
    825. 

  825. { 0,  0, 0, NULL, (void*) &appData.ponderNextMove, "", NULL, CheckBox, N_("Ponder Next Move") },
    826. 

  826. { 0,  0, 0, NULL, (void*) &appData.popupExitMessage, "", NULL, CheckBox, N_("Popup Exit Messages") },
    827. 

  827. { 0,  0, 0, NULL, (void*) &appData.popupMoveErrors, "", NULL, CheckBox, N_("Popup Move Errors") },
    828. 

  828. { 0,  0, 0, NULL, (void*) &appData.showCoords, "", NULL, CheckBox, N_("Show Coordinates") },
    829. 

  829. { 0,  0, 0, NULL, (void*) &appData.markers, "", NULL, CheckBox, N_("Show Target Squares") },
    830. 

  830. { 0,  0, 0, NULL, (void*) &appData.hideThinkingFromHuman, "", NULL, CheckBox, N_("Hide Thinking from Human") },
    831. 

  831. { 0,  0, 0, NULL, (void*) &appData.testLegality, "", NULL, CheckBox, N_("Test Legality") },
    832. 

  832. { 0, 0, 10, NULL, (void*) &appData.flashCount, "", NULL, Spin, N_("Flash Moves (0 = no flashing):") },
    833. 

  833. { 0, 1, 10, NULL, (void*) &appData.flashRate, "", NULL, Spin, N_("Flash Rate (high = fast):") },
    834. 

  834. { 0, 5, 100,NULL, (void*) &appData.animSpeed, "", NULL, Spin, N_("Animation Speed (high = slow):") },
    835. 

  835. { 0,  0, 0, NULL, (void*) &GeneralOptionsOK, "", NULL, EndMark , "" }
    836. 

  836. };
    837. 

  837. 

  838. void Pick(int n)
    839. 

  839. {
    840. 

  840. 	VariantClass v = currentOption[n].value;
    841. 

  841. 	if(!appData.noChessProgram) {
    842. 

  842. 	    char *name = VariantName(v), buf[MSG_SIZ];
    843. 

  843. 	    if (first.protocolVersion > 1 && StrStr(first.variants, name) == NULL) {
    844. 

  844. 		/* [HGM] in protocol 2 we check if variant is suported by engine */
    845. 

  845. 	      snprintf(buf, MSG_SIZ,  _("Variant %s not supported by %s"), name, first.tidy);
    846. 

  846. 		DisplayError(buf, 0);
    847. 

  847. 		return; /* ignore OK if first engine does not support it */
    848. 

  848. 	    } else
    849. 

  849. 	    if (second.initDone && second.protocolVersion > 1 && StrStr(second.variants, name) == NULL) {
    850. 

  850. 	      snprintf(buf, MSG_SIZ,  _("Warning: second engine (%s) does not support this!"), second.tidy);
    851. 

  851. 		DisplayError(buf, 0);   /* use of second engine is optional; only warn user */
    852. 

  852. 	    }
    853. 

  853. 	}
    854. 

  854. 

  855. 	GenericReadout(-1); // make sure ranks and file settings are read
    856. 

  856. 

  857. 	gameInfo.variant = v;
    858. 

  858. 	appData.variant = VariantName(v);
    859. 

  859. 

  860. 	shuffleOpenings = FALSE; /* [HGM] shuffle: possible shuffle reset when we switch */
    861. 

  861. 	startedFromPositionFile = FALSE; /* [HGM] loadPos: no longer valid in new variant */
    862. 

  862. 	appData.pieceToCharTable = NULL;
    863. 

  863. 	appData.pieceNickNames = "";
    864. 

  864. 	appData.colorNickNames = "";
    865. 

  865. 	Reset(True, True);
    866. 

  866.         PopDown(0);
    867. 

  867.         return;
    868. 

  868. }
    869. 

  869. 

  870. Option variantDescriptors[] = {
    871. 

  871. { VariantNormal, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("normal")},
    872. 

  872. { VariantFairy, 1, 135, NULL, (void*) &Pick, "#BFBFBF", NULL, Button, N_("fairy")},
    873. 

  873. { VariantFischeRandom, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("FRC")},
    874. 

  874. { VariantSChess, 1, 135, NULL, (void*) &Pick, "#FFBFBF", NULL, Button, N_("Seirawan")},
    875. 

  875. { VariantWildCastle, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("wild castle")},
    876. 

  876. { VariantSuper, 1, 135, NULL, (void*) &Pick, "#FFBFBF", NULL, Button, N_("Superchess")},
    877. 

  877. { VariantNoCastle, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("no castle")},
    878. 

  878. { VariantCrazyhouse, 1, 135, NULL, (void*) &Pick, "#FFBFBF", NULL, Button, N_("crazyhouse")},
    879. 

  879. { VariantKnightmate, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("knightmate")},
    880. 

  880. { VariantBughouse, 1, 135, NULL, (void*) &Pick, "#FFBFBF", NULL, Button, N_("bughouse")},
    881. 

  881. { VariantBerolina, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("berolina")},
    882. 

  882. { VariantShogi, 1, 135, NULL, (void*) &Pick, "#BFFFFF", NULL, Button, N_("shogi (9x9)")},
    883. 

  883. { VariantCylinder, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("cylinder")},
    884. 

  884. { VariantXiangqi, 1, 135, NULL, (void*) &Pick, "#BFFFFF", NULL, Button, N_("xiangqi (9x10)")},
    885. 

  885. { VariantShatranj, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("shatranj")},
    886. 

  886. { VariantCourier, 1, 135, NULL, (void*) &Pick, "#BFFFBF", NULL, Button, N_("courier (12x8)")},
    887. 

  887. { VariantMakruk, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("makruk")},
    888. 

  888. { VariantGreat, 1, 135, NULL, (void*) &Pick, "#BFBFFF", NULL, Button, N_("Great Shatranj (10x8)")},
    889. 

  889. { VariantAtomic, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("atomic")},
    890. 

  890. { VariantCapablanca, 1, 135, NULL, (void*) &Pick, "#BFBFFF", NULL, Button, N_("Capablanca (10x8)")},
    891. 

  891. { VariantTwoKings, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("two kings")},
    892. 

  892. { VariantGothic, 1, 135, NULL, (void*) &Pick, "#BFBFFF", NULL, Button, N_("Gothic (10x8)")},
    893. 

  893. { Variant3Check, 0, 135, NULL, (void*) &Pick, "#FFFFFF", NULL, Button, N_("3-checks")},
    894. 

  894. { VariantJanus, 1, 135, NULL, (void*) &Pick, "#BFBFFF", NULL, Button, N_("janus (10x8)")},
    895. 

  895. { VariantSuicide, 0, 135, NULL, (void*) &Pick, "#FFFFBF", NULL, Button, N_("suicide")},
    896. 

  896. { VariantCapaRandom, 1, 135, NULL, (void*) &Pick, "#BFBFFF", NULL, Button, N_("CRC (10x8)")},
    897. 

  897. { VariantGiveaway, 0, 135, NULL, (void*) &Pick, "#FFFFBF", NULL, Button, N_("give-away")},
    898. 

  898. { VariantSpartan, 1, 135, NULL, (void*) &Pick, "#FF0000", NULL, Button, N_("Spartan")},
    899. 

  899. { VariantLosers, 0, 135, NULL, (void*) &Pick, "#FFFFBF", NULL, Button, N_("losers")},
    900. 

  900. { 0, 0, 0, NULL, NULL, NULL, NULL, Label, N_("Board size ( -1 = default for selected variant):")},
    901. 

  901. { 0, -1, BOARD_RANKS-1, NULL, (void*) &appData.NrRanks, "", NULL, Spin, N_("Number of Board Ranks:") },
    902. 

  902. { 0, -1, BOARD_FILES, NULL, (void*) &appData.NrFiles, "", NULL, Spin, N_("Number of Board Files:") },
    903. 

  903. { 0, -1, BOARD_RANKS-1, NULL, (void*) &appData.holdingsSize, "", NULL, Spin, N_("Holdings Size:") },
    904. 

  904. { 0, 0, 0, NULL, NULL, NULL, NULL, Label,
    905. 

  905. 				N_("WARNING: variants with un-orthodox\n"
    906. 

  906. 				  "pieces only have built-in bitmaps\n"
    907. 

  907. 				  "for -boardSize middling, bulky and\n"
    908. 

  908. 				  "petite, and substitute king or amazon\n"
    909. 

  909. 				  "for missing bitmaps. (See manual.)")},
    910. 

  910. { 0, 2, 0, NULL, NULL, "", NULL, EndMark , "" }
    911. 

  911. };
    912. 

  912. 

  913. void CommonOptionsOK(int n)
    914. 

  914. {
    915. 

  915. 	int newPonder = appData.ponderNextMove;
    916. 

  916. 	// make sure changes are sent to first engine by re-initializing it
    917. 

  917. 	// if it was already started pre-emptively at end of previous game
    918. 

  918. 	if(gameMode == BeginningOfGame) Reset(True, True); else {
    919. 

  919. 	    // Some changed setting need immediate sending always.
    920. 

  920. 	    if(oldCores != appData.smpCores)
    921. 

  921. 		NewSettingEvent(False, &(first.maxCores), "cores", appData.smpCores);
    922. 

  922. 	    appData.ponderNextMove = oldPonder;
    923. 

  923. 	    PonderNextMoveEvent(newPonder);
    924. 

  924. 	}
    925. 

  925. }
    926. 

  926. 

  927. Option commonEngineOptions[] = {
    928. 

  928. { 0,     0, 0, NULL, (void*) &appData.ponderNextMove, "", NULL, CheckBox, N_("Ponder Next Move") },
    929. 

  929. { 0,  0, 1000, NULL, (void*) &appData.smpCores, "", NULL, Spin, N_("Maximum Number of CPUs per Engine:") },
    930. 

  930. { 0,     0, 0, NULL, (void*) &appData.polyglotDir, "", NULL, PathName, N_("Polygot Directory:") },
    931. 

  931. { 0, 0, 16000, NULL, (void*) &appData.defaultHashSize, "", NULL, Spin, N_("Hash-Table Size (MB):") },
    932. 

  932. { 0,     0, 0, NULL, (void*) &appData.defaultPathEGTB, "", NULL, PathName, N_("Nalimov EGTB Path:") },
    933. 

  933. { 0,  0, 1000, NULL, (void*) &appData.defaultCacheSizeEGTB, "", NULL, Spin, N_("EGTB Cache Size (MB):") },
    934. 

  934. { 0,     0, 0, NULL, (void*) &appData.usePolyglotBook, "", NULL, CheckBox, N_("Use GUI Book") },
    935. 

  935. { 0,     0, 0, NULL, (void*) &appData.polyglotBook, "", NULL, FileName, N_("Opening-Book Filename:") },
    936. 

  936. { 0,   0, 100, NULL, (void*) &appData.bookDepth, "", NULL, Spin, N_("Book Depth (moves):") },
    937. 

  937. { 0,   0, 100, NULL, (void*) &appData.bookStrength, "", NULL, Spin, N_("Book Variety (0) vs. Strength (100):") },
    938. 

  938. { 0,     0, 0, NULL, (void*) &appData.firstHasOwnBookUCI, "", NULL, CheckBox, N_("Engine #1 Has Own Book") },
    939. 

  939. { 0,     0, 0, NULL, (void*) &appData.secondHasOwnBookUCI, "", NULL, CheckBox, N_("Engine #2 Has Own Book          ") },
    940. 

  940. { 0,     1, 0, NULL, (void*) &CommonOptionsOK, "", NULL, EndMark , "" }
    941. 

  941. };
    942. 

  942. 

  943. Option adjudicationOptions[] = {
    944. 

  944. { 0, 0,    0, NULL, (void*) &appData.checkMates, "", NULL, CheckBox, N_("Detect all Mates") },
    945. 

  945. { 0, 0,    0, NULL, (void*) &appData.testClaims, "", NULL, CheckBox, N_("Verify Engine Result Claims") },
    946. 

  946. { 0, 0,    0, NULL, (void*) &appData.materialDraws, "", NULL, CheckBox, N_("Draw if Insufficient Mating Material") },
    947. 

  947. { 0, 0,    0, NULL, (void*) &appData.trivialDraws, "", NULL, CheckBox, N_("Adjudicate Trivial Draws (3-Move Delay)") },
    948. 

  948. { 0, 0,  100, NULL, (void*) &appData.ruleMoves, "", NULL, Spin, N_("N-Move Rule:") },
    949. 

  949. { 0, 0,    6, NULL, (void*) &appData.drawRepeats, "", NULL, Spin, N_("N-fold Repeats:") },
    950. 

  950. { 0, 0, 1000, NULL, (void*) &appData.adjudicateDrawMoves, "", NULL, Spin, N_("Draw after N Moves Total:") },
    951. 

  951. { 0,-5000, 0, NULL, (void*) &appData.adjudicateLossThreshold, "", NULL, Spin, N_("Win / Loss Threshold:") },
    952. 

  952. { 0, 0,    0, NULL, (void*) &first.scoreIsAbsolute, "", NULL, CheckBox, N_("Negate Score of Engine #1") },
    953. 

  953. { 0, 0,    0, NULL, (void*) &second.scoreIsAbsolute, "", NULL, CheckBox, N_("Negate Score of Engine #2") },
    954. 

  954. { 0, 1,    0, NULL, NULL, "", NULL, EndMark , "" }
    955. 

  955. };
    956. 

  956. 

  957. void IcsOptionsOK(int n)
    958. 

  958. {
    959. 

  959.     ParseIcsTextColors();
    960. 

  960. }
    961. 

  961. 

  962. Option icsOptions[] = {
    963. 

  963. { 0, 0, 0, NULL, (void*) &appData.autoKibitz, "",  NULL, CheckBox, N_("Auto-Kibitz") },
    964. 

  964. { 0, 0, 0, NULL, (void*) &appData.autoComment, "", NULL, CheckBox, N_("Auto-Comment") },
    965. 

  965. { 0, 0, 0, NULL, (void*) &appData.autoObserve, "", NULL, CheckBox, N_("Auto-Observe") },
    966. 

  966. { 0, 0, 0, NULL, (void*) &appData.autoRaiseBoard, "", NULL, CheckBox, N_("Auto-Raise Board") },
    967. 

  967. { 0, 0, 0, NULL, (void*) &appData.bgObserve, "",   NULL, CheckBox, N_("Background Observe while Playing") },
    968. 

  968. { 0, 0, 0, NULL, (void*) &appData.dualBoard, "",   NULL, CheckBox, N_("Dual Board for Background-Observed Game") },
    969. 

  969. { 0, 0, 0, NULL, (void*) &appData.getMoveList, "", NULL, CheckBox, N_("Get Move List") },
    970. 

  970. { 0, 0, 0, NULL, (void*) &appData.quietPlay, "",   NULL, CheckBox, N_("Quiet Play") },
    971. 

  971. { 0, 0, 0, NULL, (void*) &appData.seekGraph, "",   NULL, CheckBox, N_("Seek Graph") },
    972. 

  972. { 0, 0, 0, NULL, (void*) &appData.autoRefresh, "", NULL, CheckBox, N_("Auto-Refresh Seek Graph") },
    973. 

  973. { 0, 0, 0, NULL, (void*) &appData.premove, "",     NULL, CheckBox, N_("Premove") },
    974. 

  974. { 0, 0, 0, NULL, (void*) &appData.premoveWhite, "", NULL, CheckBox, N_("Premove for White") },
    975. 

  975. { 0, 0, 0, NULL, (void*) &appData.premoveWhiteText, "", NULL, TextBox, N_("First White Move:") },
    976. 

  976. { 0, 0, 0, NULL, (void*) &appData.premoveBlack, "", NULL, CheckBox, N_("Premove for Black") },
    977. 

  977. { 0, 0, 0, NULL, (void*) &appData.premoveBlackText, "", NULL, TextBox, N_("First Black Move:") },
    978. 

  978. { 0, 0, 0, NULL, NULL, NULL, NULL, Break, "" },
    979. 

  979. { 0, 0, 0, NULL, (void*) &appData.icsAlarm, "", NULL, CheckBox, N_("Alarm") },
    980. 

  980. { 0, 0, 100000000, NULL, (void*) &appData.icsAlarmTime, "", NULL, Spin, N_("Alarm Time (msec):") },
    981. 

  981. //{ 0, 0, 0, NULL, (void*) &appData.chatBoxes, "", NULL, TextBox, N_("Startup Chat Boxes:") },
    982. 

  982. { 0, 0, 0, NULL, (void*) &appData.colorize, "", NULL, CheckBox, N_("Colorize Messages") },
    983. 

  983. { 0, 0, 0, NULL, (void*) &appData.colorShout, "", NULL, TextBox, N_("Shout Text Colors:") },
    984. 

  984. { 0, 0, 0, NULL, (void*) &appData.colorSShout, "", NULL, TextBox, N_("S-Shout Text Colors:") },
    985. 

  985. { 0, 0, 0, NULL, (void*) &appData.colorChannel1, "", NULL, TextBox, N_("Channel #1 Text Colors:") },
    986. 

  986. { 0, 0, 0, NULL, (void*) &appData.colorChannel, "", NULL, TextBox, N_("Other Channel Text Colors:") },
    987. 

  987. { 0, 0, 0, NULL, (void*) &appData.colorKibitz, "", NULL, TextBox, N_("Kibitz Text Colors:") },
    988. 

  988. { 0, 0, 0, NULL, (void*) &appData.colorTell, "", NULL, TextBox, N_("Tell Text Colors:") },
    989. 

  989. { 0, 0, 0, NULL, (void*) &appData.colorChallenge, "", NULL, TextBox, N_("Challenge Text Colors:") },
    990. 

  990. { 0, 0, 0, NULL, (void*) &appData.colorRequest, "", NULL, TextBox, N_("Request Text Colors:") },
    991. 

  991. { 0, 0, 0, NULL, (void*) &appData.colorSeek, "", NULL, TextBox, N_("Seek Text Colors:") },
    992. 

  992. { 0, 0, 0, NULL, (void*) &IcsOptionsOK, "", NULL, EndMark , "" }
    993. 

  993. };
    994. 

  994. 

  995. Option loadOptions[] = {
    996. 

  996. { 0, 0, 0, NULL, (void*) &appData.autoDisplayTags, "", NULL, CheckBox, N_("Auto-Display Tags") },
    997. 

  997. { 0, 0, 0, NULL, (void*) &appData.autoDisplayComment, "", NULL, CheckBox, N_("Auto-Display Comment") },
    998. 

  998. { 0, 0, 0, NULL, NULL, NULL, NULL, Label, N_("Auto-Play speed of loaded games\n(0 = instant, -1 = off):") },
    999. 

  999. { 0, -1, 10000000, NULL, (void*) &appData.timeDelay, "", NULL, Fractional, N_("Seconds per Move:") },
    1000. 

  1000. { 0,  0, 0, NULL, NULL, "", NULL, EndMark , "" }
    1001. 

  1001. };
    1002. 

  1002. 

  1003. Option saveOptions[] = {
    1004. 

  1004. { 0, 0, 0, NULL, (void*) &appData.autoSaveGames, "", NULL, CheckBox, N_("Auto-Save Games") },
    1005. 

  1005. { 0, 0, 0, NULL, (void*) &appData.saveGameFile, "", NULL, FileName,  N_("Save Games on File:") },
    1006. 

  1006. { 0, 0, 0, NULL, (void*) &appData.savePositionFile, "", NULL, FileName,  N_("Save Final Positions on File:") },
    1007. 

  1007. { 0, 0, 0, NULL, (void*) &appData.pgnEventHeader, "", NULL, TextBox,  N_("PGN Event Header:") },
    1008. 

  1008. { 0, 0, 0, NULL, (void*) &appData.oldSaveStyle, "", NULL, CheckBox, N_("Old Save Style (as opposed to PGN)") },
    1009. 

  1009. { 0, 0, 0, NULL, (void*) &appData.saveExtendedInfoInPGN, "", NULL, CheckBox, N_("Save Score/Depth Info in PGN") },
    1010. 

  1010. { 0, 0, 0, NULL, (void*) &appData.saveOutOfBookInfo, "", NULL, CheckBox, N_("Save Out-of-Book Info in PGN           ") },
    1011. 

  1011. { 0, 1, 0, NULL, NULL, "", NULL, EndMark , "" }
    1012. 

  1012. };
    1013. 

  1013. 

  1014. char *soundNames[] = {
    1015. 

  1015. 	N_("No Sound"),
    1016. 

  1016. 	N_("Default Beep"),
    1017. 

  1017. 	N_("Above WAV File"),
    1018. 

  1018. 	N_("Car Horn"),
    1019. 

  1019. 	N_("Cymbal"),
    1020. 

  1020. 	N_("Ding"),
    1021. 

  1021. 	N_("Gong"),
    1022. 

  1022. 	N_("Laser"),
    1023. 

  1023. 	N_("Penalty"),
    1024. 

  1024. 	N_("Phone"),
    1025. 

  1025. 	N_("Pop"),
    1026. 

  1026. 	N_("Slap"),
    1027. 

  1027. 	N_("Wood Thunk"),
    1028. 

  1028. 	NULL,
    1029. 

  1029. 	N_("User File")
    1030. 

  1030. };
    1031. 

  1031. 

  1032. char *soundFiles[] = { // sound files corresponding to above names
    1033. 

  1033. 	"",
    1034. 

  1034. 	"$",
    1035. 

  1035. 	"*", // kludge alert: as first thing in the dialog readout this is replaced with the user-given .WAV filename
    1036. 

  1036. 	"honkhonk.wav",
    1037. 

  1037. 	"cymbal.wav",
    1038. 

  1038. 	"ding1.wav",
    1039. 

  1039. 	"gong.wav",
    1040. 

  1040. 	"laser.wav",
    1041. 

  1041. 	"penalty.wav",
    1042. 

  1042. 	"phone.wav",
    1043. 

  1043. 	"pop2.wav",
    1044. 

  1044. 	"slap.wav",
    1045. 

  1045. 	"woodthunk.wav",
    1046. 

  1046. 	NULL,
    1047. 

  1047. 	NULL
    1048. 

  1048. };
    1049. 

  1049. 

  1050. void Test(int n)
    1051. 

  1051. {
    1052. 

  1052.     GenericReadout(2);
    1053. 

  1053.     if(soundFiles[values[3]]) PlaySound(soundFiles[values[3]]);
    1054. 

  1054. }
    1055. 

  1055. 

  1056. Option soundOptions[] = {
    1057. 

  1057. { 0, 0, 0, NULL, (void*) &appData.soundProgram, "", NULL, TextBox, N_("Sound Program:") },
    1058. 

  1058. { 0, 0, 0, NULL, (void*) &appData.soundDirectory, "", NULL, PathName, N_("Sounds Directory:") },
    1059. 

  1059. { 0, 0, 0, NULL, (void*) (soundFiles+2) /* kludge! */, "", NULL, FileName, N_("User WAV File:") },
    1060. 

  1060. { 0, 0, 0, NULL, (void*) &trialSound, (char*) soundNames, soundFiles, ComboBox, N_("Try-Out Sound:") },
    1061. 

  1061. { 0, 1, 0, NULL, (void*) &Test, NULL, NULL, Button, N_("Play") },
    1062. 

  1062. { 0, 0, 0, NULL, (void*) &appData.soundMove, (char*) soundNames, soundFiles, ComboBox, N_("Move:") },
    1063. 

  1063. { 0, 0, 0, NULL, (void*) &appData.soundIcsWin, (char*) soundNames, soundFiles, ComboBox, N_("Win:") },
    1064. 

  1064. { 0, 0, 0, NULL, (void*) &appData.soundIcsLoss, (char*) soundNames, soundFiles, ComboBox, N_("Lose:") },
    1065. 

  1065. { 0, 0, 0, NULL, (void*) &appData.soundIcsDraw, (char*) soundNames, soundFiles, ComboBox, N_("Draw:") },
    1066. 

  1066. { 0, 0, 0, NULL, (void*) &appData.soundIcsUnfinished, (char*) soundNames, soundFiles, ComboBox, N_("Unfinished:") },
    1067. 

  1067. { 0, 0, 0, NULL, (void*) &appData.soundIcsAlarm, (char*) soundNames, soundFiles, ComboBox, N_("Alarm:") },
    1068. 

  1068. { 0, 0, 0, NULL, (void*) &appData.soundShout, (char*) soundNames, soundFiles, ComboBox, N_("Shout:") },
    1069. 

  1069. { 0, 0, 0, NULL, (void*) &appData.soundSShout, (char*) soundNames, soundFiles, ComboBox, N_("S-Shout:") },
    1070. 

  1070. { 0, 0, 0, NULL, (void*) &appData.soundChannel, (char*) soundNames, soundFiles, ComboBox, N_("Channel:") },
    1071. 

  1071. { 0, 0, 0, NULL, (void*) &appData.soundChannel1, (char*) soundNames, soundFiles, ComboBox, N_("Channel 1:") },
    1072. 

  1072. { 0, 0, 0, NULL, (void*) &appData.soundTell, (char*) soundNames, soundFiles, ComboBox, N_("Tell:") },
    1073. 

  1073. { 0, 0, 0, NULL, (void*) &appData.soundKibitz, (char*) soundNames, soundFiles, ComboBox, N_("Kibitz:") },
    1074. 

  1074. { 0, 0, 0, NULL, (void*) &appData.soundChallenge, (char*) soundNames, soundFiles, ComboBox, N_("Challenge:") },
    1075. 

  1075. { 0, 0, 0, NULL, (void*) &appData.soundRequest, (char*) soundNames, soundFiles, ComboBox, N_("Request:") },
    1076. 

  1076. { 0, 0, 0, NULL, (void*) &appData.soundSeek, (char*) soundNames, soundFiles, ComboBox, N_("Seek:") },
    1077. 

  1077. { 0, 1, 0, NULL, NULL, "", NULL, EndMark , "" }
    1078. 

  1078. };
    1079. 

  1079. 

  1080. void SetColor(char *colorName, Widget box)
    1081. 

  1081. {
    1082. 

  1082. 	Arg args[5];
    1083. 

  1083. 	Pixel buttonColor;
    1084. 

  1084. 	XrmValue vFrom, vTo;
    1085. 

  1085. 	if (!appData.monoMode) {
    1086. 

  1086. 	    vFrom.addr = (caddr_t) colorName;
    1087. 

  1087. 	    vFrom.size = strlen(colorName);
    1088. 

  1088. 	    XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
    1089. 

  1089. 	    if (vTo.addr == NULL) {
    1090. 

  1090. 	  	buttonColor = (Pixel) -1;
    1091. 

  1091. 	    } else {
    1092. 

  1092. 		buttonColor = *(Pixel *) vTo.addr;
    1093. 

  1093. 	    }
    1094. 

  1094. 	}
    1095. 

  1095. 	XtSetArg(args[0], XtNbackground, buttonColor);;
    1096. 

  1096. 	XtSetValues(box, args, 1);
    1097. 

  1097. }
    1098. 

  1098. 

  1099. void SetColorText(int n, char *buf)
    1100. 

  1100. {
    1101. 

  1101.     Arg args[5];
    1102. 

  1102.     XtSetArg(args[0], XtNstring, buf);
    1103. 

  1103.     XtSetValues(currentOption[n-1].handle, args, 1);
    1104. 

  1104.     SetFocus(currentOption[n-1].handle, shells[0], NULL, False);
    1105. 

  1105.     SetColor(buf, currentOption[n].handle);
    1106. 

  1106. }
    1107. 

  1107. 

  1108. void DefColor(int n)
    1109. 

  1109. {
    1110. 

  1110.     SetColorText(n, (char*) currentOption[n].choice);
    1111. 

  1111. }
    1112. 

  1112. 

  1113. void RefreshColor(int source, int n)
    1114. 

  1114. {
    1115. 

  1115.     int col, j, r, g, b, step = 10;
    1116. 

  1116.     char *s, buf[MSG_SIZ]; // color string
    1117. 

  1117.     Arg args[5];
    1118. 

  1118.     XtSetArg(args[0], XtNstring, &s);
    1119. 

  1119.     XtGetValues(currentOption[source].handle, args, 1);
    1120. 

  1120.     if(sscanf(s, "#%x", &col) != 1) return;   // malformed
    1121. 

  1121.     b = col & 0xFF; g = col & 0xFF00; r = col & 0xFF0000;
    1122. 

  1122.     switch(n) {
    1123. 

  1123. 	case 1: r += 0x10000*step;break;
    1124. 

  1124. 	case 2: g += 0x100*step;  break;
    1125. 

  1125. 	case 3: b += step;        break;
    1126. 

  1126. 	case 4: r -= 0x10000*step; g -= 0x100*step; b -= step; break;
    1127. 

  1127.     }
    1128. 

  1128.     if(r < 0) r = 0; if(g < 0) g = 0; if(b < 0) b = 0;
    1129. 

  1129.     if(r > 0xFF0000) r = 0xFF0000; if(g > 0xFF00) g = 0xFF00; if(b > 0xFF) b = 0xFF;
    1130. 

  1130.     col = r | g | b;
    1131. 

  1131.     snprintf(buf, MSG_SIZ, "#%06x", col);
    1132. 

  1132.     for(j=1; j<7; j++) if(buf[j] >= 'a') buf[j] -= 32; // capitalize
    1133. 

  1133.     SetColorText(source+1, buf);
    1134. 

  1134. }
    1135. 

  1135. 

  1136. void ColorChanged(Widget w, XtPointer data, XEvent *event, Boolean *b)
    1137. 

  1137. {
    1138. 

  1138.     char buf[10];
    1139. 

  1139.     if ( (XLookupString(&(event->xkey), buf, 2, NULL, NULL) == 1) && *buf == '\r' )
    1140. 

  1140. 	RefreshColor((int)(intptr_t) data, 0);
    1141. 

  1141. }
    1142. 

  1142. 

  1143. void AdjustColor(int i)
    1144. 

  1144. {
    1145. 

  1145.     int n = currentOption[i].value;
    1146. 

  1146.     RefreshColor(i-n-1, n);
    1147. 

  1147. }
    1148. 

  1148. 

  1149. void BoardOptionsOK(int n)
    1150. 

  1150. {
    1151. 

  1151.     extern int defaultLineGap, useImages, useImageSqs;
    1152. 

  1152.     if(appData.overrideLineGap >= 0) lineGap = appData.overrideLineGap; else lineGap = defaultLineGap;
    1153. 

  1153.     useImages = useImageSqs = 0;
    1154. 

  1154.     MakeColors(); CreateGCs(True);
    1155. 

  1155.     CreateAnyPieces();
    1156. 

  1156.     InitDrawingSizes(-1, 0);
    1157. 

  1157.     DrawPosition(True, NULL);
    1158. 

  1158. }
    1159. 

  1159. 

  1160. Option boardOptions[] = {
    1161. 

  1161. { 0,   0, 70, NULL, (void*) &appData.whitePieceColor, "", NULL, TextBox, N_("White Piece Color:") },
    1162. 

  1162. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#FFFFCC", Button, "      " },
    1163. 

  1163. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1164. 

  1164. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1165. 

  1165. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1166. 

  1166. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1167. 

  1167. { 0,   0, 70, NULL, (void*) &appData.blackPieceColor, "", NULL, TextBox, N_("Black Piece Color:") },
    1168. 

  1168. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#202020", Button, "      " },
    1169. 

  1169. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1170. 

  1170. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1171. 

  1171. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1172. 

  1172. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1173. 

  1173. { 0,   0, 70, NULL, (void*) &appData.lightSquareColor, "", NULL, TextBox, N_("Light Square Color:") },
    1174. 

  1174. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#C8C365", Button, "      " },
    1175. 

  1175. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1176. 

  1176. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1177. 

  1177. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1178. 

  1178. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1179. 

  1179. { 0,   0, 70, NULL, (void*) &appData.darkSquareColor, "", NULL, TextBox, N_("Dark Square Color:") },
    1180. 

  1180. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#77A26D", Button, "      " },
    1181. 

  1181. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1182. 

  1182. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1183. 

  1183. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1184. 

  1184. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1185. 

  1185. { 0,   0, 70, NULL, (void*) &appData.highlightSquareColor, "", NULL, TextBox, N_("Highlight Color:") },
    1186. 

  1186. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#FFFF00", Button, "      " },
    1187. 

  1187. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1188. 

  1188. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1189. 

  1189. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1190. 

  1190. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1191. 

  1191. { 0,   0, 70, NULL, (void*) &appData.premoveHighlightColor, "", NULL, TextBox, N_("Premove Highlight Color:") },
    1192. 

  1192. { 1000, 1, 0, NULL, (void*) &DefColor, NULL, (char**) "#FF0000", Button, "      " },
    1193. 

  1193. {    1, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "R" },
    1194. 

  1194. {    2, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "G" },
    1195. 

  1195. {    3, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "B" },
    1196. 

  1196. {    4, 1, 0, NULL, (void*) &AdjustColor, NULL, NULL, Button, "D" },
    1197. 

  1197. { 0, 0, 0, NULL, (void*) &appData.upsideDown, "", NULL, CheckBox, N_("Flip Pieces Shogi Style        (Colored buttons restore default)") },
    1198. 

  1198. //{ 0, 0, 0, NULL, (void*) &appData.allWhite, "", NULL, CheckBox, N_("Use Outline Pieces for Black") },
    1199. 

  1199. { 0, 0, 0, NULL, (void*) &appData.monoMode, "", NULL, CheckBox, N_("Mono Mode") },
    1200. 

  1200. { 0,-1, 5, NULL, (void*) &appData.overrideLineGap, "", NULL, Spin, N_("Line Gap ( -1 = default for board size):") },
    1201. 

  1201. { 0, 0, 0, NULL, (void*) &appData.liteBackTextureFile, "", NULL, FileName, N_("Light-Squares Texture File:") },
    1202. 

  1202. { 0, 0, 0, NULL, (void*) &appData.darkBackTextureFile, "", NULL, FileName, N_("Dark-Squares Texture File:") },
    1203. 

  1203. { 0, 0, 0, NULL, (void*) &appData.bitmapDirectory, "", NULL, PathName, N_("Directory with Bitmap Pieces:") },
    1204. 

  1204. { 0, 0, 0, NULL, (void*) &appData.pixmapDirectory, "", NULL, PathName, N_("Directory with Pixmap Pieces:") },
    1205. 

  1205. { 0, 0, 0, NULL, (void*) &BoardOptionsOK, "", NULL, EndMark , "" }
    1206. 

  1206. };
    1207. 

  1207. 

  1208. void GenericReadout(int selected)
    1209. 

  1209. {
    1210. 

  1210.     int i, j;
    1211. 

  1211.     String name, val;
    1212. 

  1212.     Arg args[16];
    1213. 

  1213.     char buf[MSG_SIZ], **dest;
    1214. 

  1214.     float x;
    1215. 

  1215. 	for(i=0; ; i++) { // send all options that had to be OK-ed to engine
    1216. 

  1216. 	    if(selected >= 0) { if(i < selected) continue; else if(i > selected) break; }
    1217. 

  1217. 	    switch(currentOption[i].type) {
    1218. 

  1218. 		case TextBox:
    1219. 

  1219. 		case FileName:
    1220. 

  1220. 		case PathName:
    1221. 

  1221. 		    XtSetArg(args[0], XtNstring, &val);
    1222. 

  1222. 		    XtGetValues(currentOption[i].handle, args, 1);
    1223. 

  1223. 		    dest = currentCps ? &(currentOption[i].textValue) : (char**) currentOption[i].target;
    1224. 

  1224. 		    if(*dest == NULL || strcmp(*dest, val)) {
    1225. 

  1225. 			if(currentCps) {
    1226. 

  1226. 			    snprintf(buf, MSG_SIZ,  "option %s=%s\n", currentOption[i].name, val);
    1227. 

  1227. 			    SendToProgram(buf, currentCps);
    1228. 

  1228. 			} else *dest = currentOption[i].name + 100; // option gets to point to private storage;
    1229. 

  1229. 			safeStrCpy(*dest, val, MSG_SIZ - (*dest - currentOption[i].name)); // copy text there
    1230. 

  1230. 		    }
    1231. 

  1231. 		    break;
    1232. 

  1232. 		case Spin:
    1233. 

  1233. 		case Fractional:
    1234. 

  1234. 		    XtSetArg(args[0], XtNstring, &val);
    1235. 

  1235. 		    XtGetValues(currentOption[i].handle, args, 1);
    1236. 

  1236. 		    sscanf(val, "%f", &x);
    1237. 

  1237. 		    if(x > currentOption[i].max) x = currentOption[i].max;
    1238. 

  1238. 		    if(x < currentOption[i].min) x = currentOption[i].min;
    1239. 

  1239. 		    if(currentOption[i].type == Fractional)
    1240. 

  1240. 			*(float*) currentOption[i].target = x; // engines never have float options!
    1241. 

  1241. 		    else if(currentOption[i].value != x) {
    1242. 

  1242. 			currentOption[i].value = x;
    1243. 

  1243. 			if(currentCps) {
    1244. 

  1244. 			    snprintf(buf, MSG_SIZ,  "option %s=%.0f\n", currentOption[i].name, x);
    1245. 

  1245. 			    SendToProgram(buf, currentCps);
    1246. 

  1246. 			} else *(int*) currentOption[i].target = x;
    1247. 

  1247. 		    }
    1248. 

  1248. 		    break;
    1249. 

  1249. 		case CheckBox:
    1250. 

  1250. 		    j = 0;
    1251. 

  1251. 		    XtSetArg(args[0], XtNstate, &j);
    1252. 

  1252. 		    XtGetValues(currentOption[i].handle, args, 1);
    1253. 

  1253. 		    if(currentOption[i].value != j) {
    1254. 

  1254. 			currentOption[i].value = j;
    1255. 

  1255. 			if(currentCps) {
    1256. 

  1256. 			    snprintf(buf, MSG_SIZ,  "option %s=%d\n", currentOption[i].name, j);
    1257. 

  1257. 			    SendToProgram(buf, currentCps);
    1258. 

  1258. 			} else *(Boolean*) currentOption[i].target = j;
    1259. 

  1259. 		    }
    1260. 

  1260. 		    break;
    1261. 

  1261. 		case ComboBox:
    1262. 

  1262. 		    val = ((char**)currentOption[i].choice)[values[i]];
    1263. 

  1263. 		    if(currentCps) {
    1264. 

  1264. 			if(currentOption[i].value == values[i]) break; // not changed
    1265. 

  1265. 			currentOption[i].value = values[i];
    1266. 

  1266. 			snprintf(buf, MSG_SIZ,  "option %s=%s\n", currentOption[i].name,
    1267. 

  1267. 				((char**)currentOption[i].textValue)[values[i]]);
    1268. 

  1268. 			SendToProgram(buf, currentCps);
    1269. 

  1269. 		    } else if(val && (*(char**) currentOption[i].target == NULL || strcmp(*(char**) currentOption[i].target, val))) {
    1270. 

  1270. 		      if(*(char**) currentOption[i].target) free(*(char**) currentOption[i].target);
    1271. 

  1271. 		      *(char**) currentOption[i].target = strdup(val);
    1272. 

  1272. 		    }
    1273. 

  1273. 		    break;
    1274. 

  1274. 		case EndMark:
    1275. 

  1275. 		    if(currentOption[i].target) // callback for implementing necessary actions on OK (like redraw)
    1276. 

  1276. 			((ButtonCallback*) currentOption[i].target)(i);
    1277. 

  1277. 		    break;
    1278. 

  1278. 	    default:
    1279. 

  1279. 		printf("GenericReadout: unexpected case in switch.\n");
    1280. 

  1280. 		case Button:
    1281. 

  1281. 		case SaveButton:
    1282. 

  1282. 		case Label:
    1283. 

  1283. 		case Break:
    1284. 

  1284. 	      break;
    1285. 

  1285. 	    }
    1286. 

  1286. 	    if(currentOption[i].type == EndMark) break;
    1287. 

  1287. 	}
    1288. 

  1288. }
    1289. 

  1289. 

  1290. void GenericCallback(w, client_data, call_data)
    1291. 

  1291.      Widget w;
    1292. 

  1292.      XtPointer client_data, call_data;
    1293. 

  1293. {
    1294. 

  1294.     String name, val;
    1295. 

  1295.     Arg args[16];
    1296. 

  1296.     char buf[MSG_SIZ];
    1297. 

  1297.     int i, j;
    1298. 

  1298.     int data = (intptr_t) client_data;
    1299. 

  1299. 

  1300.     currentOption = dialogOptions[data>>16]; data &= 0xFFFF;
    1301. 

  1301. 

  1302.     XtSetArg(args[0], XtNlabel, &name);
    1303. 

  1303.     XtGetValues(w, args, 1);
    1304. 

  1304. 

  1305.     if (strcmp(name, _("cancel")) == 0) {
    1306. 

  1306.         PopDown(data);
    1307. 

  1307.         return;
    1308. 

  1308.     }
    1309. 

  1309.     if (strcmp(name, _("OK")) == 0) { // save buttons imply OK
    1310. 

  1310.         GenericReadout(-1);
    1311. 

  1311.         PopDown(data);
    1312. 

  1312.         return;
    1313. 

  1313.     }
    1314. 

  1314.     if(currentCps) {
    1315. 

  1315. 	if(currentOption[data].type == SaveButton) GenericReadout(-1);
    1316. 

  1316. 	snprintf(buf, MSG_SIZ,  "option %s\n", name);
    1317. 

  1317. 	SendToProgram(buf, currentCps);
    1318. 

  1318.     } else ((ButtonCallback*) currentOption[data].target)(data);
    1319. 

  1319. }
    1320. 

  1320. 

  1321. static char *oneLiner  = "<Key>Return:	redraw-display()\n";
    1322. 

  1322. 

  1323. int
    1324. 

  1324. GenericPopUp(Option *option, char *title, int dlgNr)
    1325. 

  1325. {
    1326. 

  1326.     Arg args[16];
    1327. 

  1327.     Widget popup, layout, dialog, edit=NULL, form,  last, b_ok, b_cancel, leftMargin = NULL, textField = NULL;
    1328. 

  1328.     Window root, child;
    1329. 

  1329.     int x, y, i, j, height=999, width=1, h, c, w;
    1330. 

  1330.     int win_x, win_y, maxWidth, maxTextWidth;
    1331. 

  1331.     unsigned int mask;
    1332. 

  1332.     char def[MSG_SIZ], *msg;
    1333. 

  1333.     static char pane[6] = "paneX";
    1334. 

  1334.     Widget texts[100], forelast = NULL, anchor, widest, lastrow = NULL;
    1335. 

  1335. 

  1336.     if(shellUp[dlgNr]) return 0; // already up
    1337. 

  1337.     if(dlgNr && shells[dlgNr]) {
    1338. 

  1338. 	XtPopup(shells[dlgNr], XtGrabNone);
    1339. 

  1339. 	shellUp[dlgNr] = True;
    1340. 

  1340. 	return 0;
    1341. 

  1341.     }
    1342. 

  1342. 

  1343.     dialogOptions[dlgNr] = option; // make available to callback
    1344. 

  1344.     // post currentOption globally, so Spin and Combo callbacks can already use it
    1345. 

  1345.     // WARNING: this kludge does not work for persistent dialogs, so that these cannot have spin or combo controls!
    1346. 

  1346.     currentOption = option;
    1347. 

  1347. 

  1348.     if(currentCps) { // Settings popup for engine: format through heuristic
    1349. 

  1349. 	int n = currentCps->nrOptions;
    1350. 

  1350. 	if(n > 50) width = 4; else if(n>24) width = 2; else width = 1;
    1351. 

  1351. 	height = n / width + 1;
    1352. 

  1352. 	if(currentOption[n-1].type == Button || currentOption[n-1].type == SaveButton) currentOption[n].min = 1; // OK on same line
    1353. 

  1353. 	currentOption[n].type = EndMark; currentOption[n].target = NULL; // delimit list by callback-less end mark
    1354. 

  1354.     }
    1355. 

  1355.      i = 0;
    1356. 

  1356.     XtSetArg(args[i], XtNresizable, True); i++;
    1357. 

  1357.     popup = shells[dlgNr] =
    1358. 

  1358.       XtCreatePopupShell(title, transientShellWidgetClass,
    1359. 

  1359. 			 shellWidget, args, i);
    1360. 

  1360. 

  1361.     layout =
    1362. 

  1362.       XtCreateManagedWidget(layoutName, formWidgetClass, popup,
    1363. 

  1363. 			    layoutArgs, XtNumber(layoutArgs));
    1364. 

  1364.   for(c=0; c<width; c++) {
    1365. 

  1365.     pane[4] = 'A'+c;
    1366. 

  1366.     form =
    1367. 

  1367.       XtCreateManagedWidget(pane, formWidgetClass, layout,
    1368. 

  1368. 			    formArgs, XtNumber(formArgs));
    1369. 

  1369.     j=0;
    1370. 

  1370.     XtSetArg(args[j], XtNfromHoriz, leftMargin);  j++;
    1371. 

  1371.     XtSetValues(form, args, j);
    1372. 

  1372.     leftMargin = form;
    1373. 

  1373. 

  1374.     last = widest = NULL; anchor = lastrow;
    1375. 

  1375.     for(h=0; h<height; h++) {
    1376. 

  1376. 	i = h + c*height;
    1377. 

  1377. 	if(option[i].type == EndMark) break;
    1378. 

  1378. 	lastrow = forelast;
    1379. 

  1379. 	forelast = last;
    1380. 

  1380. 	switch(option[i].type) {
    1381. 

  1381. 	  case Fractional:
    1382. 

  1382. 	    snprintf(def, MSG_SIZ,  "%.2f", *(float*)option[i].target);
    1383. 

  1383. 	    option[i].value = *(float*)option[i].target;
    1384. 

  1384. 	    goto tBox;
    1385. 

  1385. 	  case Spin:
    1386. 

  1386. 	    if(!currentCps) option[i].value = *(int*)option[i].target;
    1387. 

  1387. 	    snprintf(def, MSG_SIZ,  "%d", option[i].value);
    1388. 

  1388. 	  case TextBox:
    1389. 

  1389. 	  case FileName:
    1390. 

  1390. 	  case PathName:
    1391. 

  1391.           tBox:
    1392. 

  1392. 	    if(option[i].name[0]) {
    1393. 

  1393. 	    j=0;
    1394. 

  1394. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1395. 

  1395. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1396. 

  1396. 	    XtSetArg(args[j], XtNright, XtChainLeft); j++;
    1397. 

  1397. 	    XtSetArg(args[j], XtNborderWidth, 0);  j++;
    1398. 

  1398. 	    XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
    1399. 

  1399. 	    texts[h] =
    1400. 

  1400. 	    dialog = XtCreateManagedWidget(option[i].name, labelWidgetClass, form, args, j);
    1401. 

  1401. 	    } else texts[h] = dialog = NULL;
    1402. 

  1402. 	    w = option[i].type == Spin || option[i].type == Fractional ? 70 : option[i].max ? option[i].max : 205;
    1403. 

  1403. 	    if(option[i].type == FileName || option[i].type == PathName) w -= 55;
    1404. 

  1404. 	    j=0;
    1405. 

  1405. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1406. 

  1406. 	    XtSetArg(args[j], XtNfromHoriz, dialog);  j++;
    1407. 

  1407. 	    XtSetArg(args[j], XtNborderWidth, 1); j++;
    1408. 

  1408. 	    XtSetArg(args[j], XtNwidth, w); j++;
    1409. 

  1409. 	    if(option[i].type == TextBox && option[i].min) {
    1410. 

  1410. 		XtSetArg(args[j], XtNheight, option[i].min); j++;
    1411. 

  1411. 		if(option[i].value & 1) { XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways);  j++; }
    1412. 

  1412. 		if(option[i].value & 2) { XtSetArg(args[j], XtNscrollHorizontal, XawtextScrollAlways);  j++; }
    1413. 

  1413. 		if(option[i].value & 4) { XtSetArg(args[j], XtNautoFill, True);  j++; }
    1414. 

  1414. 		if(option[i].value & 8) { XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++; }
    1415. 

  1415. 	    }
    1416. 

  1416. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1417. 

  1417. 	    XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
    1418. 

  1418. 	    XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
    1419. 

  1419. 	    XtSetArg(args[j], XtNdisplayCaret, False);  j++;
    1420. 

  1420. 	    XtSetArg(args[j], XtNright, XtChainRight);  j++;
    1421. 

  1421. 	    XtSetArg(args[j], XtNresizable, True);  j++;
    1422. 

  1422. 	    XtSetArg(args[j], XtNinsertPosition, 9999);  j++;
    1423. 

  1423. 	    XtSetArg(args[j], XtNstring, option[i].type==Spin || option[i].type==Fractional ? def : 
    1424. 

  1424. 				currentCps ? option[i].textValue : *(char**)option[i].target);  j++;
    1425. 

  1425. 	    edit = last;
    1426. 

  1426. 	    option[i].handle = (void*)
    1427. 

  1427. 		(textField = last = XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j));
    1428. 

  1428. 	    XtAddEventHandler(last, ButtonPressMask, False, SetFocus, (XtPointer) popup);
    1429. 

  1429. 	    if(option[i].min == 0 || option[i].type != TextBox)
    1430. 

  1430. 		XtOverrideTranslations(last, XtParseTranslationTable(oneLiner));
    1431. 

  1431. 

  1432. 	    if(option[i].type == TextBox || option[i].type == Fractional) break;
    1433. 

  1433. 

  1434. 	    // add increment and decrement controls for spin
    1435. 

  1435. 	    j=0;
    1436. 

  1436. 	    XtSetArg(args[j], XtNfromVert, edit);  j++;
    1437. 

  1437. 	    XtSetArg(args[j], XtNfromHoriz, last);  j++;
    1438. 

  1438. 	    XtSetArg(args[j], XtNleft, XtChainRight); j++;
    1439. 

  1439. 	    XtSetArg(args[j], XtNright, XtChainRight); j++;
    1440. 

  1440. 	    if(option[i].type == FileName || option[i].type == PathName) {
    1441. 

  1441. 		w = 50; msg = "browse";
    1442. 

  1442. 	    } else {
    1443. 

  1443. 		XtSetArg(args[j], XtNheight, 10);  j++;
    1444. 

  1444. 		w = 20; msg = "+";
    1445. 

  1445. 	    }
    1446. 

  1446. 	    XtSetArg(args[j], XtNwidth, w);  j++;
    1447. 

  1447. 	    edit = XtCreateManagedWidget(msg, commandWidgetClass, form, args, j);
    1448. 

  1448. 	    XtAddCallback(edit, XtNcallback, SpinCallback, (XtPointer)(intptr_t) i);
    1449. 

  1449. 

  1450. 	    if(option[i].type != Spin) break;
    1451. 

  1451. 

  1452. 	    j=0;
    1453. 

  1453. 	    XtSetArg(args[j], XtNfromVert, edit);  j++;
    1454. 

  1454. 	    XtSetArg(args[j], XtNfromHoriz, last);  j++;
    1455. 

  1455. 	    XtSetArg(args[j], XtNheight, 10);  j++;
    1456. 

  1456. 	    XtSetArg(args[j], XtNwidth, 20);  j++;
    1457. 

  1457. 	    XtSetArg(args[j], XtNleft, XtChainRight); j++;
    1458. 

  1458. 	    XtSetArg(args[j], XtNright, XtChainRight); j++;
    1459. 

  1459. 	    last = XtCreateManagedWidget("-", commandWidgetClass, form, args, j);
    1460. 

  1460. 	    XtAddCallback(last, XtNcallback, SpinCallback, (XtPointer)(intptr_t) i);
    1461. 

  1461. 	    break;
    1462. 

  1462. 	  case CheckBox:
    1463. 

  1463. 	    if(!currentCps) option[i].value = *(Boolean*)option[i].target;
    1464. 

  1464. 	    j=0;
    1465. 

  1465. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1466. 

  1466. 	    XtSetArg(args[j], XtNwidth, 10);  j++;
    1467. 

  1467. 	    XtSetArg(args[j], XtNheight, 10);  j++;
    1468. 

  1468. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1469. 

  1469. 	    XtSetArg(args[j], XtNright, XtChainLeft); j++;
    1470. 

  1470. 	    XtSetArg(args[j], XtNstate, option[i].value);  j++;
    1471. 

  1471. 	    option[i].handle = (void*)
    1472. 

  1472. 		(dialog = XtCreateManagedWidget(" ", toggleWidgetClass, form, args, j));
    1473. 

  1473. 	  case Label:
    1474. 

  1474. 	    msg = option[i].name;
    1475. 

  1475. 	    if(*msg == NULLCHAR) msg = option[i].textValue;
    1476. 

  1476. 	    if(!msg) break;
    1477. 

  1477. 	    j=0;
    1478. 

  1478. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1479. 

  1479. 	    XtSetArg(args[j], XtNfromHoriz, option[i].type != Label ? dialog : NULL);  j++;
    1480. 

  1480. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1481. 

  1481. 	    XtSetArg(args[j], XtNborderWidth, 0);  j++;
    1482. 

  1482. 	    XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
    1483. 

  1483. 	    last = XtCreateManagedWidget(msg, labelWidgetClass, form, args, j);
    1484. 

  1484. 	    if(option[i].type == CheckBox)
    1485. 

  1485. 		XtAddEventHandler(last, ButtonPressMask, False, CheckCallback, (XtPointer)(intptr_t) i);
    1486. 

  1486. 	    break;
    1487. 

  1487. 	  case SaveButton:
    1488. 

  1488. 	  case Button:
    1489. 

  1489. 	    j=0;
    1490. 

  1490. 	    XtSetArg(args[j], XtNfromVert, option[i].min & 1 ? lastrow : last);  j++;
    1491. 

  1491. 	    if(option[i].min & 1) { XtSetArg(args[j], XtNfromHoriz, last);  j++; }
    1492. 

  1492. 	    else  { XtSetArg(args[j], XtNfromHoriz, NULL);  j++; lastrow = forelast; }
    1493. 

  1493. 	    if(option[i].max) XtSetArg(args[j], XtNwidth, option[i].max);  j++;
    1494. 

  1494. 	    if(option[i].textValue) { // special for buttons of New Variant dialog
    1495. 

  1495. 		XtSetArg(args[j], XtNsensitive, appData.noChessProgram || option[i].value < 0
    1496. 

  1496. 					 || strstr(first.variants, VariantName(option[i].value))); j++;
    1497. 

  1497. 		XtSetArg(args[j], XtNborderWidth, (gameInfo.variant == option[i].value)+1); j++;
    1498. 

  1498. 	    }
    1499. 

  1499. 	    option[i].handle = (void*)
    1500. 

  1500. 		(dialog = last = XtCreateManagedWidget(option[i].name, commandWidgetClass, form, args, j));
    1501. 

  1501. 	    if(option[i].choice && ((char*)option[i].choice)[0] == '#' && !currentCps) {
    1502. 

  1502. 		SetColor( *(char**) option[i-1].target, last);
    1503. 

  1503. 		XtAddEventHandler(option[i-1].handle, KeyReleaseMask, False, ColorChanged, (XtPointer)(intptr_t) i-1);
    1504. 

  1504. 	    }
    1505. 

  1505. 	    XtAddCallback(last, XtNcallback, GenericCallback,
    1506. 

  1506. 			  (XtPointer)(intptr_t) i + (dlgNr<<16));
    1507. 

  1507. 	    if(option[i].textValue) SetColor( option[i].textValue, last);
    1508. 

  1508. 	    forelast = lastrow; // next button can go on same row
    1509. 

  1509. 	    break;
    1510. 

  1510. 	  case ComboBox:
    1511. 

  1511. 	    j=0;
    1512. 

  1512. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1513. 

  1513. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1514. 

  1514. 	    XtSetArg(args[j], XtNright, XtChainLeft); j++;
    1515. 

  1515. 	    XtSetArg(args[j], XtNborderWidth, 0);  j++;
    1516. 

  1516. 	    XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
    1517. 

  1517. 	    texts[h] = dialog = XtCreateManagedWidget(option[i].name, labelWidgetClass, form, args, j);
    1518. 

  1518. 

  1519. 	    if(currentCps) option[i].choice = (char**) option[i].textValue; else {
    1520. 

  1520. 	      for(j=0; option[i].choice[j]; j++)
    1521. 

  1521. 		if(*(char**)option[i].target && !strcmp(*(char**)option[i].target, option[i].choice[j])) break;
    1522. 

  1522. 	      option[i].value = j + (option[i].choice[j] == NULL);
    1523. 

  1523. 	    }
    1524. 

  1524. 

  1525. 	    j=0;
    1526. 

  1526. 	    XtSetArg(args[j], XtNfromVert, last);  j++;
    1527. 

  1527. 	    XtSetArg(args[j], XtNfromHoriz, dialog);  j++;
    1528. 

  1528. 	    XtSetArg(args[j], XtNwidth, option[i].max && !currentCps ? option[i].max : 100);  j++;
    1529. 

  1529. 	    XtSetArg(args[j], XtNleft, XtChainLeft); j++;
    1530. 

  1530. 	    XtSetArg(args[j], XtNmenuName, XtNewString(option[i].name));  j++;
    1531. 

  1531. 	    XtSetArg(args[j], XtNlabel, ((char**)option[i].textValue)[option[i].value]);  j++;
    1532. 

  1532. 	    option[i].handle = (void*)
    1533. 

  1533. 		(last = XtCreateManagedWidget(" ", menuButtonWidgetClass, form, args, j));
    1534. 

  1534. 	    CreateComboPopup(last, option[i].name, i, (char **) option[i].textValue);
    1535. 

  1535. 	    values[i] = option[i].value;
    1536. 

  1536. 	    break;
    1537. 

  1537. 	  case Break:
    1538. 

  1538. 	    width++;
    1539. 

  1539. 	    height = i+1;
    1540. 

  1540. 	    break;
    1541. 

  1541. 	default:
    1542. 

  1542. 	    printf("GenericPopUp: unexpected case in switch.\n");
    1543. 

  1543. 	    break;
    1544. 

  1544. 	}
    1545. 

  1545.     }
    1546. 

  1546. 

  1547.     // make an attempt to align all spins and textbox controls
    1548. 

  1548.     maxWidth = maxTextWidth = 0;
    1549. 

  1549.     for(h=0; h<height; h++) {
    1550. 

  1550. 	i = h + c*height;
    1551. 

  1551. 	if(option[i].type == EndMark) break;
    1552. 

  1552. 	if(option[i].type == Spin || option[i].type == TextBox || option[i].type == ComboBox
    1553. 

  1553. 				  || option[i].type == PathName || option[i].type == FileName) {
    1554. 

  1554. 	    Dimension w;
    1555. 

  1555. 	    if(!texts[h]) continue;
    1556. 

  1556. 	    j=0;
    1557. 

  1557. 	    XtSetArg(args[j], XtNwidth, &w);  j++;
    1558. 

  1558. 	    XtGetValues(texts[h], args, j);
    1559. 

  1559. 	    if(option[i].type == Spin) {
    1560. 

  1560. 		if(w > maxWidth) maxWidth = w;
    1561. 

  1561. 		widest = texts[h];
    1562. 

  1562. 	    } else {
    1563. 

  1563. 		if(w > maxTextWidth) maxTextWidth = w;
    1564. 

  1564. 		if(!widest) widest = texts[h];
    1565. 

  1565. 	    }
    1566. 

  1566. 	}
    1567. 

  1567.     }
    1568. 

  1568.     if(maxTextWidth + 110 < maxWidth)
    1569. 

  1569. 	 maxTextWidth = maxWidth - 110;
    1570. 

  1570.     else maxWidth = maxTextWidth + 110;
    1571. 

  1571.     for(h=0; h<height; h++) {
    1572. 

  1572. 	i = h + c*height;
    1573. 

  1573. 	if(option[i].type == EndMark) break;
    1574. 

  1574. 	if(!texts[h]) continue;
    1575. 

  1575. 	j=0;
    1576. 

  1576. 	if(option[i].type == Spin) {
    1577. 

  1577. 	    XtSetArg(args[j], XtNwidth, maxWidth);  j++;
    1578. 

  1578. 	    XtSetValues(texts[h], args, j);
    1579. 

  1579. 	} else
    1580. 

  1580. 	if(option[i].type == TextBox || option[i].type == ComboBox || option[i].type == PathName || option[i].type == FileName) {
    1581. 

  1581. 	    XtSetArg(args[j], XtNwidth, maxTextWidth);  j++;
    1582. 

  1582. 	    XtSetValues(texts[h], args, j);
    1583. 

  1583. 	}
    1584. 

  1584.     }
    1585. 

  1585.   }
    1586. 

  1586. 

  1587.   if(!(option[i].min & 2)) {
    1588. 

  1588.     j=0;
    1589. 

  1589.     if(option[i].min & 1) { XtSetArg(args[j], XtNfromHoriz, last); last = forelast; } else
    1590. 

  1590.     XtSetArg(args[j], XtNfromHoriz, widest ? widest : dialog);  j++;
    1591. 

  1591.     XtSetArg(args[j], XtNfromVert, anchor ? anchor : last);  j++;
    1592. 

  1592.     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
    1593. 

  1593.     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
    1594. 

  1594.     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
    1595. 

  1595.     XtSetArg(args[j], XtNright, XtChainRight);  j++;
    1596. 

  1596.     b_ok = XtCreateManagedWidget(_("OK"), commandWidgetClass, form, args, j);
    1597. 

  1597.     XtAddCallback(b_ok, XtNcallback, GenericCallback, (XtPointer)(intptr_t) dlgNr + (dlgNr<<16));
    1598. 

  1598. 

  1599.     XtSetArg(args[0], XtNfromHoriz, b_ok);
    1600. 

  1600.     b_cancel = XtCreateManagedWidget(_("cancel"), commandWidgetClass, form, args, j);
    1601. 

  1601.     XtAddCallback(b_cancel, XtNcallback, GenericCallback, (XtPointer)(intptr_t) dlgNr);
    1602. 

  1602.   }
    1603. 

  1603. 

  1604.     XtRealizeWidget(popup);
    1605. 

  1605.     XSetWMProtocols(xDisplay, XtWindow(popup), &wm_delete_window, 1);
    1606. 

  1606.     snprintf(def, MSG_SIZ, "<Message>WM_PROTOCOLS: GenericPopDown(\"%d\") \n", dlgNr);
    1607. 

  1607.     XtAugmentTranslations(popup, XtParseTranslationTable(def));
    1608. 

  1608.     XQueryPointer(xDisplay, xBoardWindow, &root, &child,
    1609. 

  1609. 		  &x, &y, &win_x, &win_y, &mask);
    1610. 

  1610. 

  1611.     XtSetArg(args[0], XtNx, x - 10);
    1612. 

  1612.     XtSetArg(args[1], XtNy, y - 30);
    1613. 

  1613.     XtSetValues(popup, args, 2);
    1614. 

  1614. 

  1615.     XtPopup(popup, dlgNr ? XtGrabNone : XtGrabExclusive);
    1616. 

  1616.     shellUp[dlgNr] = True;
    1617. 

  1617.     previous = NULL;
    1618. 

  1618.     if(textField)SetFocus(textField, popup, (XEvent*) NULL, False);
    1619. 

  1619.     if(dlgNr && wp[dlgNr] && wp[dlgNr]->width > 0) { // if persistent window-info available, reposition
    1620. 

  1620. 	j = 0;
    1621. 

  1621. 	XtSetArg(args[j], XtNheight, (Dimension) (wp[dlgNr]->height));  j++;
    1622. 

  1622. 	XtSetArg(args[j], XtNwidth,  (Dimension) (wp[dlgNr]->width));  j++;
    1623. 

  1623. 	XtSetArg(args[j], XtNx, (Position) (wp[dlgNr]->x));  j++;
    1624. 

  1624. 	XtSetArg(args[j], XtNy, (Position) (wp[dlgNr]->y));  j++;
    1625. 

  1625. 	XtSetValues(popup, args, j);
    1626. 

  1626.     }
    1627. 

  1627.     return 1;
    1628. 

  1628. }
    1629. 

  1629. 

  1630. 

  1631. void IcsOptionsProc(w, event, prms, nprms)
    1632. 

  1632.      Widget w;
    1633. 

  1633.      XEvent *event;
    1634. 

  1634.      String *prms;
    1635. 

  1635.      Cardinal *nprms;
    1636. 

  1636. {
    1637. 

  1637.    GenericPopUp(icsOptions, _("ICS Options"), 0);
    1638. 

  1638. }
    1639. 

  1639. 

  1640. void LoadOptionsProc(w, event, prms, nprms)
    1641. 

  1641.      Widget w;
    1642. 

  1642.      XEvent *event;
    1643. 

  1643.      String *prms;
    1644. 

  1644.      Cardinal *nprms;
    1645. 

  1645. {
    1646. 

  1646.    GenericPopUp(loadOptions, _("Load Game Options"), 0);
    1647. 

  1647. }
    1648. 

  1648. 

  1649. void SaveOptionsProc(w, event, prms, nprms)
    1650. 

  1650.      Widget w;
    1651. 

  1651.      XEvent *event;
    1652. 

  1652.      String *prms;
    1653. 

  1653.      Cardinal *nprms;
    1654. 

  1654. {
    1655. 

  1655.    GenericPopUp(saveOptions, _("Save Game Options"), 0);
    1656. 

  1656. }
    1657. 

  1657. 

  1658. void SoundOptionsProc(w, event, prms, nprms)
    1659. 

  1659.      Widget w;
    1660. 

  1660.      XEvent *event;
    1661. 

  1661.      String *prms;
    1662. 

  1662.      Cardinal *nprms;
    1663. 

  1663. {
    1664. 

  1664.    soundFiles[2] = "*";
    1665. 

  1665.    GenericPopUp(soundOptions, _("Sound Options"), 0);
    1666. 

  1666. }
    1667. 

  1667. 

  1668. void BoardOptionsProc(w, event, prms, nprms)
    1669. 

  1669.      Widget w;
    1670. 

  1670.      XEvent *event;
    1671. 

  1671.      String *prms;
    1672. 

  1672.      Cardinal *nprms;
    1673. 

  1673. {
    1674. 

  1674.    GenericPopUp(boardOptions, _("Board Options"), 0);
    1675. 

  1675. }
    1676. 

  1676. 

  1677. void EngineMenuProc(w, event, prms, nprms)
    1678. 

  1678.      Widget w;
    1679. 

  1679.      XEvent *event;
    1680. 

  1680.      String *prms;
    1681. 

  1681.      Cardinal *nprms;
    1682. 

  1682. {
    1683. 

  1683.    GenericPopUp(adjudicationOptions, "Adjudicate non-ICS Games", 0);
    1684. 

  1684. }
    1685. 

  1685. 

  1686. void UciMenuProc(w, event, prms, nprms)
    1687. 

  1687.      Widget w;
    1688. 

  1688.      XEvent *event;
    1689. 

  1689.      String *prms;
    1690. 

  1690.      Cardinal *nprms;
    1691. 

  1691. {
    1692. 

  1692.    oldCores = appData.smpCores;
    1693. 

  1693.    oldPonder = appData.ponderNextMove;
    1694. 

  1694.    GenericPopUp(commonEngineOptions, _("Common Engine Settings"), 0);
    1695. 

  1695. }
    1696. 

  1696. 

  1697. void NewVariantProc(w, event, prms, nprms)
    1698. 

  1698.      Widget w;
    1699. 

  1699.      XEvent *event;
    1700. 

  1700.      String *prms;
    1701. 

  1701.      Cardinal *nprms;
    1702. 

  1702. {
    1703. 

  1703.    GenericPopUp(variantDescriptors, _("New Variant"), 0);
    1704. 

  1704. }
    1705. 

  1705. 

  1706. void OptionsProc(w, event, prms, nprms)
    1707. 

  1707.      Widget w;
    1708. 

  1708.      XEvent *event;
    1709. 

  1709.      String *prms;
    1710. 

  1710.      Cardinal *nprms;
    1711. 

  1711. {
    1712. 

  1712.    oldPonder = appData.ponderNextMove;
    1713. 

  1713.    GenericPopUp(generalOptions, _("General Options"), 0);
    1714. 

  1714. }
    1715. 

  1715. 

  1716. void MatchOptionsProc(w, event, prms, nprms)
    1717. 

  1717.      Widget w;
    1718. 

  1718.      XEvent *event;
    1719. 

  1719.      String *prms;
    1720. 

  1720.      Cardinal *nprms;
    1721. 

  1721. {
    1722. 

  1722.    GenericPopUp(matchOptions, _("Match Options"), 0);
    1723. 

  1723. }
    1724. 

  1724. 

  1725. Option textOptions[100];
    1726. 

  1726. extern char *icsTextMenuString;
    1727. 

  1727. void PutText P((char *text, int pos));
    1728. 

  1728. 

  1729. SendString(char *p)
    1730. 

  1730. {
    1731. 

  1731.     char buf[MSG_SIZ], *q;
    1732. 

  1732.     if(q = strstr(p, "$input")) {
    1733. 

  1733. 	if(!shellUp[4]) return;
    1734. 

  1734. 	strncpy(buf, p, MSG_SIZ);
    1735. 

  1735. 	strncpy(buf + (q-p), q+6, MSG_SIZ-(q-p));
    1736. 

  1736. 	PutText(buf, q-p);
    1737. 

  1737. 	return;
    1738. 

  1738.     }
    1739. 

  1739.     snprintf(buf, MSG_SIZ, "%s\n", p);
    1740. 

  1740.     SendToICS(buf);
    1741. 

  1741. }
    1742. 

  1742. 

  1743. /* function called when the data to Paste is ready */
    1744. 

  1744. static void
    1745. 

  1745. SendTextCB(Widget w, XtPointer client_data, Atom *selection,
    1746. 

  1746. 	   Atom *type, XtPointer value, unsigned long *len, int *format)
    1747. 

  1747. {
    1748. 

  1748.   char buf[MSG_SIZ], *p = (char*) textOptions[(int)(intptr_t) client_data].choice, *name = (char*) value, *q;
    1749. 

  1749.   if (value==NULL || *len==0) return; /* nothing selected, abort */
    1750. 

  1750.   name[*len]='\0';
    1751. 

  1751.   strncpy(buf, p, MSG_SIZ);
    1752. 

  1752.   q = strstr(p, "$name");
    1753. 

  1753.   snprintf(buf + (q-p), MSG_SIZ -(q-p), "%s%s", name, q+5);
    1754. 

  1754.   SendString(buf);
    1755. 

  1755.   XtFree(value);
    1756. 

  1756. }
    1757. 

  1757. 

  1758. void SendText(int n)
    1759. 

  1759. {
    1760. 

  1760.     char *p = (char*) textOptions[n].choice;
    1761. 

  1761.     if(strstr(p, "$name")) {
    1762. 

  1762. 	XtGetSelectionValue(menuBarWidget,
    1763. 

  1763. 	  XA_PRIMARY, XA_STRING,
    1764. 

  1764. 	  /* (XtSelectionCallbackProc) */ SendTextCB,
    1765. 

  1765. 	  (XtPointer) (intptr_t) n, /* client_data passed to PastePositionCB */
    1766. 

  1766. 	  CurrentTime
    1767. 

  1767. 	);
    1768. 

  1768.     } else SendString(p);
    1769. 

  1769. }
    1770. 

  1770. 

  1771. void IcsTextProc(w, event, prms, nprms)
    1772. 

  1772.      Widget w;
    1773. 

  1773.      XEvent *event;
    1774. 

  1774.      String *prms;
    1775. 

  1775.      Cardinal *nprms;
    1776. 

  1776. {
    1777. 

  1777.    int i=0, j;
    1778. 

  1778.    char *p, *q, *r;
    1779. 

  1779.    if((p = icsTextMenuString) == NULL) return;
    1780. 

  1780.    do {
    1781. 

  1781. 	q = r = p; while(*p && *p != ';') p++;
    1782. 

  1782. 	for(j=0; j<p-q; j++) textOptions[i].name[j] = *r++;
    1783. 

  1783. 	textOptions[i].name[j++] = 0;
    1784. 

  1784. 	if(!*p) break;
    1785. 

  1785. 	if(*++p == '\n') p++; // optional linefeed after button-text terminating semicolon
    1786. 

  1786. 	q = p;
    1787. 

  1787. 	textOptions[i].choice = (char**) (r = textOptions[i].name + j);
    1788. 

  1788. 	while(*p && (*p != ';' || p[1] != '\n')) textOptions[i].name[j++] = *p++;
    1789. 

  1789. 	textOptions[i].name[j++] = 0;
    1790. 

  1790. 	if(*p) p += 2;
    1791. 

  1791. 	textOptions[i].max = 135;
    1792. 

  1792. 	textOptions[i].min = i&1;
    1793. 

  1793. 	textOptions[i].handle = NULL;
    1794. 

  1794. 	textOptions[i].target = &SendText;
    1795. 

  1795. 	textOptions[i].textValue = strstr(r, "$input") ? "#80FF80" : strstr(r, "$name") ? "#FF8080" : "#FFFFFF";
    1796. 

  1796. 	textOptions[i].type = Button;
    1797. 

  1797.    } while(++i < 99 && *p);
    1798. 

  1798.    if(i == 0) return;
    1799. 

  1799.    textOptions[i].type = EndMark;
    1800. 

  1800.    textOptions[i].target = NULL;
    1801. 

  1801.    textOptions[i].min = 2;
    1802. 

  1802.    MarkMenu("menuView.ICStex", 3);
    1803. 

  1803.    GenericPopUp(textOptions, _("ICS text menu"), 3);
    1804. 

  1804. }
    1805. 

  1805. 

  1806. extern char ICSInputTranslations[];
    1807. 

  1807. char *icsText;
    1808. 

  1808. 

  1809. Option boxOptions[] = {
    1810. 

  1810. {   0, 30,  400, NULL, (void*) &icsText, "", NULL, TextBox, "" },
    1811. 

  1811. {   0,  3,    0, NULL, NULL, "", NULL, EndMark , "" }
    1812. 

  1812. };
    1813. 

  1813. 

  1814. void PutText(char *text, int pos)
    1815. 

  1815. {
    1816. 

  1816.     Widget edit;
    1817. 

  1817.     Arg args[16];
    1818. 

  1818.     char buf[MSG_SIZ], *p;
    1819. 

  1819. 

  1820.     if(strstr(text, "$add ") == text) {
    1821. 

  1821. 	XtSetArg(args[0], XtNstring, &p);
    1822. 

  1822. 	XtGetValues(boxOptions[0].handle, args, 1);
    1823. 

  1823. 	snprintf(buf, MSG_SIZ, "%s%s", p, text+5); text = buf;
    1824. 

  1824. 	pos += strlen(p) - 5;
    1825. 

  1825.     }
    1826. 

  1826.     XtSetArg(args[0], XtNstring, text);
    1827. 

  1827.     XtSetValues(boxOptions[0].handle, args, 1);
    1828. 

  1828.     XtSetArg(args[0], XtNinsertPosition, pos);
    1829. 

  1829.     XtSetValues(boxOptions[0].handle, args, 1);
    1830. 

  1830. //    SetFocus(boxOptions[0].handle, shells[4], NULL, False); // No idea why this does not work, and the following is needed:
    1831. 

  1831.     XSetInputFocus(xDisplay, XtWindow(boxOptions[0].handle), RevertToPointerRoot, CurrentTime);
    1832. 

  1832. }
    1833. 

  1833. 

  1834. void InputBoxPopup()
    1835. 

  1835. {
    1836. 

  1836.     MarkMenu("menuView.ICS Input Box", 4);
    1837. 

  1837.     if(GenericPopUp(boxOptions, _("ICS input box"), 4))
    1838. 

  1838. 	XtOverrideTranslations(boxOptions[0].handle, XtParseTranslationTable(ICSInputTranslations));
    1839. 

  1839. }
    1840. 

  1840. 

  1841. void
    1842. 

  1842. SettingsPopUp(ChessProgramState *cps)
    1843. 

  1843. {
    1844. 

  1844.    currentCps = cps;
    1845. 

  1845.    GenericPopUp(cps->option, _("Engine Settings"), 0);
    1846. 

  1846. }
    1847. 

  1847. 

  1848. void FirstSettingsProc(w, event, prms, nprms)
    1849. 

  1849.      Widget w;
    1850. 

  1850.      XEvent *event;
    1851. 

  1851.      String *prms;
    1852. 

  1852.      Cardinal *nprms;
    1853. 

  1853. {
    1854. 

  1854.     SettingsPopUp(&first);
    1855. 

  1855. }
    1856. 

  1856. 

  1857. void SecondSettingsProc(w, event, prms, nprms)
    1858. 

  1858.      Widget w;
    1859. 

  1859.      XEvent *event;
    1860. 

  1860.      String *prms;
    1861. 

  1861.      Cardinal *nprms;
    1862. 

  1862. {
    1863. 

  1863.    if(WaitForSecond(SettingsMenuIfReady)) return;
    1864. 

  1864.    SettingsPopUp(&second);
    1865. 

  1865. }
    1866. 

  1866. 

  1867. //---------------------------- Chat Windows ----------------------------------------------
    1868. 

  1868. 

  1869. void OutputChatMessage(int partner, char *mess)
    1870. 

  1870. {
    1871. 

  1871.     return; // dummy
    1872. 

  1872. }
    1873. 

  1873. 

  1874.