PageRenderTime 56ms CodeModel.GetById 16ms 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

Large files files are truncated, but you can click here to view the full file

    

  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(currentOpt…
    1223.

Large files files are truncated, but you can click here to view the full file