updated documentation for new release
[xboard.git] / xengineoutput.c
1 /*\r
2  * Engine output (PV)\r
3  *\r
4  * Author: Alessandro Scotti (Dec 2005)\r
5  *\r
6  * ------------------------------------------------------------------------\r
7  *\r
8  * GNU XBoard is free software: you can redistribute it and/or modify\r
9  * it under the terms of the GNU General Public License as published by\r
10  * the Free Software Foundation, either version 3 of the License, or (at\r
11  * your option) any later version.\r
12  *\r
13  * GNU XBoard is distributed in the hope that it will be useful, but\r
14  * WITHOUT ANY WARRANTY; without even the implied warranty of\r
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
16  * General Public License for more details.\r
17  *\r
18  * You should have received a copy of the GNU General Public License\r
19  * along with this program. If not, see http://www.gnu.org/licenses/.\r
20  *\r
21  * ------------------------------------------------------------------------\r
22  ** See the file ChangeLog for a revision history.  */\r
23 \r
24 #include "config.h"\r
25 \r
26 #include <stdio.h>\r
27 #include <ctype.h>\r
28 #include <errno.h>\r
29 #include <sys/types.h>\r
30 \r
31 #if STDC_HEADERS\r
32 # include <stdlib.h>\r
33 # include <string.h>\r
34 #else /* not STDC_HEADERS */\r
35 extern char *getenv();\r
36 # if HAVE_STRING_H\r
37 #  include <string.h>\r
38 # else /* not HAVE_STRING_H */\r
39 #  include <strings.h>\r
40 # endif /* not HAVE_STRING_H */\r
41 #endif /* not STDC_HEADERS */\r
42 \r
43 #if HAVE_UNISTD_H\r
44 # include <unistd.h>\r
45 #endif\r
46 \r
47 #include <X11/Intrinsic.h>\r
48 #include <X11/StringDefs.h>\r
49 #include <X11/Shell.h>\r
50 #include <X11/Xaw/Dialog.h>\r
51 #include <X11/Xaw/Form.h>\r
52 #include <X11/Xaw/List.h>\r
53 #include <X11/Xaw/Label.h>\r
54 #include <X11/Xaw/SimpleMenu.h>\r
55 #include <X11/Xaw/SmeBSB.h>\r
56 #include <X11/Xaw/SmeLine.h>\r
57 #include <X11/Xaw/Box.h>\r
58 #include <X11/Xaw/Paned.h>\r
59 #include <X11/Xaw/MenuButton.h>\r
60 #include <X11/cursorfont.h>\r
61 #include <X11/Xaw/Text.h>\r
62 #include <X11/Xaw/AsciiText.h>\r
63 #include <X11/Xaw/Viewport.h>\r
64 \r
65 #include "common.h"\r
66 #include "frontend.h"\r
67 #include "backend.h"\r
68 #include "xboard.h"\r
69 // Add xengineo.h later\r
70 #include "gettext.h"\r
71 \r
72 #ifdef ENABLE_NLS\r
73 # define  _(s) gettext (s)\r
74 # define N_(s) gettext_noop (s)\r
75 #else\r
76 # define  _(s) (s)\r
77 # define N_(s)  s\r
78 #endif\r
79 \r
80 #include <X11/xpm.h>\r
81 \r
82 // [HGM] pixmaps of some ICONS used in the engine-outut window\r
83 #include "pixmaps/WHITE_14.xpm"\r
84 #include "pixmaps/BLACK_14.xpm"\r
85 #include "pixmaps/CLEAR_14.xpm"\r
86 #include "pixmaps/UNKNOWN_14.xpm"\r
87 #include "pixmaps/THINKING_14.xpm"\r
88 #include "pixmaps/PONDER_14.xpm"\r
89 #include "pixmaps/ANALYZING_14.xpm"\r
90 \r
91 #ifdef SNAP\r
92 #include "wsnap.h"\r
93 #endif\r
94 \r
95 #define _LL_ 100\r
96 \r
97 // imports from xboard.c\r
98 extern Widget formWidget, shellWidget, boardWidget, menuBarWidget;\r
99 extern Display *xDisplay;\r
100 extern Window xBoardWindow;\r
101 extern int squareSize;\r
102 extern Pixmap xMarkPixmap, wIconPixmap, bIconPixmap;\r
103 extern char *layoutName;\r
104 \r
105 // temporary kludge to avoid compile errors untill all Windows code has been replaced\r
106 #define HICON int *\r
107 #define HWND  int *\r
108 \r
109 // [HGM] define numbers to indicate icons, for referring to them in platform-independent way\r
110 #define nColorBlack   1\r
111 #define nColorWhite   2\r
112 #define nColorUnknown 3\r
113 #define nClear        4\r
114 #define nPondering    5\r
115 #define nThinking     6\r
116 #define nAnalyzing    7\r
117 \r
118 Pixmap icons[8]; // [HGM] this front-end array translates back-end icon indicator to handle\r
119 \r
120 // [HGM] same for output fields (note that there are two of each type, one per color)\r
121 #define nColorIcon 1\r
122 #define nStateIcon 2\r
123 #define nLabel     3\r
124 #define nStateData 4\r
125 #define nLabelNPS  5\r
126 #define nMemo      6\r
127 \r
128 Widget outputField[2][7]; // [HGM] front-end array to translate output field to window handle\r
129 \r
130 void EngineOutputPopDown();\r
131 void engineOutputPopUp(char *title, char *text);\r
132 int  EngineOutputIsUp();\r
133 static void SetEngineColorIcon( int which );\r
134 \r
135 #define SHOW_PONDERING\r
136 \r
137 /* Imports from backend.c */\r
138 char * SavePart(char *str);\r
139 extern int opponentKibitzes;\r
140 \r
141 /* Imports from winboard.c */\r
142 //extern HWND engineOutputDialog;\r
143 extern Arg layoutArgs[2], formArgs[2], messageArgs[4];\r
144 \r
145 //extern WindowPlacement wpEngineOutput;\r
146 \r
147 Position engineOutputX = -1, engineOutputY = -1;\r
148 Dimension engineOutputW, engineOutputH;\r
149 Widget engineOutputShell;\r
150 int engineOutputDialogUp;\r
151 \r
152 /* Module variables */\r
153 #define H_MARGIN            2\r
154 #define V_MARGIN            2\r
155 #define LABEL_V_DISTANCE    1   /* Distance between label and memo */\r
156 #define SPLITTER_SIZE       4   /* Distance between first memo and second label */\r
157 \r
158 #define ICON_SIZE           14\r
159 \r
160 #define STATE_UNKNOWN   -1\r
161 #define STATE_THINKING   0\r
162 #define STATE_IDLE       1\r
163 #define STATE_PONDERING  2\r
164 #define STATE_ANALYZING  3\r
165 \r
166 static int  windowMode = 1;\r
167 \r
168 static int  needInit = TRUE;\r
169 \r
170 static int  lastDepth[2] = { -1, -1 };\r
171 static int  lastForwardMostMove[2] = { -1, -1 };\r
172 static int  engineState[2] = { -1, -1 };\r
173 \r
174 typedef struct {\r
175     char * name;\r
176     int which;\r
177     int depth;\r
178     u64 nodes;\r
179     int score;\r
180     int time;\r
181     char * pv;\r
182     char * hint;\r
183     int an_move_index;\r
184     int an_move_count;\r
185 } EngineOutputData;\r
186 \r
187 static int VerifyDisplayMode();\r
188 static void UpdateControls( EngineOutputData * ed );\r
189 static SetEngineState( int which, int state, char * state_data );\r
190 \r
191 void ReadIcon(char *pixData[], int iconNr)\r
192 {\r
193     int r;\r
194 \r
195         if ((r=XpmCreatePixmapFromData(xDisplay, XtWindow(outputField[0][nColorIcon]),\r
196                                        pixData,\r
197                                        &(icons[iconNr]),\r
198                                        NULL, NULL /*&attr*/)) != 0) {\r
199           fprintf(stderr, _("Error %d loading icon image\n"), r);\r
200           exit(1); \r
201         }       \r
202 }\r
203 \r
204 static void InitializeEngineOutput()\r
205 { int i;\r
206 \r
207         ReadIcon(WHITE_14,   nColorWhite);\r
208         ReadIcon(BLACK_14,   nColorBlack);\r
209         ReadIcon(UNKNOWN_14, nColorUnknown);\r
210 \r
211         ReadIcon(CLEAR_14,   nClear);\r
212         ReadIcon(PONDER_14,  nPondering);\r
213         ReadIcon(THINK_14,   nThinking);\r
214         ReadIcon(ANALYZE_14, nAnalyzing);\r
215 }\r
216 \r
217 void DoSetWindowText(int which, int field, char *s_label)\r
218\r
219         Arg arg;\r
220 \r
221         XtSetArg(arg, XtNlabel, (XtArgVal) s_label);\r
222         XtSetValues(outputField[which][field], &arg, 1);\r
223 }\r
224 \r
225 static void InsertIntoMemo( int which, char * text )\r
226 {\r
227         Arg arg; XawTextBlock t; Widget edit;\r
228 \r
229         t.ptr = text; t.firstPos = 0; t.length = strlen(text); t.format = XawFmt8Bit;\r
230         edit = XtNameToWidget(engineOutputShell, which ? "*form2.text" : "*form.text");\r
231         XawTextReplace(edit, 0, 0, &t);\r
232 //      XtSetArg(arg, XtNstring, (XtArgVal) text);\r
233 //      XtSetValues(outputField[which][nMemo], &arg, 1);\r
234 }\r
235 \r
236 static void SetIcon( int which, int field, int nIcon )\r
237 {\r
238     Arg arg;\r
239 \r
240     if( nIcon != 0 ) {\r
241         XtSetArg(arg, XtNleftBitmap, (XtArgVal) icons[nIcon]);\r
242         XtSetValues(outputField[which][field], &arg, 1);\r
243     }\r
244 }\r
245 \r
246 void DoClearMemo(int which)\r
247\r
248     Arg args[16];\r
249     int j;\r
250     Widget edit;\r
251 \r
252         edit = XtNameToWidget(engineOutputShell, which ? "*form2.text" : "*form.text");\r
253         XtCallActionProc(edit, "select-all", NULL, NULL, 0);\r
254         XtCallActionProc(edit, "kill-selection", NULL, NULL, 0);\r
255 }\r
256 \r
257 // The following routines are mutated clones of the commentPopUp routines\r
258 \r
259 void PositionControlSet(which, form, bw_width)\r
260      int which;\r
261      Widget form;\r
262      Dimension bw_width;\r
263 {\r
264     Arg args[16];\r
265     Widget edit, NameWidget, ColorWidget, ModeWidget, MoveWidget, NodesWidget;\r
266     int j, mutable=1;\r
267     j = 0;\r
268     XtSetArg(args[j], XtNborderWidth, (XtArgVal) 0); j++;\r
269     XtSetArg(args[j], XtNlabel,     (XtArgVal) ""); j++;\r
270     XtSetArg(args[j], XtNtop,       XtChainTop); j++;\r
271     XtSetArg(args[j], XtNbottom,    XtChainTop); j++;\r
272     XtSetArg(args[j], XtNleft,      XtChainLeft); j++;\r
273     XtSetArg(args[j], XtNright,     XtChainLeft); j++;\r
274     XtSetArg(args[j], XtNheight,    (XtArgVal) 16); j++;\r
275     XtSetArg(args[j], XtNwidth,     (XtArgVal) 17); j++;\r
276     outputField[which][nColorIcon] = ColorWidget =\r
277       XtCreateManagedWidget("Color", labelWidgetClass,\r
278                      form, args, j);\r
279 \r
280     j = 0;\r
281     XtSetArg(args[j], XtNborderWidth, (XtArgVal) 0); j++;\r
282     XtSetArg(args[j], XtNjustify,   (XtArgVal) XtJustifyLeft); j++;\r
283     XtSetArg(args[j], XtNfromHoriz, (XtArgVal) ColorWidget); j++;\r
284     XtSetArg(args[j], XtNtop,       XtChainTop); j++;\r
285     XtSetArg(args[j], XtNbottom,    XtChainTop); j++;\r
286     XtSetArg(args[j], XtNleft,      XtChainLeft); j++;\r
287     XtSetArg(args[j], XtNheight,    (XtArgVal) 16); j++;\r
288     XtSetArg(args[j], XtNwidth,     (XtArgVal) bw_width/2 - 57); j++;\r
289     outputField[which][nLabel] = NameWidget =\r
290       XtCreateManagedWidget("Engine", labelWidgetClass,\r
291                      form, args, j);\r
292 \r
293     j = 0;\r
294     XtSetArg(args[j], XtNborderWidth, (XtArgVal) 0); j++;\r
295     XtSetArg(args[j], XtNlabel,     (XtArgVal) ""); j++;\r
296     XtSetArg(args[j], XtNfromHoriz, (XtArgVal) NameWidget); j++;\r
297     XtSetArg(args[j], XtNtop,       XtChainTop); j++;\r
298     XtSetArg(args[j], XtNbottom,    XtChainTop); j++;\r
299     XtSetArg(args[j], XtNheight,    (XtArgVal) 16); j++;\r
300     XtSetArg(args[j], XtNwidth,     (XtArgVal) 20); j++;\r
301     outputField[which][nStateIcon] = ModeWidget =\r
302       XtCreateManagedWidget("Mode", labelWidgetClass,\r
303                      form, args, j);\r
304 \r
305     j = 0;\r
306     XtSetArg(args[j], XtNborderWidth, (XtArgVal) 0); j++;\r
307     XtSetArg(args[j], XtNjustify,   (XtArgVal) XtJustifyLeft); j++;\r
308     XtSetArg(args[j], XtNlabel,     (XtArgVal) ""); j++;\r
309     XtSetArg(args[j], XtNfromHoriz, (XtArgVal) ModeWidget); j++;\r
310     XtSetArg(args[j], XtNtop,       XtChainTop); j++;\r
311     XtSetArg(args[j], XtNbottom,    XtChainTop); j++;\r
312     XtSetArg(args[j], XtNright,     XtChainRight); j++;\r
313     XtSetArg(args[j], XtNheight,    (XtArgVal) 16); j++;\r
314     XtSetArg(args[j], XtNwidth,     (XtArgVal) bw_width/2 - 102); j++;\r
315     outputField[which][nStateData] = MoveWidget =\r
316       XtCreateManagedWidget("Move", labelWidgetClass,\r
317                      form, args, j);\r
318 \r
319     j = 0;\r
320     XtSetArg(args[j], XtNborderWidth, (XtArgVal) 0); j++;\r
321     XtSetArg(args[j], XtNjustify,   (XtArgVal) XtJustifyRight); j++;\r
322     XtSetArg(args[j], XtNlabel,     (XtArgVal) _("NPS")); j++;\r
323     XtSetArg(args[j], XtNfromHoriz, (XtArgVal) MoveWidget); j++;\r
324     XtSetArg(args[j], XtNtop,       XtChainTop); j++;\r
325     XtSetArg(args[j], XtNbottom,    XtChainTop); j++;\r
326     XtSetArg(args[j], XtNleft,      XtChainRight); j++;\r
327     XtSetArg(args[j], XtNright,     XtChainRight); j++;\r
328     XtSetArg(args[j], XtNheight,    (XtArgVal) 16); j++;\r
329     XtSetArg(args[j], XtNwidth,     (XtArgVal) 100); j++;\r
330     outputField[which][nLabelNPS] = NodesWidget =\r
331       XtCreateManagedWidget("Nodes", labelWidgetClass,\r
332                      form, args, j);\r
333 \r
334     // create "text" within "form"\r
335     j = 0;\r
336     if (mutable) {\r
337         XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;\r
338         XtSetArg(args[j], XtNuseStringInPlace, False);  j++;\r
339     }\r
340     XtSetArg(args[j], XtNstring, "");  j++;\r
341     XtSetArg(args[j], XtNdisplayCaret, False);  j++;\r
342     XtSetArg(args[j], XtNtop, XtChainTop);  j++;\r
343     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;\r
344     XtSetArg(args[j], XtNleft, XtChainLeft);  j++;\r
345     XtSetArg(args[j], XtNright, XtChainRight);  j++;\r
346     XtSetArg(args[j], XtNresizable, True);  j++;\r
347     XtSetArg(args[j], XtNwidth, bw_width);  j++; /*force wider than buttons*/\r
348 #if 0\r
349     XtSetArg(args[j], XtNscrollVertical, XawtextScrollWhenNeeded);  j++;\r
350 #else\r
351     /* !!Work around an apparent bug in XFree86 4.0.1 (X11R6.4.3) */\r
352     XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways);  j++;\r
353     XtSetArg(args[j], XtNscrollHorizontal, XawtextScrollWhenNeeded);  j++;\r
354 #endif\r
355 //    XtSetArg(args[j], XtNautoFill, True);  j++;\r
356 //    XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++;\r
357     outputField[which][nMemo] = edit =\r
358       XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j);\r
359 \r
360     j = 0;\r
361     XtSetArg(args[j], XtNfromVert, ColorWidget); j++;\r
362 //    XtSetArg(args[j], XtNresizable, (XtArgVal) True); j++;\r
363     XtSetValues(edit, args, j);\r
364 }\r
365 \r
366 Widget EngineOutputCreate(name, text)\r
367      char *name, *text;\r
368 {\r
369     Arg args[16];\r
370     Widget shell, layout, form, form2, edit;\r
371     Dimension bw_width, bw_height;\r
372     int j;\r
373 \r
374     // get board width\r
375     j = 0;\r
376     XtSetArg(args[j], XtNwidth,  &bw_width);  j++;\r
377     XtSetArg(args[j], XtNheight, &bw_height);  j++;\r
378     XtGetValues(boardWidget, args, j);\r
379 \r
380     // define form within layout within shell.\r
381     j = 0;\r
382     XtSetArg(args[j], XtNresizable, True);  j++;\r
383     shell =\r
384       XtCreatePopupShell(name, transientShellWidgetClass,\r
385                          shellWidget, args, j);\r
386     layout =\r
387       XtCreateManagedWidget(layoutName, formWidgetClass, shell,\r
388                             layoutArgs, XtNumber(layoutArgs));\r
389     // divide window vertically into two equal parts, by creating two forms\r
390     form =\r
391       XtCreateManagedWidget("form", formWidgetClass, layout,\r
392                             formArgs, XtNumber(formArgs));\r
393     form2 =\r
394       XtCreateManagedWidget("form2", formWidgetClass, layout,\r
395                             formArgs, XtNumber(formArgs));\r
396     j = 0;\r
397     XtSetArg(args[j], XtNfromVert,  (XtArgVal) form); j++;\r
398     XtSetValues(form2, args, j);\r
399     // make sure width is known in advance, for better placement of child widgets\r
400     j = 0;\r
401     XtSetArg(args[j], XtNwidth,     (XtArgVal) bw_width-16); j++;\r
402     XtSetArg(args[j], XtNheight,    (XtArgVal) bw_height/2); j++;\r
403     XtSetValues(shell, args, j);\r
404 \r
405     // fill up both forms with control elements\r
406     PositionControlSet(0, form,  bw_width);\r
407     PositionControlSet(1, form2, bw_width);\r
408 \r
409     XtRealizeWidget(shell);\r
410 \r
411     if (engineOutputX == -1) {\r
412         int xx, yy;\r
413         Window junk;\r
414         Dimension pw_height;\r
415         Dimension ew_height;\r
416 #if 0\r
417         j = 0;\r
418         XtSetArg(args[j], XtNheight, &ew_height);  j++;\r
419         XtGetValues(edit, args, j);\r
420 \r
421         j = 0;\r
422         XtSetArg(args[j], XtNheight, &pw_height);  j++;\r
423         XtGetValues(shell, args, j);\r
424         engineOutputH = pw_height + (lines - 1) * ew_height;\r
425         engineOutputW = bw_width - 16;\r
426 #else\r
427         engineOutputH = bw_height/2;\r
428         engineOutputW = bw_width-16;\r
429 #endif\r
430 \r
431         XSync(xDisplay, False);\r
432 #ifdef NOTDEF\r
433         /* This code seems to tickle an X bug if it is executed too soon\r
434            after xboard starts up.  The coordinates get transformed as if\r
435            the main window was positioned at (0, 0).\r
436            */\r
437         XtTranslateCoords(shellWidget,\r
438                           (bw_width - engineOutputW) / 2, 0 - engineOutputH / 2,\r
439                           &engineOutputX, &engineOutputY);\r
440 #else  /*!NOTDEF*/\r
441         XTranslateCoordinates(xDisplay, XtWindow(shellWidget),\r
442                               RootWindowOfScreen(XtScreen(shellWidget)),\r
443                               (bw_width - engineOutputW) / 2, 0 - engineOutputH / 2,\r
444                               &xx, &yy, &junk);\r
445         engineOutputX = xx;\r
446         engineOutputY = yy;\r
447 #endif /*!NOTDEF*/\r
448         if (engineOutputY < 0) engineOutputY = 0; /*avoid positioning top offscreen*/\r
449     }\r
450     j = 0;\r
451     XtSetArg(args[j], XtNheight, engineOutputH);  j++;\r
452     XtSetArg(args[j], XtNwidth, engineOutputW);  j++;\r
453     XtSetArg(args[j], XtNx, engineOutputX);  j++;\r
454     XtSetArg(args[j], XtNy, engineOutputY);  j++;\r
455     XtSetValues(shell, args, j);\r
456 //    XtSetKeyboardFocus(shell, edit);\r
457 \r
458     return shell;\r
459 }\r
460 \r
461 void ResizeWindowControls(shell, mode)\r
462         Widget shell;\r
463         int mode;\r
464 {\r
465     Widget form1, form2;\r
466     Arg args[16];\r
467     int j;\r
468     Dimension ew_height, tmp;\r
469 \r
470     form1 = XtNameToWidget(shell, "*form");\r
471     form2 = XtNameToWidget(shell, "*form2");\r
472 \r
473     j = 0;\r
474     XtSetArg(args[j], XtNheight, (XtArgVal) &ew_height); j++;\r
475     XtGetValues(form1, args, j);\r
476     j = 0;\r
477     XtSetArg(args[j], XtNheight, (XtArgVal) &tmp); j++;\r
478     XtGetValues(form2, args, j);\r
479     ew_height += tmp; // total height\r
480 \r
481     if(mode==0) {\r
482         j = 0;\r
483         XtSetArg(args[j], XtNheight, (XtArgVal) 5); j++;\r
484         XtSetValues(form2, args, j);\r
485         j = 0;\r
486         XtSetArg(args[j], XtNheight, (XtArgVal) (ew_height-5)); j++;\r
487         XtSetValues(form1, args, j);\r
488     } else {\r
489         j = 0;\r
490         XtSetArg(args[j], XtNheight, (XtArgVal) (ew_height/2)); j++;\r
491         XtSetValues(form1, args, j);\r
492         j = 0;\r
493         XtSetArg(args[j], XtNheight, (XtArgVal) (ew_height/2)); j++;\r
494         XtSetValues(form2, args, j);\r
495     }\r
496 }\r
497 \r
498 void EngineOutputPopUp(title, text)\r
499      char *title, *text;\r
500 {\r
501     Arg args[16];\r
502     int j;\r
503     Widget edit;\r
504 \r
505     if (engineOutputShell == NULL) {\r
506         engineOutputShell =\r
507           EngineOutputCreate(title, text);\r
508         XtRealizeWidget(engineOutputShell);\r
509         CatchDeleteWindow(engineOutputShell, "EngineOutputPopDown");\r
510         if( needInit ) {\r
511             InitializeEngineOutput();\r
512             needInit = FALSE;\r
513         }\r
514         SetEngineColorIcon( 0 );\r
515         SetEngineColorIcon( 1 );\r
516         SetEngineState( 0, STATE_IDLE, "" );\r
517         SetEngineState( 1, STATE_IDLE, "" );\r
518     } else {\r
519         edit = XtNameToWidget(engineOutputShell, "*form.text");\r
520         j = 0;\r
521         XtSetArg(args[j], XtNstring, text); j++;\r
522         XtSetValues(edit, args, j);\r
523         j = 0;\r
524         XtSetArg(args[j], XtNiconName, (XtArgVal) title);   j++;\r
525         XtSetArg(args[j], XtNtitle, (XtArgVal) title);      j++;\r
526         XtSetValues(engineOutputShell, args, j);\r
527     }\r
528 \r
529     XtPopup(engineOutputShell, XtGrabNone);\r
530     XSync(xDisplay, False);\r
531 \r
532     j=0;\r
533     XtSetArg(args[j], XtNleftBitmap, xMarkPixmap); j++;\r
534     XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Show Engine Output"),\r
535                 args, j);\r
536 \r
537     engineOutputDialogUp = True;\r
538     ShowThinkingEvent(); // [HGM] thinking: might need to prompt engine for thinking output\r
539 }\r
540 \r
541 void EngineOutputPopDown()\r
542 {\r
543     Arg args[16];\r
544     int j;\r
545 \r
546     if (!engineOutputDialogUp) return;\r
547     DoClearMemo(1);\r
548     j = 0;\r
549     XtSetArg(args[j], XtNx, &engineOutputX); j++;\r
550     XtSetArg(args[j], XtNy, &engineOutputY); j++;\r
551     XtSetArg(args[j], XtNwidth, &engineOutputW); j++;\r
552     XtSetArg(args[j], XtNheight, &engineOutputH); j++;\r
553     XtGetValues(engineOutputShell, args, j);\r
554     XtPopdown(engineOutputShell);\r
555     XSync(xDisplay, False);\r
556     j=0;\r
557     XtSetArg(args[j], XtNleftBitmap, None); j++;\r
558     XtSetValues(XtNameToWidget(menuBarWidget, "menuMode.Show Engine Output"),\r
559                 args, j);\r
560 \r
561     engineOutputDialogUp = False;\r
562     ShowThinkingEvent(); // [HGM] thinking: might need to shut off thinking output\r
563 }\r
564 \r
565 //------------------------ pure back-end routines -------------------------------\r
566 \r
567 \r
568 // back end, due to front-end wrapper for SetWindowText, and new SetIcon arguments\r
569 static SetEngineState( int which, int state, char * state_data )\r
570 {\r
571     int x_which = 1 - which;\r
572 \r
573     if( engineState[ which ] != state ) {\r
574         engineState[ which ] = state;\r
575 \r
576         switch( state ) {\r
577         case STATE_THINKING:\r
578             SetIcon( which, nStateIcon, nThinking );\r
579             if( engineState[ x_which ] == STATE_THINKING ) {\r
580                 SetEngineState( x_which, STATE_IDLE, "" );\r
581             }\r
582             break;\r
583         case STATE_PONDERING:\r
584             SetIcon( which, nStateIcon, nPondering );\r
585             break;\r
586         case STATE_ANALYZING:\r
587             SetIcon( which, nStateIcon, nAnalyzing );\r
588             break;\r
589         default:\r
590             SetIcon( which, nStateIcon, nClear );\r
591             break;\r
592         }\r
593     }\r
594 \r
595     if( state_data != 0 ) {\r
596         DoSetWindowText( which, nStateData, state_data );\r
597     }\r
598 }\r
599 \r
600 // back end, now the front-end wrapper ClearMemo is used, and ed no longer contains handles.\r
601 void EngineOutputUpdate( FrontEndProgramStats * stats )\r
602 {\r
603     EngineOutputData ed;\r
604     int clearMemo = FALSE;\r
605     int which;\r
606     int depth;\r
607 \r
608     if( stats == 0 ) {\r
609         SetEngineState( 0, STATE_IDLE, "" );\r
610         SetEngineState( 1, STATE_IDLE, "" );\r
611         return;\r
612     }\r
613 \r
614     if(gameMode == IcsObserving && !appData.icsEngineAnalyze)\r
615         return; // [HGM] kibitz: shut up engine if we are observing an ICS game\r
616 \r
617     which = stats->which;\r
618     depth = stats->depth;\r
619 \r
620     if( which < 0 || which > 1 || depth < 0 || stats->time < 0 || stats->pv == 0 ) {\r
621         return;\r
622     }\r
623 \r
624     if( engineOutputShell == NULL ) {\r
625         return;\r
626     }\r
627 \r
628     VerifyDisplayMode();\r
629 \r
630     ed.which = which;\r
631     ed.depth = depth;\r
632     ed.nodes = stats->nodes;\r
633     ed.score = stats->score;\r
634     ed.time = stats->time;\r
635     ed.pv = stats->pv;\r
636     ed.hint = stats->hint;\r
637     ed.an_move_index = stats->an_move_index;\r
638     ed.an_move_count = stats->an_move_count;\r
639 \r
640     /* Get target control. [HGM] this is moved to front end, which get them from a table */\r
641     if( which == 0 ) {\r
642         ed.name = first.tidy;\r
643     }\r
644     else {\r
645         ed.name = second.tidy;\r
646     }\r
647 \r
648     /* Clear memo if needed */\r
649     if( lastDepth[which] > depth || (lastDepth[which] == depth && depth <= 1) ) {\r
650         clearMemo = TRUE;\r
651     }\r
652 \r
653     if( lastForwardMostMove[which] != forwardMostMove ) {\r
654         clearMemo = TRUE;\r
655     }\r
656 \r
657     if( clearMemo ) DoClearMemo(which);\r
658 \r
659     /* Update */\r
660     lastDepth[which] = depth;\r
661     lastForwardMostMove[which] = forwardMostMove;\r
662 \r
663     if( ed.pv != 0 && ed.pv[0] == ' ' ) {\r
664         if( strncmp( ed.pv, " no PV", 6 ) == 0 ) { /* Hack on hack! :-O */\r
665             ed.pv = "";\r
666         }\r
667     }\r
668 \r
669     UpdateControls( &ed );\r
670 }\r
671 \r
672 #define ENGINE_COLOR_WHITE      'w'\r
673 #define ENGINE_COLOR_BLACK      'b'\r
674 #define ENGINE_COLOR_UNKNOWN    ' '\r
675 \r
676 // pure back end\r
677 char GetEngineColor( int which )\r
678 {\r
679     char result = ENGINE_COLOR_UNKNOWN;\r
680 \r
681     if( which == 0 || which == 1 ) {\r
682         ChessProgramState * cps;\r
683 \r
684         switch (gameMode) {\r
685         case MachinePlaysBlack:\r
686         case IcsPlayingBlack:\r
687             result = ENGINE_COLOR_BLACK;\r
688             break;\r
689         case MachinePlaysWhite:\r
690         case IcsPlayingWhite:\r
691             result = ENGINE_COLOR_WHITE;\r
692             break;\r
693         case AnalyzeMode:\r
694         case AnalyzeFile:\r
695             result = WhiteOnMove(forwardMostMove) ? ENGINE_COLOR_WHITE : ENGINE_COLOR_BLACK;\r
696             break;\r
697         case TwoMachinesPlay:\r
698             cps = (which == 0) ? &first : &second;\r
699             result = cps->twoMachinesColor[0];\r
700             result = result == 'w' ? ENGINE_COLOR_WHITE : ENGINE_COLOR_BLACK;\r
701             break;\r
702         }\r
703     }\r
704 \r
705     return result;\r
706 }\r
707 \r
708 // pure back end\r
709 char GetActiveEngineColor()\r
710 {\r
711     char result = ENGINE_COLOR_UNKNOWN;\r
712 \r
713     if( gameMode == TwoMachinesPlay ) {\r
714         result = WhiteOnMove(forwardMostMove) ? ENGINE_COLOR_WHITE : ENGINE_COLOR_BLACK;\r
715     }\r
716 \r
717     return result;\r
718 }\r
719 \r
720 // pure back end\r
721 static int IsEnginePondering( int which )\r
722 {\r
723     int result = FALSE;\r
724 \r
725     switch (gameMode) {\r
726     case MachinePlaysBlack:\r
727     case IcsPlayingBlack:\r
728         if( WhiteOnMove(forwardMostMove) ) result = TRUE;\r
729         break;\r
730     case MachinePlaysWhite:\r
731     case IcsPlayingWhite:\r
732         if( ! WhiteOnMove(forwardMostMove) ) result = TRUE;\r
733         break;\r
734     case TwoMachinesPlay:\r
735         if( GetActiveEngineColor() != ENGINE_COLOR_UNKNOWN ) {\r
736             if( GetEngineColor( which ) != GetActiveEngineColor() ) result = TRUE;\r
737         }\r
738         break;\r
739     }\r
740 \r
741     return result;\r
742 }\r
743 \r
744 // back end\r
745 static void SetDisplayMode( int mode )\r
746 {\r
747     if( windowMode != mode ) {\r
748         windowMode = mode;\r
749 \r
750         ResizeWindowControls( engineOutputShell, mode );\r
751     }\r
752 }\r
753 \r
754 // pure back end\r
755 int VerifyDisplayMode()\r
756 {\r
757     int mode;\r
758 \r
759     /* Get proper mode for current game */\r
760     switch( gameMode ) {\r
761     case IcsObserving:    // [HGM] ICS analyze\r
762         if(!appData.icsEngineAnalyze) return;\r
763     case AnalyzeMode:\r
764     case AnalyzeFile:\r
765     case MachinePlaysWhite:\r
766     case MachinePlaysBlack:\r
767         mode = 0;\r
768         break;\r
769     case IcsPlayingWhite:\r
770     case IcsPlayingBlack:\r
771         mode = appData.zippyPlay && opponentKibitzes; // [HGM] kibitz\r
772         break;\r
773     case TwoMachinesPlay:\r
774         mode = 1;\r
775         break;\r
776     default:\r
777         /* Do not change */\r
778         return;\r
779     }\r
780 \r
781     SetDisplayMode( mode );\r
782 }\r
783 \r
784 // back end. Determine what icon to se in the color-icon field, and print it\r
785 static void SetEngineColorIcon( int which )\r
786 {\r
787     char color = GetEngineColor(which);\r
788     int nicon = 0;\r
789 \r
790     if( color == ENGINE_COLOR_BLACK )\r
791         nicon = nColorBlack;\r
792     else if( color == ENGINE_COLOR_WHITE )\r
793         nicon = nColorWhite;\r
794     else\r
795         nicon = nColorUnknown;\r
796 \r
797     SetIcon( which, nColorIcon, nicon );\r
798 }\r
799 \r
800 #define MAX_NAME_LENGTH 32\r
801 \r
802 // pure back end, now SetWindowText is called via wrapper DoSetWindowText\r
803 static void UpdateControls( EngineOutputData * ed )\r
804 {\r
805     int isPondering = FALSE;\r
806 \r
807     char s_label[MAX_NAME_LENGTH + 32];\r
808     \r
809     char * name = ed->name;\r
810 \r
811     /* Label */\r
812     if( name == 0 || *name == '\0' ) {\r
813         name = "?";\r
814     }\r
815 \r
816     strncpy( s_label, name, MAX_NAME_LENGTH );\r
817     s_label[ MAX_NAME_LENGTH-1 ] = '\0';\r
818 \r
819 #ifdef SHOW_PONDERING\r
820     if( IsEnginePondering( ed->which ) ) {\r
821         char buf[8];\r
822 \r
823         buf[0] = '\0';\r
824 \r
825         if( ed->hint != 0 && *ed->hint != '\0' ) {\r
826             strncpy( buf, ed->hint, sizeof(buf) );\r
827             buf[sizeof(buf)-1] = '\0';\r
828         }\r
829         else if( ed->pv != 0 && *ed->pv != '\0' ) {\r
830             char * sep = strchr( ed->pv, ' ' );\r
831             int buflen = sizeof(buf);\r
832 \r
833             if( sep != NULL ) {\r
834                 buflen = sep - ed->pv + 1;\r
835                 if( buflen > sizeof(buf) ) buflen = sizeof(buf);\r
836             }\r
837 \r
838             strncpy( buf, ed->pv, buflen );\r
839             buf[ buflen-1 ] = '\0';\r
840         }\r
841 \r
842         SetEngineState( ed->which, STATE_PONDERING, buf );\r
843     }\r
844     else if( gameMode == TwoMachinesPlay ) {\r
845         SetEngineState( ed->which, STATE_THINKING, "" );\r
846     }\r
847     else if( gameMode == AnalyzeMode || gameMode == AnalyzeFile \r
848           || gameMode == IcsObserving && appData.icsEngineAnalyze) { // [HGM] ICS-analyze\r
849         char buf[64];\r
850         int time_secs = ed->time / 100;\r
851         int time_mins = time_secs / 60;\r
852 \r
853         buf[0] = '\0';\r
854 \r
855         if( ed->an_move_index != 0 && ed->an_move_count != 0 && *ed->hint != '\0' ) {\r
856             char mov[16];\r
857 \r
858             strncpy( mov, ed->hint, sizeof(mov) );\r
859             mov[ sizeof(mov)-1 ] = '\0';\r
860 \r
861             sprintf( buf, "%d/%d: %s [%02d:%02d:%02d]", ed->an_move_index, ed->an_move_count, mov, time_mins / 60, time_mins % 60, time_secs % 60 );\r
862         }\r
863 \r
864         SetEngineState( ed->which, STATE_ANALYZING, buf );\r
865     }\r
866     else {\r
867         SetEngineState( ed->which, STATE_IDLE, "" );\r
868     }\r
869 #endif\r
870 \r
871     DoSetWindowText( ed->which, nLabel, s_label );\r
872 \r
873     s_label[0] = '\0';\r
874 \r
875     if( ed->time > 0 && ed->nodes > 0 ) {\r
876         unsigned long nps_100 = ed->nodes / ed->time;\r
877 \r
878         if( nps_100 < 100000 ) {\r
879             sprintf( s_label, _("NPS: %lu"), nps_100 * 100 );\r
880         }\r
881         else {\r
882             sprintf( s_label, _("NPS: %.1fk"), nps_100 / 10.0 );\r
883         }\r
884     }\r
885 \r
886     DoSetWindowText( ed->which, nLabelNPS, s_label );\r
887 \r
888     /* Memo */\r
889     if( ed->pv != 0 && *ed->pv != '\0' ) {\r
890         char s_nodes[24];\r
891         char s_score[16];\r
892         char s_time[24];\r
893         char buf[256];\r
894         int buflen;\r
895         int time_secs = ed->time / 100;\r
896         int time_cent = ed->time % 100;\r
897 \r
898         /* Nodes */\r
899         if( ed->nodes < 1000000 ) {\r
900             sprintf( s_nodes, u64Display, ed->nodes );\r
901         }\r
902         else {\r
903             sprintf( s_nodes, "%.1fM", u64ToDouble(ed->nodes) / 1000000.0 );\r
904         }\r
905 \r
906         /* Score */\r
907         if( ed->score > 0 ) {\r
908             sprintf( s_score, "+%.2f", ed->score / 100.0 );\r
909         } else\r
910             sprintf( s_score, "%.2f", ed->score / 100.0 );\r
911 \r
912         /* Time */\r
913         sprintf( s_time, "%d:%02d.%02d", time_secs / 60, time_secs % 60, time_cent );\r
914 \r
915         /* Put all together... */\r
916         sprintf( buf, "%3d  %s  %s\t%s\t", ed->depth, s_score, s_nodes, s_time );\r
917 \r
918         /* Add PV */\r
919         buflen = strlen(buf);\r
920 \r
921         strncpy( buf + buflen, ed->pv, sizeof(buf) - buflen );\r
922 \r
923         buf[ sizeof(buf) - 3 ] = '\0';\r
924 \r
925         strcat( buf + buflen, "\n" );\r
926 \r
927         /* Update memo */\r
928         InsertIntoMemo( ed->which, buf );\r
929     }\r
930 \r
931     /* Colors */\r
932     SetEngineColorIcon( ed->which );\r
933 }\r
934 \r
935 // back end\r
936 int EngineOutputIsUp()\r
937 {\r
938     return engineOutputDialogUp;\r
939 }\r
940 \r
941 void\r
942 EngineOutputProc(w, event, prms, nprms)\r
943      Widget w;\r
944      XEvent *event;\r
945      String *prms;\r
946      Cardinal *nprms;\r
947 {\r
948   if (engineOutputDialogUp) {\r
949     EngineOutputPopDown();\r
950   } else {\r
951     EngineOutputPopUp(_("engine output"),_("This feature is experimental"));\r
952   }\r
953 //  ToNrEvent(currentMove);\r
954 }\r
955 \r
956 // [HGM] kibitz: write kibitz line; split window for it if necessary\r
957 void OutputKibitz(char *text)\r
958 {\r
959         if(!EngineOutputIsUp()) return;\r
960         if(!opponentKibitzes) DoClearMemo(1);\r
961         opponentKibitzes = TRUE; // thas causes split window DisplayMode in ICS modes.\r
962         VerifyDisplayMode();\r
963         DoSetWindowText(1, nLabel, gameMode == IcsPlayingWhite ? gameInfo.black : gameInfo.white); // opponent name\r
964         SetIcon( 1, nColorIcon,  gameMode == IcsPlayingWhite ? nColorBlack : nColorWhite);\r
965         InsertIntoMemo(1, text);\r
966 }\r