Split back-endish part off xoptions.c, and move to dialogs.c
[xboard.git] / xoptions.c
1 /*
2  * xoptions.c -- Move list window, part of X front end for XBoard
3  *
4  * Copyright 2000, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
5  * ------------------------------------------------------------------------
6  *
7  * GNU XBoard is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or (at
10  * your option) any later version.
11  *
12  * GNU XBoard is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program. If not, see http://www.gnu.org/licenses/.  *
19  *
20  *------------------------------------------------------------------------
21  ** See the file ChangeLog for a revision history.  */
22
23 // [HGM] this file is the counterpart of woptions.c, containing xboard popup menus
24 // similar to those of WinBoard, to set the most common options interactively.
25
26 #include "config.h"
27
28 #include <stdio.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #include <sys/types.h>
32
33 #if STDC_HEADERS
34 # include <stdlib.h>
35 # include <string.h>
36 #else /* not STDC_HEADERS */
37 extern char *getenv();
38 # if HAVE_STRING_H
39 #  include <string.h>
40 # else /* not HAVE_STRING_H */
41 #  include <strings.h>
42 # endif /* not HAVE_STRING_H */
43 #endif /* not STDC_HEADERS */
44
45 #if HAVE_UNISTD_H
46 # include <unistd.h>
47 #endif
48 #include <stdint.h>
49
50 #include <X11/Intrinsic.h>
51 #include <X11/StringDefs.h>
52 #include <X11/Shell.h>
53 #include <X11/Xatom.h>
54 #include <X11/Xaw/Dialog.h>
55 #include <X11/Xaw/Form.h>
56 #include <X11/Xaw/List.h>
57 #include <X11/Xaw/Label.h>
58 #include <X11/Xaw/SimpleMenu.h>
59 #include <X11/Xaw/SmeBSB.h>
60 #include <X11/Xaw/SmeLine.h>
61 #include <X11/Xaw/Box.h>
62 #include <X11/Xaw/Paned.h>
63 #include <X11/Xaw/MenuButton.h>
64 #include <X11/cursorfont.h>
65 #include <X11/Xaw/Text.h>
66 #include <X11/Xaw/AsciiText.h>
67 #include <X11/Xaw/Viewport.h>
68 #include <X11/Xaw/Toggle.h>
69
70 #include "common.h"
71 #include "backend.h"
72 #include "xboard.h"
73 #include "dialogs.h"
74 #include "gettext.h"
75
76 #ifdef ENABLE_NLS
77 # define  _(s) gettext (s)
78 # define N_(s) gettext_noop (s)
79 #else
80 # define  _(s) (s)
81 # define N_(s)  s
82 #endif
83
84 // [HGM] the following code for makng menu popups was cloned from the FileNamePopUp routines
85
86 static Widget previous = NULL;
87 static Option *currentOption;
88
89 void
90 SetFocus (Widget w, XtPointer data, XEvent *event, Boolean *b)
91 {
92     Arg args[2];
93     char *s;
94     int j;
95
96     if(previous) {
97         XtSetArg(args[0], XtNdisplayCaret, False);
98         XtSetValues(previous, args, 1);
99     }
100     XtSetArg(args[0], XtNstring, &s);
101     XtGetValues(w, args, 1);
102     j = 1;
103     XtSetArg(args[0], XtNdisplayCaret, True);
104     if(!strchr(s, '\n') && strlen(s) < 80) XtSetArg(args[1], XtNinsertPosition, strlen(s)), j++;
105     XtSetValues(w, args, j);
106     XtSetKeyboardFocus((Widget) data, w);
107     previous = w;
108 }
109
110 //--------------------------- Engine-specific options menu ----------------------------------
111
112 int dialogError;
113 static Boolean browserUp;
114
115 void
116 GetWidgetText (Option *opt, char **buf)
117 {
118     Arg arg;
119     XtSetArg(arg, XtNstring, buf);
120     XtGetValues(opt->handle, &arg, 1);
121 }
122
123 void
124 SetWidgetText (Option *opt, char *buf, int n)
125 {
126     Arg arg;
127     XtSetArg(arg, XtNstring, buf);
128     XtSetValues(opt->handle, &arg, 1);
129     if(n >= 0) SetFocus(opt->handle, shells[n], NULL, False);
130 }
131
132 void
133 GetWidgetState (Option *opt, int *state)
134 {
135     Arg arg;
136     XtSetArg(arg, XtNstate, state);
137     XtGetValues(opt->handle, &arg, 1);
138 }
139
140 void
141 SetWidgetState (Option *opt, int state)
142 {
143     Arg arg;
144     XtSetArg(arg, XtNstate, state);
145     XtSetValues(opt->handle, &arg, 1);
146 }
147
148 void
149 SetDialogTitle (DialogClass dlg, char *title)
150 {
151     Arg args[16];
152     XtSetArg(args[0], XtNtitle, title);
153     XtSetValues(shells[dlg], args, 1);
154 }
155
156 static void
157 CheckCallback (Widget ww, XtPointer data, XEvent *event, Boolean *b)
158 {
159     Widget w = currentOption[(int)(intptr_t)data].handle;
160     Boolean s;
161     Arg args[16];
162
163     XtSetArg(args[0], XtNstate, &s);
164     XtGetValues(w, args, 1);
165     SetWidgetState(&currentOption[(int)(intptr_t)data], !s);
166 }
167
168 static void
169 SpinCallback (Widget w, XtPointer client_data, XtPointer call_data)
170 {
171     String name, val;
172     Arg args[16];
173     char buf[MSG_SIZ], *p;
174     int j = 0; // Initialiasation is necessary because the text value may be non-numeric causing the scanf conversion to fail
175     int data = (intptr_t) client_data;
176
177     XtSetArg(args[0], XtNlabel, &name);
178     XtGetValues(w, args, 1);
179
180     GetWidgetText(&currentOption[data], &val);
181     sscanf(val, "%d", &j);
182     if (strcmp(name, _("browse")) == 0) {
183         char *q=val, *r;
184         for(r = ""; *q; q++) if(*q == '.') r = q; else if(*q == '/') r = ""; // last dot after last slash
185         if(!strcmp(r, "") && !currentCps && currentOption[data].type == FileName && currentOption[data].textValue)
186                 r = currentOption[data].textValue;
187         browserUp = True;
188         if(XsraSelFile(shells[TransientDlg], currentOption[data].name, NULL, NULL, "", "", r,
189                                   currentOption[data].type == PathName ? "p" : "f", NULL, &p)) {
190                 int len = strlen(p);
191                 if(len && p[len-1] == '/') p[len-1] = NULLCHAR;
192                 XtSetArg(args[0], XtNstring, p);
193                 XtSetValues(currentOption[data].handle, args, 1);
194         }
195         browserUp = False;
196         SetFocus(currentOption[data].handle, shells[TransientDlg], (XEvent*) NULL, False);
197         return;
198     } else
199     if (strcmp(name, "+") == 0) {
200         if(++j > currentOption[data].max) return;
201     } else
202     if (strcmp(name, "-") == 0) {
203         if(--j < currentOption[data].min) return;
204     } else return;
205     snprintf(buf, MSG_SIZ,  "%d", j);
206     SetWidgetText(&currentOption[data], buf, TransientDlg);
207 }
208
209 static void
210 ComboSelect (Widget w, caddr_t addr, caddr_t index) // callback for all combo items
211 {
212     Arg args[16];
213     int i = ((intptr_t)addr)>>8;
214     int j = 255 & (intptr_t) addr;
215
216     values[i] = j; // store in temporary, for transfer at OK
217
218     if(currentOption[i].min & NO_GETTEXT)
219       XtSetArg(args[0], XtNlabel, ((char**)currentOption[i].textValue)[j]);
220     else
221       XtSetArg(args[0], XtNlabel, _(((char**)currentOption[i].textValue)[j]));
222
223     XtSetValues(currentOption[i].handle, args, 1);
224
225     if(currentOption[i].min & COMBO_CALLBACK && !currentCps && comboCallback) (comboCallback)(i);
226 }
227
228 static void
229 CreateComboPopup (Widget parent, Option *option, int n)
230 {
231     int i=0, j;
232     Widget menu, entry;
233     Arg args[16];
234     char **mb = (char **) option->textValue;
235
236     if(mb[0] == NULL) return; // avoid empty menus, as they cause crash
237     menu = XtCreatePopupShell(option->name, simpleMenuWidgetClass,
238                               parent, NULL, 0);
239     j = 0;
240     XtSetArg(args[j], XtNwidth, 100);  j++;
241     while (mb[i] != NULL) 
242       {
243         if (option->min & NO_GETTEXT)
244           XtSetArg(args[j], XtNlabel, mb[i]);
245         else
246           XtSetArg(args[j], XtNlabel, _(mb[i]));
247         entry = XtCreateManagedWidget((String) mb[i], smeBSBObjectClass,
248                                       menu, args, j+1);
249         XtAddCallback(entry, XtNcallback,
250                       (XtCallbackProc) ComboSelect,
251                       (caddr_t)(intptr_t) (256*n+i));
252         i++;
253       }
254 }
255
256 char moveTypeInTranslations[] =
257     "<Key>Return: TypeInProc(1) \n"
258     "<Key>Escape: TypeInProc(0) \n";
259
260
261 char *translationTable[] = {
262    historyTranslations, commentTranslations, moveTypeInTranslations, ICSInputTranslations,
263 };
264
265 void
266 AddHandler (Option *opt, int nr)
267 {
268     XtOverrideTranslations(opt->handle, XtParseTranslationTable(translationTable[nr]));
269 }
270
271 //----------------------------Generic dialog --------------------------------------------
272
273 // cloned from Engine Settings dialog (and later merged with it)
274
275 Widget shells[NrOfDialogs];
276 WindowPlacement *wp[NrOfDialogs] = { NULL, &wpComment, &wpTags, NULL, NULL, NULL, NULL, &wpMoveHistory };
277 static Option *dialogOptions[NrOfDialogs];
278
279 int
280 DialogExists (DialogClass n)
281 {
282     return shells[n] != NULL;
283 }
284
285 int
286 PopDown (DialogClass n)
287 {
288     int j;
289     Arg args[10];
290     Dimension windowH, windowW; Position windowX, windowY;
291     if (!shellUp[n]) return 0;
292     if(n && wp[n]) { // remember position
293         j = 0;
294         XtSetArg(args[j], XtNx, &windowX); j++;
295         XtSetArg(args[j], XtNy, &windowY); j++;
296         XtSetArg(args[j], XtNheight, &windowH); j++;
297         XtSetArg(args[j], XtNwidth, &windowW); j++;
298         XtGetValues(shells[n], args, j);
299         wp[n]->x = windowX;
300         wp[n]->x = windowY;
301         wp[n]->width  = windowW;
302         wp[n]->height = windowH;
303     }
304     previous = NULL;
305     XtPopdown(shells[n]);
306     if(n == 0) XtDestroyWidget(shells[n]);
307     shellUp[n] = False;
308     if(marked[n]) {
309         MarkMenuItem(marked[n], False);
310         marked[n] = NULL;
311     }
312     if(!n) currentCps = NULL; // if an Engine Settings dialog was up, we must be popping it down now
313     return 1;
314 }
315
316 void
317 GenericPopDown (Widget w, XEvent *event, String *prms, Cardinal *nprms)
318 {
319     if(browserUp || dialogError) return; // prevent closing dialog when it has an open file-browse daughter
320     PopDown(prms[0][0] - '0');
321 }
322
323 int
324 AppendText (Option *opt, char *s)
325 {
326     XawTextBlock t;
327     char *v;
328     int len;
329     GetWidgetText(opt, &v);
330     len = strlen(v);
331     t.ptr = s; t.firstPos = 0; t.length = strlen(s); t.format = XawFmt8Bit;
332     XawTextReplace(opt->handle, len, len, &t);
333     return len;
334 }
335
336 void
337 SetColor (char *colorName, Option *box)
338 {
339         Arg args[5];
340         Pixel buttonColor;
341         XrmValue vFrom, vTo;
342         if (!appData.monoMode) {
343             vFrom.addr = (caddr_t) colorName;
344             vFrom.size = strlen(colorName);
345             XtConvert(shellWidget, XtRString, &vFrom, XtRPixel, &vTo);
346             if (vTo.addr == NULL) {
347                 buttonColor = (Pixel) -1;
348             } else {
349                 buttonColor = *(Pixel *) vTo.addr;
350             }
351         } else buttonColor = timerBackgroundPixel;
352         XtSetArg(args[0], XtNbackground, buttonColor);;
353         XtSetValues(box->handle, args, 1);
354 }
355
356 void
357 ColorChanged (Widget w, XtPointer data, XEvent *event, Boolean *b)
358 {
359     char buf[10];
360     if ( (XLookupString(&(event->xkey), buf, 2, NULL, NULL) == 1) && *buf == '\r' )
361         RefreshColor((int)(intptr_t) data, 0);
362 }
363
364 void
365 GenericCallback (Widget w, XtPointer client_data, XtPointer call_data)
366 {
367     String name;
368     Arg args[16];
369     char buf[MSG_SIZ];
370     int data = (intptr_t) client_data;
371
372     currentOption = dialogOptions[data>>16]; data &= 0xFFFF;
373
374     XtSetArg(args[0], XtNlabel, &name);
375     XtGetValues(w, args, 1);
376
377     if (strcmp(name, _("cancel")) == 0) {
378         PopDown(data);
379         return;
380     }
381     if (strcmp(name, _("OK")) == 0) { // save buttons imply OK
382         if(GenericReadout(currentOption, -1)) PopDown(data);
383         return;
384     }
385     if(currentCps) {
386         if(currentOption[data].type == SaveButton) GenericReadout(currentOption, -1);
387         snprintf(buf, MSG_SIZ,  "option %s\n", name);
388         SendToProgram(buf, currentCps);
389     } else ((ButtonCallback*) currentOption[data].target)(data);
390 }
391
392 static char *oneLiner  = "<Key>Return:  redraw-display()\n";
393
394 int
395 GenericPopUp (Option *option, char *title, DialogClass dlgNr)
396 {
397     Arg args[16];
398     Widget popup, layout, dialog=NULL, edit=NULL, form,  last, b_ok, b_cancel, leftMargin = NULL, textField = NULL;
399     Window root, child;
400     int x, y, i, j, height=999, width=1, h, c, w, shrink=FALSE;
401     int win_x, win_y, maxWidth, maxTextWidth;
402     unsigned int mask;
403     char def[MSG_SIZ], *msg;
404     static char pane[6] = "paneX";
405     Widget texts[100], forelast = NULL, anchor, widest, lastrow = NULL, browse = NULL;
406     Dimension bWidth = 50;
407
408     if(shellUp[dlgNr]) return 0; // already up          
409     if(dlgNr && shells[dlgNr]) {
410         XtPopup(shells[dlgNr], XtGrabNone);
411         shellUp[dlgNr] = True;
412         return 0;
413     }
414
415     dialogOptions[dlgNr] = option; // make available to callback
416     // post currentOption globally, so Spin and Combo callbacks can already use it
417     // WARNING: this kludge does not work for persistent dialogs, so that these cannot have spin or combo controls!
418     currentOption = option;
419
420     if(currentCps) { // Settings popup for engine: format through heuristic
421         int n = currentCps->nrOptions;
422         if(!n) { DisplayNote(_("Engine has no options")); currentCps = NULL; return 0; }
423         if(n > 50) width = 4; else if(n>24) width = 2; else width = 1;
424         height = n / width + 1;
425         if(n && (currentOption[n-1].type == Button || currentOption[n-1].type == SaveButton)) currentOption[n].min = SAME_ROW; // OK on same line
426         currentOption[n].type = EndMark; currentOption[n].target = NULL; // delimit list by callback-less end mark
427     }
428      i = 0;
429     XtSetArg(args[i], XtNresizable, True); i++;
430     popup = shells[dlgNr] =
431       XtCreatePopupShell(title, transientShellWidgetClass,
432                          shellWidget, args, i);
433
434     layout =
435       XtCreateManagedWidget(layoutName, formWidgetClass, popup,
436                             layoutArgs, XtNumber(layoutArgs));
437   for(c=0; c<width; c++) {
438     pane[4] = 'A'+c;
439     form =
440       XtCreateManagedWidget(pane, formWidgetClass, layout,
441                             formArgs, XtNumber(formArgs));
442     j=0;
443     XtSetArg(args[j], XtNfromHoriz, leftMargin);  j++;
444     XtSetValues(form, args, j);
445     leftMargin = form;
446
447     last = widest = NULL; anchor = lastrow;
448     for(h=0; h<height; h++) {
449         i = h + c*height;
450         if(option[i].type == EndMark) break;
451         lastrow = forelast;
452         forelast = last;
453         switch(option[i].type) {
454           case Fractional:
455             snprintf(def, MSG_SIZ,  "%.2f", *(float*)option[i].target);
456             option[i].value = *(float*)option[i].target;
457             goto tBox;
458           case Spin:
459             if(!currentCps) option[i].value = *(int*)option[i].target;
460             snprintf(def, MSG_SIZ,  "%d", option[i].value);
461           case TextBox:
462           case FileName:
463           case PathName:
464           tBox:
465             if(option[i].name[0]) {
466             j=0;
467             XtSetArg(args[j], XtNfromVert, last);  j++;
468             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
469             XtSetArg(args[j], XtNright, XtChainLeft); j++;
470             XtSetArg(args[j], XtNheight, textHeight),  j++;
471             XtSetArg(args[j], XtNborderWidth, 0);  j++;
472             XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
473             XtSetArg(args[j], XtNlabel, _(option[i].name));  j++;
474             texts[h] =
475             dialog = XtCreateManagedWidget(option[i].name, labelWidgetClass, form, args, j);
476             } else texts[h] = dialog = NULL;
477             w = option[i].type == Spin || option[i].type == Fractional ? 70 : option[i].max ? option[i].max : 205;
478             if(option[i].type == FileName || option[i].type == PathName) w -= 55;
479             j=0;
480             XtSetArg(args[j], XtNfromVert, last);  j++;
481             XtSetArg(args[j], XtNfromHoriz, dialog);  j++;
482             XtSetArg(args[j], XtNborderWidth, 1); j++;
483             XtSetArg(args[j], XtNwidth, w); j++;
484             if(option[i].type == TextBox && option[i].min) {
485                 XtSetArg(args[j], XtNheight, option[i].min); j++;
486                 if(option[i].value & 1) { XtSetArg(args[j], XtNscrollVertical, XawtextScrollAlways);  j++; }
487                 if(option[i].value & 2) { XtSetArg(args[j], XtNscrollHorizontal, XawtextScrollAlways);  j++; }
488                 if(option[i].value & 4) { XtSetArg(args[j], XtNautoFill, True);  j++; }
489                 if(option[i].value & 8) { XtSetArg(args[j], XtNwrap, XawtextWrapWord); j++; }
490             } else shrink = TRUE;
491             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
492             XtSetArg(args[j], XtNeditType, XawtextEdit);  j++;
493             XtSetArg(args[j], XtNuseStringInPlace, False);  j++;
494             XtSetArg(args[j], XtNdisplayCaret, False);  j++;
495             XtSetArg(args[j], XtNright, XtChainRight);  j++;
496             XtSetArg(args[j], XtNresizable, True);  j++;
497             XtSetArg(args[j], XtNinsertPosition, 9999);  j++;
498             XtSetArg(args[j], XtNstring, option[i].type==Spin || option[i].type==Fractional ? def : 
499                                 currentCps ? option[i].textValue : *(char**)option[i].target);  j++;
500             edit = last;
501             option[i].handle = (void*)
502                 (textField = last = XtCreateManagedWidget("text", asciiTextWidgetClass, form, args, j));
503             XtAddEventHandler(last, ButtonPressMask, False, SetFocus, (XtPointer) popup);
504             if(option[i].min == 0 || option[i].type != TextBox)
505                 XtOverrideTranslations(last, XtParseTranslationTable(oneLiner));
506
507             if(option[i].type == TextBox || option[i].type == Fractional) break;
508
509             // add increment and decrement controls for spin
510             j=0;
511             XtSetArg(args[j], XtNfromVert, edit);  j++;
512             XtSetArg(args[j], XtNfromHoriz, last);  j++;
513             XtSetArg(args[j], XtNleft, XtChainRight); j++;
514             XtSetArg(args[j], XtNright, XtChainRight); j++;
515             if(option[i].type == FileName || option[i].type == PathName) {
516                 msg = _("browse"); w = 0;
517                 /* automatically scale to width of text */
518                 XtSetArg(args[j], XtNwidth, (XtArgVal) NULL );  j++;
519                 if(textHeight) XtSetArg(args[j], XtNheight, textHeight),  j++;
520             } else {
521                 w = 20; msg = "+";
522                 XtSetArg(args[j], XtNheight, textHeight/2);  j++;
523                 XtSetArg(args[j], XtNwidth,   w);  j++;
524             }
525             edit = XtCreateManagedWidget(msg, commandWidgetClass, form, args, j);
526             XtAddCallback(edit, XtNcallback, SpinCallback, (XtPointer)(intptr_t) i);
527             if(w == 0) browse = edit;
528
529             if(option[i].type != Spin) break;
530
531             j=0;
532             XtSetArg(args[j], XtNfromVert, edit);  j++;
533             XtSetArg(args[j], XtNfromHoriz, last);  j++;
534             XtSetArg(args[j], XtNvertDistance, -1);  j++;
535             XtSetArg(args[j], XtNheight, textHeight/2);  j++;
536             XtSetArg(args[j], XtNwidth, 20);  j++;
537             XtSetArg(args[j], XtNleft, XtChainRight); j++;
538             XtSetArg(args[j], XtNright, XtChainRight); j++;
539             last = XtCreateManagedWidget("-", commandWidgetClass, form, args, j);
540             XtAddCallback(last, XtNcallback, SpinCallback, (XtPointer)(intptr_t) i);
541             break;
542           case CheckBox:
543             if(!currentCps) option[i].value = *(Boolean*)option[i].target;
544             j=0;
545             XtSetArg(args[j], XtNfromVert, last);  j++;
546             XtSetArg(args[j], XtNvertDistance, (textHeight+2)/4 + 3);  j++;
547             XtSetArg(args[j], XtNwidth, textHeight/2);  j++;
548             XtSetArg(args[j], XtNheight, textHeight/2);  j++;
549             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
550             XtSetArg(args[j], XtNright, XtChainLeft); j++;
551             XtSetArg(args[j], XtNstate, option[i].value);  j++;
552             option[i].handle = (void*)
553                 (dialog = XtCreateManagedWidget(" ", toggleWidgetClass, form, args, j));
554           case Label:
555             msg = option[i].name;
556             if(*msg == NULLCHAR) msg = option[i].textValue;
557             if(!msg) break;
558             j=0;
559             XtSetArg(args[j], XtNfromVert, last);  j++;
560             XtSetArg(args[j], XtNfromHoriz, option[i].type != Label ? dialog : NULL);  j++;
561             if(option[i].type != Label) XtSetArg(args[j], XtNheight, textHeight),  j++, shrink = TRUE;
562             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
563             XtSetArg(args[j], XtNborderWidth, 0);  j++;
564             XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
565             XtSetArg(args[j], XtNlabel, _(msg));  j++;
566             last = XtCreateManagedWidget(msg, labelWidgetClass, form, args, j);
567             if(option[i].type == CheckBox)
568                 XtAddEventHandler(last, ButtonPressMask, False, CheckCallback, (XtPointer)(intptr_t) i);
569             break;
570           case SaveButton:
571           case Button:
572             j=0;
573             if(option[i].min & SAME_ROW) {
574                 XtSetArg(args[j], XtNfromVert, lastrow);  j++;
575                 XtSetArg(args[j], XtNfromHoriz, last);  j++;
576                 XtSetArg(args[j], XtNleft, XtChainRight); j++;
577                 XtSetArg(args[j], XtNright, XtChainRight); j++;
578                 if(shrink) XtSetArg(args[j], XtNheight, textHeight),  j++;
579             } else {
580                 XtSetArg(args[j], XtNfromVert, last);  j++;
581                 XtSetArg(args[j], XtNfromHoriz, NULL);  j++; lastrow = forelast;
582                 shrink = FALSE;
583             }
584             XtSetArg(args[j], XtNlabel, _(option[i].name));  j++;
585             if(option[i].max) { XtSetArg(args[j], XtNwidth, option[i].max);  j++; }
586             if(option[i].textValue) { // special for buttons of New Variant dialog
587                 XtSetArg(args[j], XtNsensitive, appData.noChessProgram || option[i].value < 0
588                                          || strstr(first.variants, VariantName(option[i].value))); j++;
589                 XtSetArg(args[j], XtNborderWidth, (gameInfo.variant == option[i].value)+1); j++;
590             }
591             option[i].handle = (void*)
592                 (dialog = last = XtCreateManagedWidget(option[i].name, commandWidgetClass, form, args, j));
593             if(option[i].choice && ((char*)option[i].choice)[0] == '#' && !currentCps) {
594                 SetColor( *(char**) option[i-1].target, &option[i]);
595                 XtAddEventHandler(option[i-1].handle, KeyReleaseMask, False, ColorChanged, (XtPointer)(intptr_t) i-1);
596             }
597             XtAddCallback(last, XtNcallback, GenericCallback,
598                           (XtPointer)(intptr_t) i + (dlgNr<<16));
599             if(option[i].textValue) SetColor( option[i].textValue, &option[i]);
600             forelast = lastrow; // next button can go on same row
601             break;
602           case ComboBox:
603             j=0;
604             XtSetArg(args[j], XtNfromVert, last);  j++;
605             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
606             XtSetArg(args[j], XtNright, XtChainLeft); j++;
607             XtSetArg(args[j], XtNheight, textHeight),  j++;
608             XtSetArg(args[j], XtNborderWidth, 0);  j++;
609             XtSetArg(args[j], XtNjustify, XtJustifyLeft);  j++;
610             XtSetArg(args[j], XtNlabel, _(option[i].name));  j++;
611             texts[h] = dialog = XtCreateManagedWidget(option[i].name, labelWidgetClass, form, args, j);
612
613             if(currentCps) option[i].choice = (char**) option[i].textValue; else {
614               for(j=0; option[i].choice[j]; j++)
615                 if(*(char**)option[i].target && !strcmp(*(char**)option[i].target, option[i].choice[j])) break;
616               option[i].value = j + (option[i].choice[j] == NULL);
617             }
618
619             j=0;
620             XtSetArg(args[j], XtNfromVert, last);  j++;
621             XtSetArg(args[j], XtNfromHoriz, dialog);  j++;
622             XtSetArg(args[j], XtNwidth, option[i].max && !currentCps ? option[i].max : 100);  j++;
623             XtSetArg(args[j], XtNleft, XtChainLeft); j++;
624             XtSetArg(args[j], XtNmenuName, XtNewString(option[i].name));  j++;
625             XtSetArg(args[j], XtNlabel, _(((char**)option[i].textValue)[option[i].value]));  j++;
626             XtSetArg(args[j], XtNheight, textHeight),  j++;
627             shrink = TRUE;
628             option[i].handle = (void*)
629                 (last = XtCreateManagedWidget(" ", menuButtonWidgetClass, form, args, j));
630             CreateComboPopup(last, option + i, i);
631             values[i] = option[i].value;
632             break;
633           case Break:
634             width++;
635             height = i+1;
636             break;
637         default:
638             printf("GenericPopUp: unexpected case in switch.\n");
639             break;
640         }
641     }
642
643     // make an attempt to align all spins and textbox controls
644     maxWidth = maxTextWidth = 0;
645     if(browse != NULL) {
646         j=0;
647         XtSetArg(args[j], XtNwidth, &bWidth);  j++;
648         XtGetValues(browse, args, j);
649     }
650     for(h=0; h<height; h++) {
651         i = h + c*height;
652         if(option[i].type == EndMark) break;
653         if(option[i].type == Spin || option[i].type == TextBox || option[i].type == ComboBox
654                                   || option[i].type == PathName || option[i].type == FileName) {
655             Dimension w;
656             if(!texts[h]) continue;
657             j=0;
658             XtSetArg(args[j], XtNwidth, &w);  j++;
659             XtGetValues(texts[h], args, j);
660             if(option[i].type == Spin) {
661                 if(w > maxWidth) maxWidth = w;
662                 widest = texts[h];
663             } else {
664                 if(w > maxTextWidth) maxTextWidth = w;
665                 if(!widest) widest = texts[h];
666             }
667         }
668     }
669     if(maxTextWidth + 110 < maxWidth)
670          maxTextWidth = maxWidth - 110;
671     else maxWidth = maxTextWidth + 110;
672     for(h=0; h<height; h++) {
673         i = h + c*height;
674         if(option[i].type == EndMark) break;
675         if(!texts[h]) continue; // Note: texts[h] can be undefined (giving errors in valgrind), but then both if's below will be false.
676         j=0;
677         if(option[i].type == Spin) {
678             XtSetArg(args[j], XtNwidth, maxWidth);  j++;
679             XtSetValues(texts[h], args, j);
680         } else
681         if(option[i].type == TextBox || option[i].type == ComboBox || option[i].type == PathName || option[i].type == FileName) {
682             XtSetArg(args[j], XtNwidth, maxTextWidth);  j++;
683             XtSetValues(texts[h], args, j);
684             if(bWidth != 50 && (option[i].type == FileName || option[i].type == PathName)) {
685                 int tWidth = (option[i].max ? option[i].max : 205) - 5 - bWidth;
686                 j = 0;
687                 XtSetArg(args[j], XtNwidth, tWidth);  j++;
688                 XtSetValues(option[i].handle, args, j);
689             }
690         }
691     }
692   }
693
694   if(!(option[i].min & NO_OK)) {
695     j=0;
696     if(option[i].min & SAME_ROW) {
697         for(j=i-1; option[j+1].min & SAME_ROW && option[j].type == Button; j--) {
698             XtSetArg(args[0], XtNtop, XtChainBottom);
699             XtSetArg(args[1], XtNbottom, XtChainBottom);
700             XtSetValues(option[j].handle, args, 2);
701         }
702         if(option[j].type == TextBox && option[j].name[0] == NULLCHAR) {
703             XtSetArg(args[0], XtNbottom, XtChainBottom);
704             XtSetValues(option[j].handle, args, 1);
705         }
706         j = 0;
707         XtSetArg(args[j], XtNfromHoriz, last); last = forelast;
708     } else shrink = FALSE,
709     XtSetArg(args[j], XtNfromHoriz, widest ? widest : dialog);  j++;
710     XtSetArg(args[j], XtNfromVert, anchor ? anchor : last);  j++;
711     XtSetArg(args[j], XtNbottom, XtChainBottom);  j++;
712     XtSetArg(args[j], XtNtop, XtChainBottom);  j++;
713     XtSetArg(args[j], XtNleft, XtChainRight);  j++;
714     XtSetArg(args[j], XtNright, XtChainRight);  j++;
715     if(shrink) XtSetArg(args[j], XtNheight, textHeight),  j++;
716     b_ok = XtCreateManagedWidget(_("OK"), commandWidgetClass, form, args, j);
717     XtAddCallback(b_ok, XtNcallback, GenericCallback, (XtPointer)(intptr_t) dlgNr + (dlgNr<<16));
718
719     XtSetArg(args[0], XtNfromHoriz, b_ok);
720     b_cancel = XtCreateManagedWidget(_("cancel"), commandWidgetClass, form, args, j);
721     XtAddCallback(b_cancel, XtNcallback, GenericCallback, (XtPointer)(intptr_t) dlgNr);
722   }
723
724     XtRealizeWidget(popup);
725     XSetWMProtocols(xDisplay, XtWindow(popup), &wm_delete_window, 1);
726     snprintf(def, MSG_SIZ, "<Message>WM_PROTOCOLS: GenericPopDown(\"%d\") \n", dlgNr);
727     XtAugmentTranslations(popup, XtParseTranslationTable(def));
728     XQueryPointer(xDisplay, xBoardWindow, &root, &child,
729                   &x, &y, &win_x, &win_y, &mask);
730
731     XtSetArg(args[0], XtNx, x - 10);
732     XtSetArg(args[1], XtNy, y - 30);
733     XtSetValues(popup, args, 2);
734
735     XtPopup(popup, dlgNr ? XtGrabNone : XtGrabExclusive);
736     shellUp[dlgNr] = True;
737     previous = NULL;
738     if(textField)SetFocus(textField, popup, (XEvent*) NULL, False);
739     if(dlgNr && wp[dlgNr] && wp[dlgNr]->width > 0) { // if persistent window-info available, reposition
740         j = 0;
741         XtSetArg(args[j], XtNheight, (Dimension) (wp[dlgNr]->height));  j++;
742         XtSetArg(args[j], XtNwidth,  (Dimension) (wp[dlgNr]->width));  j++;
743         XtSetArg(args[j], XtNx, (Position) (wp[dlgNr]->x));  j++;
744         XtSetArg(args[j], XtNy, (Position) (wp[dlgNr]->y));  j++;
745         XtSetValues(popup, args, j);
746     }
747     return 1;
748 }
749
750
751 /* function called when the data to Paste is ready */
752 static void
753 SendTextCB (Widget w, XtPointer client_data, Atom *selection,
754             Atom *type, XtPointer value, unsigned long *len, int *format)
755 {
756   char buf[MSG_SIZ], *p = (char*) textOptions[(int)(intptr_t) client_data].choice, *name = (char*) value, *q;
757   if (value==NULL || *len==0) return; /* nothing selected, abort */
758   name[*len]='\0';
759   strncpy(buf, p, MSG_SIZ);
760   q = strstr(p, "$name");
761   snprintf(buf + (q-p), MSG_SIZ -(q-p), "%s%s", name, q+5);
762   SendString(buf);
763   XtFree(value);
764 }
765
766 void
767 SendText (int n)
768 {
769     char *p = (char*) textOptions[n].choice;
770     if(strstr(p, "$name")) {
771         XtGetSelectionValue(menuBarWidget,
772           XA_PRIMARY, XA_STRING,
773           /* (XtSelectionCallbackProc) */ SendTextCB,
774           (XtPointer) (intptr_t) n, /* client_data passed to PastePositionCB */
775           CurrentTime
776         );
777     } else SendString(p);
778 }
779
780 void
781 SetInsertPos (Option *opt, int pos)
782 {
783     Arg args[16];
784     XtSetArg(args[0], XtNinsertPosition, pos);
785     XtSetValues(opt->handle, args, 1);
786 //    SetFocus(opt->handle, shells[InputBoxDlg], NULL, False); // No idea why this does not work, and the following is needed:
787     XSetInputFocus(xDisplay, XtWindow(opt->handle), RevertToPointerRoot, CurrentTime);
788 }
789
790 void
791 TypeInProc (Widget w, XEvent *event, String *prms, Cardinal *nprms)
792 {
793     char *val;
794
795     if(prms[0][0] == '1') {
796         GetWidgetText(&boxOptions[0], &val);
797         TypeInDoneEvent(val);
798     }
799     PopDown(TransientDlg);
800 }
801
802 void
803 HardSetFocus (Option *opt)
804 {
805     XSetInputFocus(xDisplay, XtWindow(opt->handle), RevertToPointerRoot, CurrentTime);
806 }
807
808