OSDN Git Service

Fix bugs of simultaneous connection.
[ffftp/ffftp.git] / putty / DIALOG.C
1 /*\r
2  * dialog.c - a reasonably platform-independent mechanism for\r
3  * describing dialog boxes.\r
4  */\r
5 \r
6 #include <assert.h>\r
7 #include <limits.h>\r
8 #include <stdarg.h>\r
9 #include <stdlib.h>\r
10 \r
11 #define DEFINE_INTORPTR_FNS\r
12 \r
13 #include "putty.h"\r
14 #include "dialog.h"\r
15 \r
16 int ctrl_path_elements(char *path)\r
17 {\r
18     int i = 1;\r
19     while (*path) {\r
20         if (*path == '/') i++;\r
21         path++;\r
22     }\r
23     return i;\r
24 }\r
25 \r
26 /* Return the number of matching path elements at the starts of p1 and p2,\r
27  * or INT_MAX if the paths are identical. */\r
28 int ctrl_path_compare(char *p1, char *p2)\r
29 {\r
30     int i = 0;\r
31     while (*p1 || *p2) {\r
32         if ((*p1 == '/' || *p1 == '\0') &&\r
33             (*p2 == '/' || *p2 == '\0'))\r
34             i++;                       /* a whole element matches, ooh */\r
35         if (*p1 != *p2)\r
36             return i;                  /* mismatch */\r
37         p1++, p2++;\r
38     }\r
39     return INT_MAX;                    /* exact match */\r
40 }\r
41 \r
42 struct controlbox *ctrl_new_box(void)\r
43 {\r
44     struct controlbox *ret = snew(struct controlbox);\r
45 \r
46     ret->nctrlsets = ret->ctrlsetsize = 0;\r
47     ret->ctrlsets = NULL;\r
48     ret->nfrees = ret->freesize = 0;\r
49     ret->frees = NULL;\r
50 \r
51     return ret;\r
52 }\r
53 \r
54 void ctrl_free_box(struct controlbox *b)\r
55 {\r
56     int i;\r
57 \r
58     for (i = 0; i < b->nctrlsets; i++) {\r
59         ctrl_free_set(b->ctrlsets[i]);\r
60     }\r
61     for (i = 0; i < b->nfrees; i++)\r
62         sfree(b->frees[i]);\r
63     sfree(b->ctrlsets);\r
64     sfree(b->frees);\r
65     sfree(b);\r
66 }\r
67 \r
68 void ctrl_free_set(struct controlset *s)\r
69 {\r
70     int i;\r
71 \r
72     sfree(s->pathname);\r
73     sfree(s->boxname);\r
74     sfree(s->boxtitle);\r
75     for (i = 0; i < s->ncontrols; i++) {\r
76         ctrl_free(s->ctrls[i]);\r
77     }\r
78     sfree(s->ctrls);\r
79     sfree(s);\r
80 }\r
81 \r
82 /*\r
83  * Find the index of first controlset in a controlbox for a given\r
84  * path. If that path doesn't exist, return the index where it\r
85  * should be inserted.\r
86  */\r
87 static int ctrl_find_set(struct controlbox *b, char *path, int start)\r
88 {\r
89     int i, last, thisone;\r
90 \r
91     last = 0;\r
92     for (i = 0; i < b->nctrlsets; i++) {\r
93         thisone = ctrl_path_compare(path, b->ctrlsets[i]->pathname);\r
94         /*\r
95          * If `start' is true and there exists a controlset with\r
96          * exactly the path we've been given, we should return the\r
97          * index of the first such controlset we find. Otherwise,\r
98          * we should return the index of the first entry in which\r
99          * _fewer_ path elements match than they did last time.\r
100          */\r
101         if ((start && thisone == INT_MAX) || thisone < last)\r
102             return i;\r
103         last = thisone;\r
104     }\r
105     return b->nctrlsets;               /* insert at end */\r
106 }\r
107 \r
108 /*\r
109  * Find the index of next controlset in a controlbox for a given\r
110  * path, or -1 if no such controlset exists. If -1 is passed as\r
111  * input, finds the first.\r
112  */\r
113 int ctrl_find_path(struct controlbox *b, char *path, int index)\r
114 {\r
115     if (index < 0)\r
116         index = ctrl_find_set(b, path, 1);\r
117     else\r
118         index++;\r
119 \r
120     if (index < b->nctrlsets && !strcmp(path, b->ctrlsets[index]->pathname))\r
121         return index;\r
122     else\r
123         return -1;\r
124 }\r
125 \r
126 /* Set up a panel title. */\r
127 struct controlset *ctrl_settitle(struct controlbox *b,\r
128                                  char *path, char *title)\r
129 {\r
130     \r
131     struct controlset *s = snew(struct controlset);\r
132     int index = ctrl_find_set(b, path, 1);\r
133     s->pathname = dupstr(path);\r
134     s->boxname = NULL;\r
135     s->boxtitle = dupstr(title);\r
136     s->ncontrols = s->ctrlsize = 0;\r
137     s->ncolumns = 0;                   /* this is a title! */\r
138     s->ctrls = NULL;\r
139     if (b->nctrlsets >= b->ctrlsetsize) {\r
140         b->ctrlsetsize = b->nctrlsets + 32;\r
141         b->ctrlsets = sresize(b->ctrlsets, b->ctrlsetsize,struct controlset *);\r
142     }\r
143     if (index < b->nctrlsets)\r
144         memmove(&b->ctrlsets[index+1], &b->ctrlsets[index],\r
145                 (b->nctrlsets-index) * sizeof(*b->ctrlsets));\r
146     b->ctrlsets[index] = s;\r
147     b->nctrlsets++;\r
148     return s;\r
149 }\r
150 \r
151 /* Retrieve a pointer to a controlset, creating it if absent. */\r
152 struct controlset *ctrl_getset(struct controlbox *b,\r
153                                char *path, char *name, char *boxtitle)\r
154 {\r
155     struct controlset *s;\r
156     int index = ctrl_find_set(b, path, 1);\r
157     while (index < b->nctrlsets &&\r
158            !strcmp(b->ctrlsets[index]->pathname, path)) {\r
159         if (b->ctrlsets[index]->boxname &&\r
160             !strcmp(b->ctrlsets[index]->boxname, name))\r
161             return b->ctrlsets[index];\r
162         index++;\r
163     }\r
164     s = snew(struct controlset);\r
165     s->pathname = dupstr(path);\r
166     s->boxname = dupstr(name);\r
167     s->boxtitle = boxtitle ? dupstr(boxtitle) : NULL;\r
168     s->ncolumns = 1;\r
169     s->ncontrols = s->ctrlsize = 0;\r
170     s->ctrls = NULL;\r
171     if (b->nctrlsets >= b->ctrlsetsize) {\r
172         b->ctrlsetsize = b->nctrlsets + 32;\r
173         b->ctrlsets = sresize(b->ctrlsets, b->ctrlsetsize,struct controlset *);\r
174     }\r
175     if (index < b->nctrlsets)\r
176         memmove(&b->ctrlsets[index+1], &b->ctrlsets[index],\r
177                 (b->nctrlsets-index) * sizeof(*b->ctrlsets));\r
178     b->ctrlsets[index] = s;\r
179     b->nctrlsets++;\r
180     return s;\r
181 }\r
182 \r
183 /* Allocate some private data in a controlbox. */\r
184 void *ctrl_alloc(struct controlbox *b, size_t size)\r
185 {\r
186     void *p;\r
187     /*\r
188      * This is an internal allocation routine, so it's allowed to\r
189      * use smalloc directly.\r
190      */\r
191     p = smalloc(size);\r
192     if (b->nfrees >= b->freesize) {\r
193         b->freesize = b->nfrees + 32;\r
194         b->frees = sresize(b->frees, b->freesize, void *);\r
195     }\r
196     b->frees[b->nfrees++] = p;\r
197     return p;\r
198 }\r
199 \r
200 static union control *ctrl_new(struct controlset *s, int type,\r
201                                intorptr helpctx, handler_fn handler,\r
202                                intorptr context)\r
203 {\r
204     union control *c = snew(union control);\r
205     if (s->ncontrols >= s->ctrlsize) {\r
206         s->ctrlsize = s->ncontrols + 32;\r
207         s->ctrls = sresize(s->ctrls, s->ctrlsize, union control *);\r
208     }\r
209     s->ctrls[s->ncontrols++] = c;\r
210     /*\r
211      * Fill in the standard fields.\r
212      */\r
213     c->generic.type = type;\r
214     c->generic.tabdelay = 0;\r
215     c->generic.column = COLUMN_FIELD(0, s->ncolumns);\r
216     c->generic.helpctx = helpctx;\r
217     c->generic.handler = handler;\r
218     c->generic.context = context;\r
219     c->generic.label = NULL;\r
220     return c;\r
221 }\r
222 \r
223 /* `ncolumns' is followed by that many percentages, as integers. */\r
224 union control *ctrl_columns(struct controlset *s, int ncolumns, ...)\r
225 {\r
226     union control *c = ctrl_new(s, CTRL_COLUMNS, P(NULL), NULL, P(NULL));\r
227     assert(s->ncolumns == 1 || ncolumns == 1);\r
228     c->columns.ncols = ncolumns;\r
229     s->ncolumns = ncolumns;\r
230     if (ncolumns == 1) {\r
231         c->columns.percentages = NULL;\r
232     } else {\r
233         va_list ap;\r
234         int i;\r
235         c->columns.percentages = snewn(ncolumns, int);\r
236         va_start(ap, ncolumns);\r
237         for (i = 0; i < ncolumns; i++)\r
238             c->columns.percentages[i] = va_arg(ap, int);\r
239         va_end(ap);\r
240     }\r
241     return c;\r
242 }\r
243 \r
244 union control *ctrl_editbox(struct controlset *s, char *label, char shortcut,\r
245                             int percentage,\r
246                             intorptr helpctx, handler_fn handler,\r
247                             intorptr context, intorptr context2)\r
248 {\r
249     union control *c = ctrl_new(s, CTRL_EDITBOX, helpctx, handler, context);\r
250     c->editbox.label = label ? dupstr(label) : NULL;\r
251     c->editbox.shortcut = shortcut;\r
252     c->editbox.percentwidth = percentage;\r
253     c->editbox.password = 0;\r
254     c->editbox.has_list = 0;\r
255     c->editbox.context2 = context2;\r
256     return c;\r
257 }\r
258 \r
259 union control *ctrl_combobox(struct controlset *s, char *label, char shortcut,\r
260                              int percentage,\r
261                              intorptr helpctx, handler_fn handler,\r
262                              intorptr context, intorptr context2)\r
263 {\r
264     union control *c = ctrl_new(s, CTRL_EDITBOX, helpctx, handler, context);\r
265     c->editbox.label = label ? dupstr(label) : NULL;\r
266     c->editbox.shortcut = shortcut;\r
267     c->editbox.percentwidth = percentage;\r
268     c->editbox.password = 0;\r
269     c->editbox.has_list = 1;\r
270     c->editbox.context2 = context2;\r
271     return c;\r
272 }\r
273 \r
274 /*\r
275  * `ncolumns' is followed by (alternately) radio button titles and\r
276  * intorptrs, until a NULL in place of a title string is seen. Each\r
277  * title is expected to be followed by a shortcut _iff_ `shortcut'\r
278  * is NO_SHORTCUT.\r
279  */\r
280 union control *ctrl_radiobuttons(struct controlset *s, char *label,\r
281                                  char shortcut, int ncolumns, intorptr helpctx,\r
282                                  handler_fn handler, intorptr context, ...)\r
283 {\r
284     va_list ap;\r
285     int i;\r
286     union control *c = ctrl_new(s, CTRL_RADIO, helpctx, handler, context);\r
287     c->radio.label = label ? dupstr(label) : NULL;\r
288     c->radio.shortcut = shortcut;\r
289     c->radio.ncolumns = ncolumns;\r
290     /*\r
291      * Initial pass along variable argument list to count the\r
292      * buttons.\r
293      */\r
294     va_start(ap, context);\r
295     i = 0;\r
296     while (va_arg(ap, char *) != NULL) {\r
297         i++;\r
298         if (c->radio.shortcut == NO_SHORTCUT)\r
299             (void)va_arg(ap, int);     /* char promotes to int in arg lists */\r
300         (void)va_arg(ap, intorptr);\r
301     }\r
302     va_end(ap);\r
303     c->radio.nbuttons = i;\r
304     if (c->radio.shortcut == NO_SHORTCUT)\r
305         c->radio.shortcuts = snewn(c->radio.nbuttons, char);\r
306     else\r
307         c->radio.shortcuts = NULL;\r
308     c->radio.buttons = snewn(c->radio.nbuttons, char *);\r
309     c->radio.buttondata = snewn(c->radio.nbuttons, intorptr);\r
310     /*\r
311      * Second pass along variable argument list to actually fill in\r
312      * the structure.\r
313      */\r
314     va_start(ap, context);\r
315     for (i = 0; i < c->radio.nbuttons; i++) {\r
316         c->radio.buttons[i] = dupstr(va_arg(ap, char *));\r
317         if (c->radio.shortcut == NO_SHORTCUT)\r
318             c->radio.shortcuts[i] = va_arg(ap, int);\r
319                                        /* char promotes to int in arg lists */\r
320         c->radio.buttondata[i] = va_arg(ap, intorptr);\r
321     }\r
322     va_end(ap);\r
323     return c;\r
324 }\r
325 \r
326 union control *ctrl_pushbutton(struct controlset *s,char *label,char shortcut,\r
327                                intorptr helpctx, handler_fn handler,\r
328                                intorptr context)\r
329 {\r
330     union control *c = ctrl_new(s, CTRL_BUTTON, helpctx, handler, context);\r
331     c->button.label = label ? dupstr(label) : NULL;\r
332     c->button.shortcut = shortcut;\r
333     c->button.isdefault = 0;\r
334     c->button.iscancel = 0;\r
335     return c;\r
336 }\r
337 \r
338 union control *ctrl_listbox(struct controlset *s,char *label,char shortcut,\r
339                             intorptr helpctx, handler_fn handler,\r
340                             intorptr context)\r
341 {\r
342     union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);\r
343     c->listbox.label = label ? dupstr(label) : NULL;\r
344     c->listbox.shortcut = shortcut;\r
345     c->listbox.height = 5;             /* *shrug* a plausible default */\r
346     c->listbox.draglist = 0;\r
347     c->listbox.multisel = 0;\r
348     c->listbox.percentwidth = 100;\r
349     c->listbox.ncols = 0;\r
350     c->listbox.percentages = NULL;\r
351     return c;\r
352 }\r
353 \r
354 union control *ctrl_droplist(struct controlset *s, char *label, char shortcut,\r
355                              int percentage, intorptr helpctx,\r
356                              handler_fn handler, intorptr context)\r
357 {\r
358     union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);\r
359     c->listbox.label = label ? dupstr(label) : NULL;\r
360     c->listbox.shortcut = shortcut;\r
361     c->listbox.height = 0;             /* means it's a drop-down list */\r
362     c->listbox.draglist = 0;\r
363     c->listbox.multisel = 0;\r
364     c->listbox.percentwidth = percentage;\r
365     c->listbox.ncols = 0;\r
366     c->listbox.percentages = NULL;\r
367     return c;\r
368 }\r
369 \r
370 union control *ctrl_draglist(struct controlset *s,char *label,char shortcut,\r
371                              intorptr helpctx, handler_fn handler,\r
372                              intorptr context)\r
373 {\r
374     union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);\r
375     c->listbox.label = label ? dupstr(label) : NULL;\r
376     c->listbox.shortcut = shortcut;\r
377     c->listbox.height = 5;             /* *shrug* a plausible default */\r
378     c->listbox.draglist = 1;\r
379     c->listbox.multisel = 0;\r
380     c->listbox.percentwidth = 100;\r
381     c->listbox.ncols = 0;\r
382     c->listbox.percentages = NULL;\r
383     return c;\r
384 }\r
385 \r
386 union control *ctrl_filesel(struct controlset *s,char *label,char shortcut,\r
387                             char const *filter, int write, char *title,\r
388                             intorptr helpctx, handler_fn handler,\r
389                             intorptr context)\r
390 {\r
391     union control *c = ctrl_new(s, CTRL_FILESELECT, helpctx, handler, context);\r
392     c->fileselect.label = label ? dupstr(label) : NULL;\r
393     c->fileselect.shortcut = shortcut;\r
394     c->fileselect.filter = filter;\r
395     c->fileselect.for_writing = write;\r
396     c->fileselect.title = dupstr(title);\r
397     return c;\r
398 }\r
399 \r
400 union control *ctrl_fontsel(struct controlset *s,char *label,char shortcut,\r
401                             intorptr helpctx, handler_fn handler,\r
402                             intorptr context)\r
403 {\r
404     union control *c = ctrl_new(s, CTRL_FONTSELECT, helpctx, handler, context);\r
405     c->fontselect.label = label ? dupstr(label) : NULL;\r
406     c->fontselect.shortcut = shortcut;\r
407     return c;\r
408 }\r
409 \r
410 union control *ctrl_tabdelay(struct controlset *s, union control *ctrl)\r
411 {\r
412     union control *c = ctrl_new(s, CTRL_TABDELAY, P(NULL), NULL, P(NULL));\r
413     c->tabdelay.ctrl = ctrl;\r
414     return c;\r
415 }\r
416 \r
417 union control *ctrl_text(struct controlset *s, char *text, intorptr helpctx)\r
418 {\r
419     union control *c = ctrl_new(s, CTRL_TEXT, helpctx, NULL, P(NULL));\r
420     c->text.label = dupstr(text);\r
421     return c;\r
422 }\r
423 \r
424 union control *ctrl_checkbox(struct controlset *s, char *label, char shortcut,\r
425                              intorptr helpctx, handler_fn handler,\r
426                              intorptr context)\r
427 {\r
428     union control *c = ctrl_new(s, CTRL_CHECKBOX, helpctx, handler, context);\r
429     c->checkbox.label = label ? dupstr(label) : NULL;\r
430     c->checkbox.shortcut = shortcut;\r
431     return c;\r
432 }\r
433 \r
434 void ctrl_free(union control *ctrl)\r
435 {\r
436     int i;\r
437 \r
438     sfree(ctrl->generic.label);\r
439     switch (ctrl->generic.type) {\r
440       case CTRL_RADIO:\r
441         for (i = 0; i < ctrl->radio.nbuttons; i++)\r
442             sfree(ctrl->radio.buttons[i]);\r
443         sfree(ctrl->radio.buttons);\r
444         sfree(ctrl->radio.shortcuts);\r
445         sfree(ctrl->radio.buttondata);\r
446         break;\r
447       case CTRL_COLUMNS:\r
448         sfree(ctrl->columns.percentages);\r
449         break;\r
450       case CTRL_LISTBOX:\r
451         sfree(ctrl->listbox.percentages);\r
452         break;\r
453       case CTRL_FILESELECT:\r
454         sfree(ctrl->fileselect.title);\r
455         break;\r
456     }\r
457     sfree(ctrl);\r
458 }\r
459 \r
460 void dlg_stdradiobutton_handler(union control *ctrl, void *dlg,\r
461                                 void *data, int event)\r
462 {\r
463     int button;\r
464     /*\r
465      * For a standard radio button set, the context parameter gives\r
466      * offsetof(targetfield, Config), and the extra data per button\r
467      * gives the value the target field should take if that button\r
468      * is the one selected.\r
469      */\r
470     if (event == EVENT_REFRESH) {\r
471         for (button = 0; button < ctrl->radio.nbuttons; button++)\r
472             if (*(int *)ATOFFSET(data, ctrl->radio.context.i) ==\r
473                 ctrl->radio.buttondata[button].i)\r
474                 break;\r
475         /* We expected that `break' to happen, in all circumstances. */\r
476         assert(button < ctrl->radio.nbuttons);\r
477         dlg_radiobutton_set(ctrl, dlg, button);\r
478     } else if (event == EVENT_VALCHANGE) {\r
479         button = dlg_radiobutton_get(ctrl, dlg);\r
480         assert(button >= 0 && button < ctrl->radio.nbuttons);\r
481         *(int *)ATOFFSET(data, ctrl->radio.context.i) =\r
482             ctrl->radio.buttondata[button].i;\r
483     }\r
484 }\r
485 \r
486 void dlg_stdcheckbox_handler(union control *ctrl, void *dlg,\r
487                                 void *data, int event)\r
488 {\r
489     int offset, invert;\r
490 \r
491     /*\r
492      * For a standard checkbox, the context parameter gives\r
493      * offsetof(targetfield, Config), optionally ORed with\r
494      * CHECKBOX_INVERT.\r
495      */\r
496     offset = ctrl->checkbox.context.i;\r
497     if (offset & CHECKBOX_INVERT) {\r
498         offset &= ~CHECKBOX_INVERT;\r
499         invert = 1;\r
500     } else\r
501         invert = 0;\r
502 \r
503     /*\r
504      * C lacks a logical XOR, so the following code uses the idiom\r
505      * (!a ^ !b) to obtain the logical XOR of a and b. (That is, 1\r
506      * iff exactly one of a and b is nonzero, otherwise 0.)\r
507      */\r
508 \r
509     if (event == EVENT_REFRESH) {\r
510         dlg_checkbox_set(ctrl,dlg, (!*(int *)ATOFFSET(data,offset) ^ !invert));\r
511     } else if (event == EVENT_VALCHANGE) {\r
512         *(int *)ATOFFSET(data, offset) = !dlg_checkbox_get(ctrl,dlg) ^ !invert;\r
513     }\r
514 }\r
515 \r
516 void dlg_stdeditbox_handler(union control *ctrl, void *dlg,\r
517                             void *data, int event)\r
518 {\r
519     /*\r
520      * The standard edit-box handler expects the main `context'\r
521      * field to contain the `offsetof' a field in the structure\r
522      * pointed to by `data'. The secondary `context2' field\r
523      * indicates the type of this field:\r
524      *\r
525      *  - if context2 > 0, the field is a char array and context2\r
526      *    gives its size.\r
527      *  - if context2 == -1, the field is an int and the edit box\r
528      *    is numeric.\r
529      *  - if context2 < -1, the field is an int and the edit box is\r
530      *    _floating_, and (-context2) gives the scale. (E.g. if\r
531      *    context2 == -1000, then typing 1.2 into the box will set\r
532      *    the field to 1200.)\r
533      */\r
534     int offset = ctrl->editbox.context.i;\r
535     int length = ctrl->editbox.context2.i;\r
536 \r
537     if (length > 0) {\r
538         char *field = (char *)ATOFFSET(data, offset);\r
539         if (event == EVENT_REFRESH) {\r
540             dlg_editbox_set(ctrl, dlg, field);\r
541         } else if (event == EVENT_VALCHANGE) {\r
542             dlg_editbox_get(ctrl, dlg, field, length);\r
543         }\r
544     } else if (length < 0) {\r
545         int *field = (int *)ATOFFSET(data, offset);\r
546         char data[80];\r
547         if (event == EVENT_REFRESH) {\r
548             if (length == -1)\r
549                 sprintf(data, "%d", *field);\r
550             else\r
551                 sprintf(data, "%g", (double)*field / (double)(-length));\r
552             dlg_editbox_set(ctrl, dlg, data);\r
553         } else if (event == EVENT_VALCHANGE) {\r
554             dlg_editbox_get(ctrl, dlg, data, lenof(data));\r
555             if (length == -1)\r
556                 *field = atoi(data);\r
557             else\r
558                 *field = (int)((-length) * atof(data));\r
559         }\r
560     }\r
561 }\r
562 \r
563 void dlg_stdfilesel_handler(union control *ctrl, void *dlg,\r
564                             void *data, int event)\r
565 {\r
566     /*\r
567      * The standard file-selector handler expects the `context'\r
568      * field to contain the `offsetof' a Filename field in the\r
569      * structure pointed to by `data'.\r
570      */\r
571     int offset = ctrl->fileselect.context.i;\r
572 \r
573     if (event == EVENT_REFRESH) {\r
574         dlg_filesel_set(ctrl, dlg, *(Filename *)ATOFFSET(data, offset));\r
575     } else if (event == EVENT_VALCHANGE) {\r
576         dlg_filesel_get(ctrl, dlg, (Filename *)ATOFFSET(data, offset));\r
577     }\r
578 }\r
579 \r
580 void dlg_stdfontsel_handler(union control *ctrl, void *dlg,\r
581                             void *data, int event)\r
582 {\r
583     /*\r
584      * The standard file-selector handler expects the `context'\r
585      * field to contain the `offsetof' a FontSpec field in the\r
586      * structure pointed to by `data'.\r
587      */\r
588     int offset = ctrl->fontselect.context.i;\r
589 \r
590     if (event == EVENT_REFRESH) {\r
591         dlg_fontsel_set(ctrl, dlg, *(FontSpec *)ATOFFSET(data, offset));\r
592     } else if (event == EVENT_VALCHANGE) {\r
593         dlg_fontsel_get(ctrl, dlg, (FontSpec *)ATOFFSET(data, offset));\r
594     }\r
595 }\r