projects / u / mdw / putty / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Now that we have Subversion's file renaming ability, it's time at
[u/mdw/putty] / windows / winctrls.c
CommitLineData
8c3cd914 1/*
2 * winctrls.c: routines to self-manage the controls in a dialog
3 * box.
4 */
5
fe8abbf4 6/*
7 * Possible TODO in new cross-platform config box stuff:
8 *
9 * - When lining up two controls alongside each other, I wonder if
10 * we could conveniently arrange to centre them vertically?
11 * Particularly ugly in the current setup is the `Add new
12 * forwarded port:' static next to the rather taller `Remove'
13 * button.
14 */
15
fe8abbf4 16#include <assert.h>
d1582b2e 17#include <ctype.h>
8c3cd914 18
7440fd44 19#include "putty.h"
fe8abbf4 20#include "misc.h"
21#include "dialog.h"
ca20bfcf 22
7440fd44 23#include <commctrl.h>
8c3cd914 24
25#define GAPBETWEEN 3
26#define GAPWITHIN 1
27#define GAPXBOX 7
28#define GAPYBOX 4
29#define DLGWIDTH 168
30#define STATICHEIGHT 8
fe8abbf4 31#define TITLEHEIGHT 12
8c3cd914 32#define CHECKBOXHEIGHT 8
33#define RADIOHEIGHT 8
34#define EDITHEIGHT 12
fe8abbf4 35#define LISTHEIGHT 11
36#define LISTINCREMENT 8
8c3cd914 37#define COMBOHEIGHT 12
38#define PUSHBTNHEIGHT 14
6e522441 39#define PROGBARHEIGHT 14
8c3cd914 40
41void ctlposinit(struct ctlpos *cp, HWND hwnd,
32874aea 42 int leftborder, int rightborder, int topborder)
43{
8c3cd914 44 RECT r, r2;
45 cp->hwnd = hwnd;
46 cp->font = SendMessage(hwnd, WM_GETFONT, 0, 0);
47 cp->ypos = topborder;
48 GetClientRect(hwnd, &r);
49 r2.left = r2.top = 0;
50 r2.right = 4;
51 r2.bottom = 8;
52 MapDialogRect(hwnd, &r2);
53 cp->dlu4inpix = r2.right;
32874aea 54 cp->width = (r.right * 4) / (r2.right) - 2 * GAPBETWEEN;
8c3cd914 55 cp->xoff = leftborder;
56 cp->width -= leftborder + rightborder;
57}
58
ca20bfcf 59HWND doctl(struct ctlpos *cp, RECT r,
32874aea 60 char *wclass, int wstyle, int exstyle, char *wtext, int wid)
61{
8c3cd914 62 HWND ctl;
63 /*
64 * Note nonstandard use of RECT. This is deliberate: by
65 * transforming the width and height directly we arrange to
66 * have all supposedly same-sized controls really same-sized.
67 */
68
69 r.left += cp->xoff;
70 MapDialogRect(cp->hwnd, &r);
71
fe8abbf4 72 /*
73 * We can pass in cp->hwnd == NULL, to indicate a dry run
74 * without creating any actual controls.
75 */
76 if (cp->hwnd) {
77 ctl = CreateWindowEx(exstyle, wclass, wtext, wstyle,
78 r.left, r.top, r.right, r.bottom,
79 cp->hwnd, (HMENU) wid, hinst, NULL);
80 SendMessage(ctl, WM_SETFONT, cp->font, MAKELPARAM(TRUE, 0));
81
82 if (!strcmp(wclass, "LISTBOX")) {
83 /*
84 * Bizarre Windows bug: the list box calculates its
85 * number of lines based on the font it has at creation
86 * time, but sending it WM_SETFONT doesn't cause it to
87 * recalculate. So now, _after_ we've sent it
88 * WM_SETFONT, we explicitly resize it (to the same
89 * size it was already!) to force it to reconsider.
90 */
91 SetWindowPos(ctl, NULL, 0, 0, r.right, r.bottom,
92 SWP_NOACTIVATE | SWP_NOCOPYBITS |
93 SWP_NOMOVE | SWP_NOZORDER);
94 }
d1582b2e 95 } else
96 ctl = NULL;
ca20bfcf 97 return ctl;
8c3cd914 98}
99
100/*
101 * A title bar across the top of a sub-dialog.
102 */
32874aea 103void bartitle(struct ctlpos *cp, char *name, int id)
104{
8c3cd914 105 RECT r;
106
32874aea 107 r.left = GAPBETWEEN;
108 r.right = cp->width;
109 r.top = cp->ypos;
110 r.bottom = STATICHEIGHT;
8c3cd914 111 cp->ypos += r.bottom + GAPBETWEEN;
112 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, name, id);
113}
114
115/*
116 * Begin a grouping box, with or without a group title.
117 */
32874aea 118void beginbox(struct ctlpos *cp, char *name, int idbox)
119{
8c3cd914 120 cp->boxystart = cp->ypos;
3ac9cd9f 121 if (!name)
32874aea 122 cp->boxystart -= STATICHEIGHT / 2;
8c3cd914 123 if (name)
32874aea 124 cp->ypos += STATICHEIGHT;
8c3cd914 125 cp->ypos += GAPYBOX;
32874aea 126 cp->width -= 2 * GAPXBOX;
8c3cd914 127 cp->xoff += GAPXBOX;
128 cp->boxid = idbox;
8c3cd914 129 cp->boxtext = name;
130}
131
132/*
133 * End a grouping box.
134 */
32874aea 135void endbox(struct ctlpos *cp)
136{
8c3cd914 137 RECT r;
138 cp->xoff -= GAPXBOX;
32874aea 139 cp->width += 2 * GAPXBOX;
8c3cd914 140 cp->ypos += GAPYBOX - GAPBETWEEN;
32874aea 141 r.left = GAPBETWEEN;
142 r.right = cp->width;
143 r.top = cp->boxystart;
144 r.bottom = cp->ypos - cp->boxystart;
3ac9cd9f 145 doctl(cp, r, "BUTTON", BS_GROUPBOX | WS_CHILD | WS_VISIBLE, 0,
32874aea 146 cp->boxtext ? cp->boxtext : "", cp->boxid);
8c3cd914 147 cp->ypos += GAPYBOX;
148}
149
150/*
151 * Some edit boxes. Each one has a static above it. The percentages
152 * of the horizontal space are provided.
153 */
fe8abbf4 154void multiedit(struct ctlpos *cp, int password, ...)
32874aea 155{
8c3cd914 156 RECT r;
157 va_list ap;
158 int percent, xpos;
159
160 percent = xpos = 0;
fe8abbf4 161 va_start(ap, password);
8c3cd914 162 while (1) {
32874aea 163 char *text;
164 int staticid, editid, pcwidth;
165 text = va_arg(ap, char *);
166 if (!text)
167 break;
168 staticid = va_arg(ap, int);
169 editid = va_arg(ap, int);
170 pcwidth = va_arg(ap, int);
171
172 r.left = xpos + GAPBETWEEN;
173 percent += pcwidth;
174 xpos = (cp->width + GAPBETWEEN) * percent / 100;
175 r.right = xpos - r.left;
176
177 r.top = cp->ypos;
178 r.bottom = STATICHEIGHT;
179 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, staticid);
180 r.top = cp->ypos + 8 + GAPWITHIN;
181 r.bottom = EDITHEIGHT;
182 doctl(cp, r, "EDIT",
fe8abbf4 183 WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL |
184 (password ? ES_PASSWORD : 0),
32874aea 185 WS_EX_CLIENTEDGE, "", editid);
8c3cd914 186 }
187 va_end(ap);
875b193f 188 cp->ypos += STATICHEIGHT + GAPWITHIN + EDITHEIGHT + GAPBETWEEN;
189}
190
191/*
b8ae1f0f 192 * A static line, followed by a full-width combo box.
875b193f 193 */
b8ae1f0f 194void combobox(struct ctlpos *cp, char *text, int staticid, int listid)
875b193f 195{
196 RECT r;
875b193f 197
198 r.left = GAPBETWEEN;
199 r.right = cp->width;
200
201 r.top = cp->ypos;
202 r.bottom = STATICHEIGHT;
203 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, staticid);
204 r.top = cp->ypos + 8 + GAPWITHIN;
205 r.bottom = COMBOHEIGHT * 10;
206 doctl(cp, r, "COMBOBOX",
207 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
b8ae1f0f 208 CBS_DROPDOWN | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", listid);
875b193f 209
210 cp->ypos += STATICHEIGHT + GAPWITHIN + COMBOHEIGHT + GAPBETWEEN;
8c3cd914 211}
212
fe8abbf4 213struct radio { char *text; int id; };
214
215static void radioline_common(struct ctlpos *cp, char *text, int id,
216 int nacross, struct radio *buttons, int nbuttons)
32874aea 217{
8c3cd914 218 RECT r;
8c3cd914 219 int group;
220 int i;
fe8abbf4 221 int j;
222
223 if (text) {
224 r.left = GAPBETWEEN;
225 r.top = cp->ypos;
226 r.right = cp->width;
227 r.bottom = STATICHEIGHT;
228 cp->ypos += r.bottom + GAPWITHIN;
229 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, id);
230 }
8c3cd914 231
8c3cd914 232 group = WS_GROUP;
233 i = 0;
fe8abbf4 234 for (j = 0; j < nbuttons; j++) {
235 char *btext = buttons[j].text;
236 int bid = buttons[j].id;
237
32874aea 238 if (i == nacross) {
fe8abbf4 239 cp->ypos += r.bottom + (nacross > 1 ? GAPBETWEEN : GAPWITHIN);
32874aea 240 i = 0;
f37caa11 241 }
32874aea 242 r.left = GAPBETWEEN + i * (cp->width + GAPBETWEEN) / nacross;
fe8abbf4 243 if (j < nbuttons-1)
32874aea 244 r.right =
245 (i + 1) * (cp->width + GAPBETWEEN) / nacross - r.left;
246 else
247 r.right = cp->width - r.left;
248 r.top = cp->ypos;
249 r.bottom = RADIOHEIGHT;
250 doctl(cp, r, "BUTTON",
fe8abbf4 251 BS_NOTIFY | BS_AUTORADIOBUTTON | WS_CHILD |
252 WS_VISIBLE | WS_TABSTOP | group, 0, btext, bid);
32874aea 253 group = 0;
254 i++;
8c3cd914 255 }
8c3cd914 256 cp->ypos += r.bottom + GAPBETWEEN;
257}
258
259/*
d74d141c 260 * A set of radio buttons on the same line, with a static above
261 * them. `nacross' dictates how many parts the line is divided into
262 * (you might want this not to equal the number of buttons if you
263 * needed to line up some 2s and some 3s to look good in the same
264 * panel).
265 *
266 * There's a bit of a hack in here to ensure that if nacross
267 * exceeds the actual number of buttons, the rightmost button
268 * really does get all the space right to the edge of the line, so
269 * you can do things like
270 *
271 * (*) Button1 (*) Button2 (*) ButtonWithReallyLongTitle
272 */
273void radioline(struct ctlpos *cp, char *text, int id, int nacross, ...)
274{
d74d141c 275 va_list ap;
fe8abbf4 276 struct radio *buttons;
277 int i, nbuttons;
d74d141c 278
d74d141c 279 va_start(ap, nacross);
fe8abbf4 280 nbuttons = 0;
281 while (1) {
282 char *btext = va_arg(ap, char *);
283 int bid;
284 if (!btext)
285 break;
286 bid = va_arg(ap, int);
7bd02947 287 nbuttons++;
fe8abbf4 288 }
289 va_end(ap);
3d88e64d 290 buttons = snewn(nbuttons, struct radio);
fe8abbf4 291 va_start(ap, nacross);
292 for (i = 0; i < nbuttons; i++) {
293 buttons[i].text = va_arg(ap, char *);
294 buttons[i].id = va_arg(ap, int);
295 }
d74d141c 296 va_end(ap);
fe8abbf4 297 radioline_common(cp, text, id, nacross, buttons, nbuttons);
298 sfree(buttons);
d74d141c 299}
300
301/*
302 * A set of radio buttons on the same line, without a static above
303 * them. Otherwise just like radioline.
304 */
305void bareradioline(struct ctlpos *cp, int nacross, ...)
306{
307 va_list ap;
fe8abbf4 308 struct radio *buttons;
309 int i, nbuttons;
d74d141c 310
311 va_start(ap, nacross);
fe8abbf4 312 nbuttons = 0;
313 while (1) {
314 char *btext = va_arg(ap, char *);
315 int bid;
316 if (!btext)
317 break;
318 bid = va_arg(ap, int);
319 }
320 va_end(ap);
3d88e64d 321 buttons = snewn(nbuttons, struct radio);
fe8abbf4 322 va_start(ap, nacross);
323 for (i = 0; i < nbuttons; i++) {
324 buttons[i].text = va_arg(ap, char *);
325 buttons[i].id = va_arg(ap, int);
326 }
d74d141c 327 va_end(ap);
fe8abbf4 328 radioline_common(cp, NULL, 0, nacross, buttons, nbuttons);
329 sfree(buttons);
d74d141c 330}
331
332/*
8c3cd914 333 * A set of radio buttons on multiple lines, with a static above
334 * them.
335 */
32874aea 336void radiobig(struct ctlpos *cp, char *text, int id, ...)
337{
8c3cd914 338 va_list ap;
fe8abbf4 339 struct radio *buttons;
340 int i, nbuttons;
8c3cd914 341
8c3cd914 342 va_start(ap, id);
fe8abbf4 343 nbuttons = 0;
8c3cd914 344 while (1) {
fe8abbf4 345 char *btext = va_arg(ap, char *);
32874aea 346 int bid;
32874aea 347 if (!btext)
348 break;
349 bid = va_arg(ap, int);
8c3cd914 350 }
351 va_end(ap);
3d88e64d 352 buttons = snewn(nbuttons, struct radio);
fe8abbf4 353 va_start(ap, id);
354 for (i = 0; i < nbuttons; i++) {
355 buttons[i].text = va_arg(ap, char *);
356 buttons[i].id = va_arg(ap, int);
357 }
358 va_end(ap);
359 radioline_common(cp, text, id, 1, buttons, nbuttons);
360 sfree(buttons);
8c3cd914 361}
362
363/*
364 * A single standalone checkbox.
365 */
32874aea 366void checkbox(struct ctlpos *cp, char *text, int id)
367{
8c3cd914 368 RECT r;
369
32874aea 370 r.left = GAPBETWEEN;
371 r.top = cp->ypos;
372 r.right = cp->width;
373 r.bottom = CHECKBOXHEIGHT;
8c3cd914 374 cp->ypos += r.bottom + GAPBETWEEN;
375 doctl(cp, r, "BUTTON",
fe8abbf4 376 BS_NOTIFY | BS_AUTOCHECKBOX | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0,
32874aea 377 text, id);
8c3cd914 378}
379
380/*
fe8abbf4 381 * Wrap a piece of text for a static text control. Returns the
382 * wrapped text (a malloc'ed string containing \ns), and also
383 * returns the number of lines required.
384 */
385char *staticwrap(struct ctlpos *cp, HWND hwnd, char *text, int *lines)
386{
fe8abbf4 387 HDC hdc = GetDC(hwnd);
388 int lpx = GetDeviceCaps(hdc, LOGPIXELSX);
389 int width, nlines, j;
390 INT *pwidths, nfit;
391 SIZE size;
392 char *ret, *p, *q;
393 RECT r;
97332719 394 HFONT oldfont, newfont;
fe8abbf4 395
3d88e64d 396 ret = snewn(1+strlen(text), char);
fe8abbf4 397 p = text;
398 q = ret;
3d88e64d 399 pwidths = snewn(1+strlen(text), INT);
fe8abbf4 400
401 /*
402 * Work out the width the text will need to fit in, by doing
403 * the same adjustment that the `statictext' function itself
404 * will perform.
fe8abbf4 405 */
97332719 406 SetMapMode(hdc, MM_TEXT); /* ensure logical units == pixels */
fe8abbf4 407 r.left = r.top = r.bottom = 0;
408 r.right = cp->width;
409 MapDialogRect(hwnd, &r);
97332719 410 width = r.right;
fe8abbf4 411
412 nlines = 1;
413
97332719 414 /*
415 * We must select the correct font into the HDC before calling
416 * GetTextExtent*, or silly things will happen.
417 */
418 newfont = (HFONT)SendMessage(hwnd, WM_GETFONT, 0, 0);
419 oldfont = SelectObject(hdc, newfont);
420
fe8abbf4 421 while (*p) {
422 if (!GetTextExtentExPoint(hdc, p, strlen(p), width,
423 &nfit, pwidths, &size) ||
424 (size_t)nfit >= strlen(p)) {
425 /*
426 * Either GetTextExtentExPoint returned failure, or the
427 * whole of the rest of the text fits on this line.
428 * Either way, we stop wrapping, copy the remainder of
429 * the input string unchanged to the output, and leave.
430 */
431 strcpy(q, p);
432 break;
433 }
434
435 /*
436 * Now we search backwards along the string from `nfit',
437 * looking for a space at which to break the line. If we
438 * don't find one at all, that's fine - we'll just break
439 * the line at `nfit'.
440 */
441 for (j = nfit; j > 0; j--) {
442 if (isspace((unsigned char)p[j])) {
443 nfit = j;
444 break;
445 }
446 }
447
448 strncpy(q, p, nfit);
449 q[nfit] = '\n';
450 q += nfit+1;
451
452 p += nfit;
453 while (*p && isspace((unsigned char)*p))
454 p++;
455
456 nlines++;
457 }
458
97332719 459 SelectObject(hdc, oldfont);
fe8abbf4 460 ReleaseDC(cp->hwnd, hdc);
461
462 if (lines) *lines = nlines;
463
464 return ret;
465}
466
467/*
6e522441 468 * A single standalone static text control.
469 */
66ee282a 470void statictext(struct ctlpos *cp, char *text, int lines, int id)
32874aea 471{
6e522441 472 RECT r;
473
32874aea 474 r.left = GAPBETWEEN;
475 r.top = cp->ypos;
476 r.right = cp->width;
66ee282a 477 r.bottom = STATICHEIGHT * lines;
6e522441 478 cp->ypos += r.bottom + GAPBETWEEN;
fe8abbf4 479 doctl(cp, r, "STATIC",
480 WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP,
481 0, text, id);
482}
483
484/*
485 * An owner-drawn static text control for a panel title.
486 */
487void paneltitle(struct ctlpos *cp, int id)
488{
489 RECT r;
490
491 r.left = GAPBETWEEN;
492 r.top = cp->ypos;
493 r.right = cp->width;
494 r.bottom = TITLEHEIGHT;
495 cp->ypos += r.bottom + GAPBETWEEN;
496 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE | SS_OWNERDRAW,
497 0, NULL, id);
6e522441 498}
499
500/*
8c3cd914 501 * A button on the right hand side, with a static to its left.
502 */
503void staticbtn(struct ctlpos *cp, char *stext, int sid,
32874aea 504 char *btext, int bid)
505{
8c3cd914 506 const int height = (PUSHBTNHEIGHT > STATICHEIGHT ?
32874aea 507 PUSHBTNHEIGHT : STATICHEIGHT);
8c3cd914 508 RECT r;
509 int lwid, rwid, rpos;
510
511 rpos = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
32874aea 512 lwid = rpos - 2 * GAPBETWEEN;
8c3cd914 513 rwid = cp->width + GAPBETWEEN - rpos;
514
32874aea 515 r.left = GAPBETWEEN;
516 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
517 r.right = lwid;
518 r.bottom = STATICHEIGHT;
8c3cd914 519 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
520
32874aea 521 r.left = rpos;
522 r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
523 r.right = rwid;
524 r.bottom = PUSHBTNHEIGHT;
8c3cd914 525 doctl(cp, r, "BUTTON",
fe8abbf4 526 BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
32874aea 527 0, btext, bid);
8c3cd914 528
529 cp->ypos += height + GAPBETWEEN;
530}
531
532/*
fe8abbf4 533 * A simple push button.
534 */
535void button(struct ctlpos *cp, char *btext, int bid, int defbtn)
536{
537 RECT r;
538
539 r.left = GAPBETWEEN;
540 r.top = cp->ypos;
541 r.right = cp->width;
542 r.bottom = PUSHBTNHEIGHT;
543
544 /* Q67655: the _dialog box_ must know which button is default
545 * as well as the button itself knowing */
546 if (defbtn && cp->hwnd)
547 SendMessage(cp->hwnd, DM_SETDEFID, bid, 0);
548
549 doctl(cp, r, "BUTTON",
550 BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP |
551 (defbtn ? BS_DEFPUSHBUTTON : 0) | BS_PUSHBUTTON,
552 0, btext, bid);
553
554 cp->ypos += PUSHBTNHEIGHT + GAPBETWEEN;
555}
556
557/*
af282e3b 558 * Like staticbtn, but two buttons.
559 */
560void static2btn(struct ctlpos *cp, char *stext, int sid,
561 char *btext1, int bid1, char *btext2, int bid2)
562{
563 const int height = (PUSHBTNHEIGHT > STATICHEIGHT ?
564 PUSHBTNHEIGHT : STATICHEIGHT);
565 RECT r;
566 int lwid, rwid1, rwid2, rpos1, rpos2;
567
568 rpos1 = GAPBETWEEN + (cp->width + GAPBETWEEN) / 2;
569 rpos2 = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
570 lwid = rpos1 - 2 * GAPBETWEEN;
571 rwid1 = rpos2 - rpos1 - GAPBETWEEN;
572 rwid2 = cp->width + GAPBETWEEN - rpos2;
573
574 r.left = GAPBETWEEN;
575 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
576 r.right = lwid;
577 r.bottom = STATICHEIGHT;
578 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
579
580 r.left = rpos1;
581 r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
582 r.right = rwid1;
583 r.bottom = PUSHBTNHEIGHT;
584 doctl(cp, r, "BUTTON",
fe8abbf4 585 BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
af282e3b 586 0, btext1, bid1);
587
588 r.left = rpos2;
589 r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
590 r.right = rwid2;
591 r.bottom = PUSHBTNHEIGHT;
592 doctl(cp, r, "BUTTON",
fe8abbf4 593 BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
af282e3b 594 0, btext2, bid2);
595
596 cp->ypos += height + GAPBETWEEN;
597}
598
599/*
8c3cd914 600 * An edit control on the right hand side, with a static to its left.
601 */
6e522441 602static void staticedit_internal(struct ctlpos *cp, char *stext,
32874aea 603 int sid, int eid, int percentedit,
604 int style)
605{
8c3cd914 606 const int height = (EDITHEIGHT > STATICHEIGHT ?
32874aea 607 EDITHEIGHT : STATICHEIGHT);
8c3cd914 608 RECT r;
609 int lwid, rwid, rpos;
610
32874aea 611 rpos =
612 GAPBETWEEN + (100 - percentedit) * (cp->width + GAPBETWEEN) / 100;
613 lwid = rpos - 2 * GAPBETWEEN;
8c3cd914 614 rwid = cp->width + GAPBETWEEN - rpos;
615
32874aea 616 r.left = GAPBETWEEN;
617 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
618 r.right = lwid;
619 r.bottom = STATICHEIGHT;
8c3cd914 620 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
621
32874aea 622 r.left = rpos;
623 r.top = cp->ypos + (height - EDITHEIGHT) / 2;
624 r.right = rwid;
625 r.bottom = EDITHEIGHT;
8c3cd914 626 doctl(cp, r, "EDIT",
32874aea 627 WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL | style,
628 WS_EX_CLIENTEDGE, "", eid);
8c3cd914 629
630 cp->ypos += height + GAPBETWEEN;
631}
632
6e522441 633void staticedit(struct ctlpos *cp, char *stext,
32874aea 634 int sid, int eid, int percentedit)
635{
6e522441 636 staticedit_internal(cp, stext, sid, eid, percentedit, 0);
637}
638
639void staticpassedit(struct ctlpos *cp, char *stext,
32874aea 640 int sid, int eid, int percentedit)
641{
6e522441 642 staticedit_internal(cp, stext, sid, eid, percentedit, ES_PASSWORD);
643}
644
645/*
2c9c6388 646 * A drop-down list box on the right hand side, with a static to
647 * its left.
648 */
649void staticddl(struct ctlpos *cp, char *stext,
650 int sid, int lid, int percentlist)
651{
652 const int height = (COMBOHEIGHT > STATICHEIGHT ?
653 COMBOHEIGHT : STATICHEIGHT);
654 RECT r;
655 int lwid, rwid, rpos;
656
657 rpos =
658 GAPBETWEEN + (100 - percentlist) * (cp->width + GAPBETWEEN) / 100;
659 lwid = rpos - 2 * GAPBETWEEN;
660 rwid = cp->width + GAPBETWEEN - rpos;
661
662 r.left = GAPBETWEEN;
663 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
664 r.right = lwid;
665 r.bottom = STATICHEIGHT;
666 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
667
668 r.left = rpos;
669 r.top = cp->ypos + (height - EDITHEIGHT) / 2;
670 r.right = rwid;
671 r.bottom = COMBOHEIGHT*4;
672 doctl(cp, r, "COMBOBOX",
673 WS_CHILD | WS_VISIBLE | WS_TABSTOP |
674 CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
675
676 cp->ypos += height + GAPBETWEEN;
677}
678
679/*
fe8abbf4 680 * A combo box on the right hand side, with a static to its left.
681 */
682void staticcombo(struct ctlpos *cp, char *stext,
683 int sid, int lid, int percentlist)
684{
685 const int height = (COMBOHEIGHT > STATICHEIGHT ?
686 COMBOHEIGHT : STATICHEIGHT);
687 RECT r;
688 int lwid, rwid, rpos;
689
690 rpos =
691 GAPBETWEEN + (100 - percentlist) * (cp->width + GAPBETWEEN) / 100;
692 lwid = rpos - 2 * GAPBETWEEN;
693 rwid = cp->width + GAPBETWEEN - rpos;
694
695 r.left = GAPBETWEEN;
696 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
697 r.right = lwid;
698 r.bottom = STATICHEIGHT;
699 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
700
701 r.left = rpos;
702 r.top = cp->ypos + (height - EDITHEIGHT) / 2;
703 r.right = rwid;
704 r.bottom = COMBOHEIGHT*10;
705 doctl(cp, r, "COMBOBOX",
706 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
707 CBS_DROPDOWN | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
708
709 cp->ypos += height + GAPBETWEEN;
710}
711
712/*
713 * A static, with a full-width drop-down list box below it.
714 */
715void staticddlbig(struct ctlpos *cp, char *stext,
716 int sid, int lid)
717{
718 RECT r;
719
720 r.left = GAPBETWEEN;
721 r.top = cp->ypos;
722 r.right = cp->width;
723 r.bottom = STATICHEIGHT;
724 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
725 cp->ypos += STATICHEIGHT;
726
727 r.left = GAPBETWEEN;
728 r.top = cp->ypos;
729 r.right = cp->width;
730 r.bottom = COMBOHEIGHT*4;
731 doctl(cp, r, "COMBOBOX",
732 WS_CHILD | WS_VISIBLE | WS_TABSTOP |
733 CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
734 cp->ypos += COMBOHEIGHT + GAPBETWEEN;
735}
736
737/*
6e522441 738 * A big multiline edit control with a static labelling it.
739 */
740void bigeditctrl(struct ctlpos *cp, char *stext,
32874aea 741 int sid, int eid, int lines)
742{
6e522441 743 RECT r;
744
32874aea 745 r.left = GAPBETWEEN;
746 r.top = cp->ypos;
747 r.right = cp->width;
748 r.bottom = STATICHEIGHT;
6e522441 749 cp->ypos += r.bottom + GAPWITHIN;
750 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
751
32874aea 752 r.left = GAPBETWEEN;
753 r.top = cp->ypos;
754 r.right = cp->width;
755 r.bottom = EDITHEIGHT + (lines - 1) * STATICHEIGHT;
6e522441 756 cp->ypos += r.bottom + GAPBETWEEN;
757 doctl(cp, r, "EDIT",
32874aea 758 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL | ES_MULTILINE,
759 WS_EX_CLIENTEDGE, "", eid);
6e522441 760}
761
8c3cd914 762/*
fe8abbf4 763 * A list box with a static labelling it.
764 */
765void listbox(struct ctlpos *cp, char *stext,
766 int sid, int lid, int lines, int multi)
767{
768 RECT r;
769
770 if (stext != NULL) {
771 r.left = GAPBETWEEN;
772 r.top = cp->ypos;
773 r.right = cp->width;
774 r.bottom = STATICHEIGHT;
775 cp->ypos += r.bottom + GAPWITHIN;
776 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
777 }
778
779 r.left = GAPBETWEEN;
780 r.top = cp->ypos;
781 r.right = cp->width;
782 r.bottom = LISTHEIGHT + (lines - 1) * LISTINCREMENT;
783 cp->ypos += r.bottom + GAPBETWEEN;
784 doctl(cp, r, "LISTBOX",
785 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
786 LBS_NOTIFY | LBS_HASSTRINGS | LBS_USETABSTOPS |
787 (multi ? LBS_MULTIPLESEL : 0),
788 WS_EX_CLIENTEDGE, "", lid);
789}
790
791/*
8c3cd914 792 * A tab-control substitute when a real tab control is unavailable.
793 */
32874aea 794void ersatztab(struct ctlpos *cp, char *stext, int sid, int lid, int s2id)
795{
8c3cd914 796 const int height = (COMBOHEIGHT > STATICHEIGHT ?
32874aea 797 COMBOHEIGHT : STATICHEIGHT);
8c3cd914 798 RECT r;
799 int bigwid, lwid, rwid, rpos;
800 static const int BIGGAP = 15;
801 static const int MEDGAP = 3;
802
32874aea 803 bigwid = cp->width + 2 * GAPBETWEEN - 2 * BIGGAP;
8c3cd914 804 cp->ypos += MEDGAP;
805 rpos = BIGGAP + (bigwid + BIGGAP) / 2;
32874aea 806 lwid = rpos - 2 * BIGGAP;
8c3cd914 807 rwid = bigwid + BIGGAP - rpos;
808
32874aea 809 r.left = BIGGAP;
810 r.top = cp->ypos + (height - STATICHEIGHT) / 2;
811 r.right = lwid;
812 r.bottom = STATICHEIGHT;
8c3cd914 813 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
814
32874aea 815 r.left = rpos;
816 r.top = cp->ypos + (height - COMBOHEIGHT) / 2;
817 r.right = rwid;
818 r.bottom = COMBOHEIGHT * 10;
8c3cd914 819 doctl(cp, r, "COMBOBOX",
32874aea 820 WS_CHILD | WS_VISIBLE | WS_TABSTOP |
821 CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
8c3cd914 822
823 cp->ypos += height + MEDGAP + GAPBETWEEN;
824
32874aea 825 r.left = GAPBETWEEN;
826 r.top = cp->ypos;
827 r.right = cp->width;
828 r.bottom = 2;
8c3cd914 829 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ,
32874aea 830 0, "", s2id);
8c3cd914 831}
832
833/*
834 * A static line, followed by an edit control on the left hand side
835 * and a button on the right.
836 */
837void editbutton(struct ctlpos *cp, char *stext, int sid,
32874aea 838 int eid, char *btext, int bid)
839{
8c3cd914 840 const int height = (EDITHEIGHT > PUSHBTNHEIGHT ?
32874aea 841 EDITHEIGHT : PUSHBTNHEIGHT);
8c3cd914 842 RECT r;
843 int lwid, rwid, rpos;
844
32874aea 845 r.left = GAPBETWEEN;
846 r.top = cp->ypos;
847 r.right = cp->width;
848 r.bottom = STATICHEIGHT;
8c3cd914 849 cp->ypos += r.bottom + GAPWITHIN;
850 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
851
852 rpos = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
32874aea 853 lwid = rpos - 2 * GAPBETWEEN;
8c3cd914 854 rwid = cp->width + GAPBETWEEN - rpos;
855
32874aea 856 r.left = GAPBETWEEN;
857 r.top = cp->ypos + (height - EDITHEIGHT) / 2;
858 r.right = lwid;
859 r.bottom = EDITHEIGHT;
8c3cd914 860 doctl(cp, r, "EDIT",
32874aea 861 WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL,
862 WS_EX_CLIENTEDGE, "", eid);
8c3cd914 863
32874aea 864 r.left = rpos;
865 r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
866 r.right = rwid;
867 r.bottom = PUSHBTNHEIGHT;
8c3cd914 868 doctl(cp, r, "BUTTON",
fe8abbf4 869 BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
32874aea 870 0, btext, bid);
8c3cd914 871
872 cp->ypos += height + GAPBETWEEN;
873}
874
875/*
fe8abbf4 876 * A special control for manipulating an ordered preference list
877 * (eg. for cipher selection).
878 * XXX: this is a rough hack and could be improved.
8c3cd914 879 */
fe8abbf4 880void prefslist(struct prefslist *hdl, struct ctlpos *cp, int lines,
881 char *stext, int sid, int listid, int upbid, int dnbid)
32874aea 882{
fe8abbf4 883 const static int percents[] = { 5, 75, 20 };
8c3cd914 884 RECT r;
fe8abbf4 885 int xpos, percent = 0, i;
886 int listheight = LISTHEIGHT + (lines - 1) * LISTINCREMENT;
887 const int BTNSHEIGHT = 2*PUSHBTNHEIGHT + GAPBETWEEN;
888 int totalheight, buttonpos;
8c3cd914 889
fe8abbf4 890 /* Squirrel away IDs. */
891 hdl->listid = listid;
892 hdl->upbid = upbid;
893 hdl->dnbid = dnbid;
8c3cd914 894
fe8abbf4 895 /* The static label. */
896 if (stext != NULL) {
897 r.left = GAPBETWEEN;
898 r.top = cp->ypos;
899 r.right = cp->width;
900 r.bottom = STATICHEIGHT;
901 cp->ypos += r.bottom + GAPWITHIN;
902 doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
8c3cd914 903 }
904
fe8abbf4 905 if (listheight > BTNSHEIGHT) {
906 totalheight = listheight;
907 buttonpos = (listheight - BTNSHEIGHT) / 2;
908 } else {
909 totalheight = BTNSHEIGHT;
910 buttonpos = 0;
ca20bfcf 911 }
912
913 for (i=0; i<3; i++) {
914 int left, wid;
915 xpos = (cp->width + GAPBETWEEN) * percent / 100;
916 left = xpos + GAPBETWEEN;
917 percent += percents[i];
918 xpos = (cp->width + GAPBETWEEN) * percent / 100;
919 wid = xpos - left;
920
921 switch (i) {
922 case 1:
923 /* The drag list box. */
924 r.left = left; r.right = wid;
fe8abbf4 925 r.top = cp->ypos; r.bottom = listheight;
ca20bfcf 926 {
927 HWND ctl;
928 ctl = doctl(cp, r, "LISTBOX",
929 WS_CHILD | WS_VISIBLE | WS_TABSTOP |
fe8abbf4 930 WS_VSCROLL | LBS_HASSTRINGS | LBS_USETABSTOPS,
ca20bfcf 931 WS_EX_CLIENTEDGE,
932 "", listid);
933 MakeDragList(ctl);
934 }
935 break;
936
937 case 2:
938 /* The "Up" and "Down" buttons. */
939 /* XXX worry about accelerators if we have more than one
940 * prefslist on a panel */
941 r.left = left; r.right = wid;
fe8abbf4 942 r.top = cp->ypos + buttonpos; r.bottom = PUSHBTNHEIGHT;
ca20bfcf 943 doctl(cp, r, "BUTTON",
fe8abbf4 944 BS_NOTIFY | WS_CHILD | WS_VISIBLE |
945 WS_TABSTOP | BS_PUSHBUTTON,
ca20bfcf 946 0, "&Up", upbid);
947
948 r.left = left; r.right = wid;
fe8abbf4 949 r.top = cp->ypos + buttonpos + PUSHBTNHEIGHT + GAPBETWEEN;
ca20bfcf 950 r.bottom = PUSHBTNHEIGHT;
951 doctl(cp, r, "BUTTON",
fe8abbf4 952 BS_NOTIFY | WS_CHILD | WS_VISIBLE |
953 WS_TABSTOP | BS_PUSHBUTTON,
ca20bfcf 954 0, "&Down", dnbid);
955
956 break;
957
958 }
959 }
960
961 cp->ypos += totalheight + GAPBETWEEN;
962
963}
964
965/*
966 * Helper function for prefslist: move item in list box.
967 */
968static void pl_moveitem(HWND hwnd, int listid, int src, int dst)
969{
970 int tlen, val;
971 char *txt;
972 /* Get the item's data. */
973 tlen = SendDlgItemMessage (hwnd, listid, LB_GETTEXTLEN, src, 0);
3d88e64d 974 txt = snewn(tlen+1, char);
ca20bfcf 975 SendDlgItemMessage (hwnd, listid, LB_GETTEXT, src, (LPARAM) txt);
976 val = SendDlgItemMessage (hwnd, listid, LB_GETITEMDATA, src, 0);
977 /* Deselect old location. */
978 SendDlgItemMessage (hwnd, listid, LB_SETSEL, FALSE, src);
979 /* Delete it at the old location. */
980 SendDlgItemMessage (hwnd, listid, LB_DELETESTRING, src, 0);
981 /* Insert it at new location. */
982 SendDlgItemMessage (hwnd, listid, LB_INSERTSTRING, dst,
983 (LPARAM) txt);
984 SendDlgItemMessage (hwnd, listid, LB_SETITEMDATA, dst,
985 (LPARAM) val);
986 /* Set selection. */
987 SendDlgItemMessage (hwnd, listid, LB_SETCURSEL, dst, 0);
988 sfree (txt);
989}
990
991int pl_itemfrompt(HWND hwnd, POINT cursor, BOOL scroll)
992{
993 int ret;
994 POINT uppoint, downpoint;
995 int updist, downdist, upitem, downitem, i;
996
997 /*
998 * Ghastly hackery to try to figure out not which
999 * _item_, but which _gap between items_, the user
1000 * is pointing at. We do this by first working out
1001 * which list item is under the cursor, and then
1002 * working out how far the cursor would have to
1003 * move up or down before the answer was different.
1004 * Then we put the insertion point _above_ the
1005 * current item if the upper edge is closer than
1006 * the lower edge, or _below_ it if vice versa.
1007 */
1008 ret = LBItemFromPt(hwnd, cursor, scroll);
ca20bfcf 1009 if (ret == -1)
1010 return ret;
1011 ret = LBItemFromPt(hwnd, cursor, FALSE);
ca20bfcf 1012 updist = downdist = 0;
1013 for (i = 1; i < 4096 && (!updist || !downdist); i++) {
1014 uppoint = downpoint = cursor;
1015 uppoint.y -= i;
1016 downpoint.y += i;
1017 upitem = LBItemFromPt(hwnd, uppoint, FALSE);
1018 downitem = LBItemFromPt(hwnd, downpoint, FALSE);
1019 if (!updist && upitem != ret)
1020 updist = i;
1021 if (!downdist && downitem != ret)
1022 downdist = i;
1023 }
1024 if (downdist < updist)
1025 ret++;
1026 return ret;
1027}
1028
1029/*
1030 * Handler for prefslist above.
fe8abbf4 1031 *
1032 * Return value has bit 0 set if the dialog box procedure needs to
1033 * return TRUE from handling this message; it has bit 1 set if a
1034 * change may have been made in the contents of the list.
ca20bfcf 1035 */
1036int handle_prefslist(struct prefslist *hdl,
1037 int *array, int maxmemb,
1038 int is_dlmsg, HWND hwnd,
1039 WPARAM wParam, LPARAM lParam)
1040{
1041 int i;
fe8abbf4 1042 int ret = 0;
ca20bfcf 1043
1044 if (is_dlmsg) {
1045
cdcbdf3b 1046 if ((int)wParam == hdl->listid) {
ca20bfcf 1047 DRAGLISTINFO *dlm = (DRAGLISTINFO *)lParam;
d1582b2e 1048 int dest = 0; /* initialise to placate gcc */
ca20bfcf 1049 switch (dlm->uNotification) {
1050 case DL_BEGINDRAG:
1051 hdl->dummyitem =
1052 SendDlgItemMessage(hwnd, hdl->listid,
1053 LB_ADDSTRING, 0, (LPARAM) "");
1054
1055 hdl->srcitem = LBItemFromPt(dlm->hWnd, dlm->ptCursor, TRUE);
1056 hdl->dragging = 0;
1057 /* XXX hack Q183115 */
1058 SetWindowLong(hwnd, DWL_MSGRESULT, TRUE);
fe8abbf4 1059 ret |= 1; break;
ca20bfcf 1060 case DL_CANCELDRAG:
1061 DrawInsert(hwnd, dlm->hWnd, -1); /* Clear arrow */
1062 SendDlgItemMessage(hwnd, hdl->listid,
1063 LB_DELETESTRING, hdl->dummyitem, 0);
1064 hdl->dragging = 0;
fe8abbf4 1065 ret |= 1; break;
ca20bfcf 1066 case DL_DRAGGING:
1067 hdl->dragging = 1;
1068 dest = pl_itemfrompt(dlm->hWnd, dlm->ptCursor, TRUE);
1069 if (dest > hdl->dummyitem) dest = hdl->dummyitem;
1070 DrawInsert (hwnd, dlm->hWnd, dest);
1071 if (dest >= 0)
1072 SetWindowLong(hwnd, DWL_MSGRESULT, DL_MOVECURSOR);
1073 else
1074 SetWindowLong(hwnd, DWL_MSGRESULT, DL_STOPCURSOR);
fe8abbf4 1075 ret |= 1; break;
ca20bfcf 1076 case DL_DROPPED:
2b241edd 1077 if (hdl->dragging) {
1078 dest = pl_itemfrompt(dlm->hWnd, dlm->ptCursor, TRUE);
1079 if (dest > hdl->dummyitem) dest = hdl->dummyitem;
1080 DrawInsert (hwnd, dlm->hWnd, -1);
1081 }
ca20bfcf 1082 SendDlgItemMessage(hwnd, hdl->listid,
1083 LB_DELETESTRING, hdl->dummyitem, 0);
2b241edd 1084 if (hdl->dragging) {
1085 hdl->dragging = 0;
1086 if (dest >= 0) {
1087 /* Correct for "missing" item. */
1088 if (dest > hdl->srcitem) dest--;
1089 pl_moveitem(hwnd, hdl->listid, hdl->srcitem, dest);
1090 }
fe8abbf4 1091 ret |= 2;
ca20bfcf 1092 }
fe8abbf4 1093 ret |= 1; break;
ca20bfcf 1094 }
1095 }
1096
1097 } else {
1098
ca20bfcf 1099 if (((LOWORD(wParam) == hdl->upbid) ||
1100 (LOWORD(wParam) == hdl->dnbid)) &&
1101 ((HIWORD(wParam) == BN_CLICKED) ||
1102 (HIWORD(wParam) == BN_DOUBLECLICKED))) {
1103 /* Move an item up or down the list. */
1104 /* Get the current selection, if any. */
1105 int selection = SendDlgItemMessage (hwnd, hdl->listid, LB_GETCURSEL, 0, 0);
1106 if (selection == LB_ERR) {
1107 MessageBeep(0);
1108 } else {
1109 int nitems;
1110 /* Get the total number of items. */
1111 nitems = SendDlgItemMessage (hwnd, hdl->listid, LB_GETCOUNT, 0, 0);
1112 /* Should we do anything? */
1113 if (LOWORD(wParam) == hdl->upbid && (selection > 0))
1114 pl_moveitem(hwnd, hdl->listid, selection, selection - 1);
1115 else if (LOWORD(wParam) == hdl->dnbid && (selection < nitems - 1))
1116 pl_moveitem(hwnd, hdl->listid, selection, selection + 1);
fe8abbf4 1117 ret |= 2;
ca20bfcf 1118 }
1119
1120 }
1121
1122 }
1123
fe8abbf4 1124 if (array) {
1125 /* Update array to match the list box. */
1126 for (i=0; i < maxmemb; i++)
1127 array[i] = SendDlgItemMessage (hwnd, hdl->listid, LB_GETITEMDATA,
1128 i, 0);
1129 }
ca20bfcf 1130
1131 return ret;
ca20bfcf 1132}
1133
1134/*
6e522441 1135 * A progress bar (from Common Controls). We like our progress bars
1136 * to be smooth and unbroken, without those ugly divisions; some
1137 * older compilers may not support that, but that's life.
1138 */
32874aea 1139void progressbar(struct ctlpos *cp, int id)
1140{
6e522441 1141 RECT r;
1142
32874aea 1143 r.left = GAPBETWEEN;
1144 r.top = cp->ypos;
1145 r.right = cp->width;
1146 r.bottom = PROGBARHEIGHT;
6e522441 1147 cp->ypos += r.bottom + GAPBETWEEN;
1148
32874aea 1149 doctl(cp, r, PROGRESS_CLASS, WS_CHILD | WS_VISIBLE
6e522441 1150#ifdef PBS_SMOOTH
32874aea 1151 | PBS_SMOOTH
6e522441 1152#endif
32874aea 1153 , WS_EX_CLIENTEDGE, "", id);
6e522441 1154}
d74d141c 1155
fe8abbf4 1156/* ----------------------------------------------------------------------
1157 * Platform-specific side of portable dialog-box mechanism.
1158 */
1159
d74d141c 1160/*
fe8abbf4 1161 * This function takes a string, escapes all the ampersands, and
1162 * places a single (unescaped) ampersand in front of the first
1163 * occurrence of the given shortcut character (which may be
1164 * NO_SHORTCUT).
1165 *
1166 * Return value is a malloc'ed copy of the processed version of the
1167 * string.
d74d141c 1168 */
fe8abbf4 1169static char *shortcut_escape(char *text, char shortcut)
1170{
1171 char *ret;
1172 char *p, *q;
1173
1174 if (!text)
1175 return NULL; /* sfree won't choke on this */
1176
3d88e64d 1177 ret = snewn(2*strlen(text)+1, char); /* size potentially doubles! */
fe8abbf4 1178 shortcut = tolower((unsigned char)shortcut);
1179
1180 p = text;
1181 q = ret;
1182 while (*p) {
1183 if (shortcut != NO_SHORTCUT &&
1184 tolower((unsigned char)*p) == shortcut) {
1185 *q++ = '&';
1186 shortcut = NO_SHORTCUT; /* stop it happening twice */
1187 } else if (*p == '&') {
1188 *q++ = '&';
1189 }
1190 *q++ = *p++;
1191 }
1192 *q = '\0';
1193 return ret;
1194}
d74d141c 1195
fe8abbf4 1196void winctrl_add_shortcuts(struct dlgparam *dp, struct winctrl *c)
1197{
1198 int i;
1199 for (i = 0; i < lenof(c->shortcuts); i++)
1200 if (c->shortcuts[i] != NO_SHORTCUT) {
1201 unsigned char s = tolower((unsigned char)c->shortcuts[i]);
1202 assert(!dp->shortcuts[s]);
1203 dp->shortcuts[s] = TRUE;
1204 }
1205}
1206
1207void winctrl_rem_shortcuts(struct dlgparam *dp, struct winctrl *c)
1208{
1209 int i;
1210 for (i = 0; i < lenof(c->shortcuts); i++)
1211 if (c->shortcuts[i] != NO_SHORTCUT) {
1212 unsigned char s = tolower((unsigned char)c->shortcuts[i]);
1213 assert(dp->shortcuts[s]);
1214 dp->shortcuts[s] = FALSE;
1215 }
1216}
1217
1218static int winctrl_cmp_byctrl(void *av, void *bv)
1219{
1220 struct winctrl *a = (struct winctrl *)av;
1221 struct winctrl *b = (struct winctrl *)bv;
1222 if (a->ctrl < b->ctrl)
1223 return -1;
1224 else if (a->ctrl > b->ctrl)
1225 return +1;
1226 else
1227 return 0;
1228}
1229static int winctrl_cmp_byid(void *av, void *bv)
1230{
1231 struct winctrl *a = (struct winctrl *)av;
1232 struct winctrl *b = (struct winctrl *)bv;
1233 if (a->base_id < b->base_id)
1234 return -1;
1235 else if (a->base_id > b->base_id)
1236 return +1;
1237 else
1238 return 0;
1239}
1240static int winctrl_cmp_byctrl_find(void *av, void *bv)
1241{
1242 union control *a = (union control *)av;
1243 struct winctrl *b = (struct winctrl *)bv;
1244 if (a < b->ctrl)
1245 return -1;
1246 else if (a > b->ctrl)
1247 return +1;
1248 else
1249 return 0;
1250}
1251static int winctrl_cmp_byid_find(void *av, void *bv)
1252{
1253 int *a = (int *)av;
1254 struct winctrl *b = (struct winctrl *)bv;
1255 if (*a < b->base_id)
1256 return -1;
1257 else if (*a >= b->base_id + b->num_ids)
1258 return +1;
1259 else
1260 return 0;
1261}
1262
1263void winctrl_init(struct winctrls *wc)
1264{
1265 wc->byctrl = newtree234(winctrl_cmp_byctrl);
1266 wc->byid = newtree234(winctrl_cmp_byid);
1267}
1268void winctrl_cleanup(struct winctrls *wc)
1269{
1270 struct winctrl *c;
1271
1272 while ((c = index234(wc->byid, 0)) != NULL) {
1273 winctrl_remove(wc, c);
1274 sfree(c->data);
1275 sfree(c);
1276 }
d74d141c 1277
fe8abbf4 1278 freetree234(wc->byctrl);
1279 freetree234(wc->byid);
1280 wc->byctrl = wc->byid = NULL;
1281}
1282
1283void winctrl_add(struct winctrls *wc, struct winctrl *c)
1284{
1285 struct winctrl *ret;
1286 if (c->ctrl) {
1287 ret = add234(wc->byctrl, c);
1288 assert(ret == c);
1289 }
1290 ret = add234(wc->byid, c);
1291 assert(ret == c);
1292}
1293
1294void winctrl_remove(struct winctrls *wc, struct winctrl *c)
1295{
1296 struct winctrl *ret;
1297 ret = del234(wc->byctrl, c);
1298 ret = del234(wc->byid, c);
1299 assert(ret == c);
1300}
1301
1302struct winctrl *winctrl_findbyctrl(struct winctrls *wc, union control *ctrl)
1303{
1304 return find234(wc->byctrl, ctrl, winctrl_cmp_byctrl_find);
1305}
1306
1307struct winctrl *winctrl_findbyid(struct winctrls *wc, int id)
1308{
1309 return find234(wc->byid, &id, winctrl_cmp_byid_find);
1310}
1311
1312struct winctrl *winctrl_findbyindex(struct winctrls *wc, int index)
1313{
1314 return index234(wc->byid, index);
1315}
1316
1317void winctrl_layout(struct dlgparam *dp, struct winctrls *wc,
1318 struct ctlpos *cp, struct controlset *s, int *id)
1319{
1320 struct ctlpos columns[16];
1321 int ncols, colstart, colspan;
1322
1323 struct ctlpos tabdelays[16];
1324 union control *tabdelayed[16];
1325 int ntabdelays;
1326
1327 struct ctlpos pos;
1328
d1582b2e 1329 char shortcuts[MAX_SHORTCUTS_PER_CTRL];
1330 int nshortcuts;
fe8abbf4 1331 char *escaped;
0bd8d76d 1332 int i, actual_base_id, base_id, num_ids;
fe8abbf4 1333 void *data;
1334
1335 base_id = *id;
1336
1337 /* Start a containing box, if we have a boxname. */
1338 if (s->boxname && *s->boxname) {
3d88e64d 1339 struct winctrl *c = snew(struct winctrl);
fe8abbf4 1340 c->ctrl = NULL;
1341 c->base_id = base_id;
1342 c->num_ids = 1;
1343 c->data = NULL;
1344 memset(c->shortcuts, NO_SHORTCUT, lenof(c->shortcuts));
1345 winctrl_add(wc, c);
1346 beginbox(cp, s->boxtitle, base_id);
1347 base_id++;
1348 }
1349
1350 /* Draw a title, if we have one. */
1351 if (!s->boxname && s->boxtitle) {
3d88e64d 1352 struct winctrl *c = snew(struct winctrl);
fe8abbf4 1353 c->ctrl = NULL;
1354 c->base_id = base_id;
1355 c->num_ids = 1;
1356 c->data = dupstr(s->boxtitle);
1357 memset(c->shortcuts, NO_SHORTCUT, lenof(c->shortcuts));
1358 winctrl_add(wc, c);
1359 paneltitle(cp, base_id);
1360 base_id++;
1361 }
1362
1363 /* Initially we have just one column. */
1364 ncols = 1;
1365 columns[0] = *cp; /* structure copy */
1366
1367 /* And initially, there are no pending tab-delayed controls. */
1368 ntabdelays = 0;
1369
1370 /* Loop over each control in the controlset. */
1371 for (i = 0; i < s->ncontrols; i++) {
1372 union control *ctrl = s->ctrls[i];
1373
fe8abbf4 1374 /*
1375 * Generic processing that pertains to all control types.
1376 * At the end of this if statement, we'll have produced
1377 * `ctrl' (a pointer to the control we have to create, or
1378 * think about creating, in this iteration of the loop),
1379 * `pos' (a suitable ctlpos with which to position it), and
1380 * `c' (a winctrl structure to receive details of the
1381 * dialog IDs). Or we'll have done a `continue', if it was
1382 * CTRL_COLUMNS and doesn't require any control creation at
1383 * all.
1384 */
1385 if (ctrl->generic.type == CTRL_COLUMNS) {
1386 assert((ctrl->columns.ncols == 1) ^ (ncols == 1));
1387
1388 if (ncols == 1) {
1389 /*
1390 * We're splitting into multiple columns.
1391 */
1392 int lpercent, rpercent, lx, rx, i;
1393
1394 ncols = ctrl->columns.ncols;
1395 assert(ncols <= lenof(columns));
1396 for (i = 1; i < ncols; i++)
1397 columns[i] = columns[0]; /* structure copy */
1398
1399 lpercent = 0;
1400 for (i = 0; i < ncols; i++) {
1401 rpercent = lpercent + ctrl->columns.percentages[i];
1402 lx = columns[i].xoff + lpercent *
1403 (columns[i].width + GAPBETWEEN) / 100;
1404 rx = columns[i].xoff + rpercent *
1405 (columns[i].width + GAPBETWEEN) / 100;
1406 columns[i].xoff = lx;
1407 columns[i].width = rx - lx - GAPBETWEEN;
1408 lpercent = rpercent;
1409 }
1410 } else {
a4b92c62 1411 /*
fe8abbf4 1412 * We're recombining the various columns into one.
a4b92c62 1413 */
fe8abbf4 1414 int maxy = columns[0].ypos;
1415 int i;
1416 for (i = 1; i < ncols; i++)
1417 if (maxy < columns[i].ypos)
1418 maxy = columns[i].ypos;
1419 ncols = 1;
1420 columns[0] = *cp; /* structure copy */
1421 columns[0].ypos = maxy;
1422 }
1423
1424 continue;
1425 } else if (ctrl->generic.type == CTRL_TABDELAY) {
1426 int i;
1427
1428 assert(!ctrl->generic.tabdelay);
1429 ctrl = ctrl->tabdelay.ctrl;
fe8abbf4 1430
1431 for (i = 0; i < ntabdelays; i++)
1432 if (tabdelayed[i] == ctrl)
1433 break;
1434 assert(i < ntabdelays); /* we have to have found it */
1435
1436 pos = tabdelays[i]; /* structure copy */
1437
d1582b2e 1438 colstart = colspan = -1; /* indicate this was tab-delayed */
1439
fe8abbf4 1440 } else {
1441 /*
1442 * If it wasn't one of those, it's a genuine control;
1443 * so we'll have to compute a position for it now, by
1444 * checking its column span.
1445 */
1446 int col;
1447
1448 colstart = COLUMN_START(ctrl->generic.column);
1449 colspan = COLUMN_SPAN(ctrl->generic.column);
1450
1451 pos = columns[colstart]; /* structure copy */
1452 pos.width = columns[colstart+colspan-1].width +
1453 (columns[colstart+colspan-1].xoff - columns[colstart].xoff);
1454
1455 for (col = colstart; col < colstart+colspan; col++)
1456 if (pos.ypos < columns[col].ypos)
1457 pos.ypos = columns[col].ypos;
1458
1459 /*
1460 * If this control is to be tabdelayed, add it to the
1461 * tabdelay list, and unset pos.hwnd to inhibit actual
1462 * control creation.
1463 */
1464 if (ctrl->generic.tabdelay) {
1465 assert(ntabdelays < lenof(tabdelays));
1466 tabdelays[ntabdelays] = pos; /* structure copy */
1467 tabdelayed[ntabdelays] = ctrl;
1468 ntabdelays++;
1469 pos.hwnd = NULL;
d74d141c 1470 }
1471 }
fe8abbf4 1472
1473 /* Most controls don't need anything in c->data. */
1474 data = NULL;
1475
1476 /* And they all start off with no shortcuts registered. */
1477 memset(shortcuts, NO_SHORTCUT, lenof(shortcuts));
1478 nshortcuts = 0;
1479
0bd8d76d 1480 /* Almost all controls start at base_id. */
1481 actual_base_id = base_id;
1482
fe8abbf4 1483 /*
1484 * Now we're ready to actually create the control, by
1485 * switching on its type.
1486 */
1487 switch (ctrl->generic.type) {
1488 case CTRL_TEXT:
1489 {
1490 char *wrapped, *escaped;
1491 int lines;
1492 num_ids = 1;
1493 wrapped = staticwrap(&pos, cp->hwnd,
1494 ctrl->generic.label, &lines);
1495 escaped = shortcut_escape(wrapped, NO_SHORTCUT);
1496 statictext(&pos, escaped, lines, base_id);
1497 sfree(escaped);
1498 sfree(wrapped);
1499 }
1500 break;
1501 case CTRL_EDITBOX:
1502 num_ids = 2; /* static, edit */
1503 escaped = shortcut_escape(ctrl->editbox.label,
1504 ctrl->editbox.shortcut);
1505 shortcuts[nshortcuts++] = ctrl->editbox.shortcut;
1506 if (ctrl->editbox.percentwidth == 100) {
1507 if (ctrl->editbox.has_list)
1508 combobox(&pos, escaped,
1509 base_id, base_id+1);
1510 else
1511 multiedit(&pos, ctrl->editbox.password, escaped,
1512 base_id, base_id+1, 100, NULL);
1513 } else {
1514 if (ctrl->editbox.has_list) {
1515 staticcombo(&pos, escaped, base_id, base_id+1,
1516 ctrl->editbox.percentwidth);
1517 } else {
1518 (ctrl->editbox.password ? staticpassedit : staticedit)
1519 (&pos, escaped, base_id, base_id+1,
1520 ctrl->editbox.percentwidth);
1521 }
1522 }
1523 sfree(escaped);
1524 break;
1525 case CTRL_RADIO:
1526 num_ids = ctrl->radio.nbuttons + 1; /* label as well */
1527 {
1528 struct radio *buttons;
1529 int i;
1530
1531 escaped = shortcut_escape(ctrl->radio.label,
1532 ctrl->radio.shortcut);
1533 shortcuts[nshortcuts++] = ctrl->radio.shortcut;
1534
3d88e64d 1535 buttons = snewn(ctrl->radio.nbuttons, struct radio);
fe8abbf4 1536
1537 for (i = 0; i < ctrl->radio.nbuttons; i++) {
1538 buttons[i].text =
1539 shortcut_escape(ctrl->radio.buttons[i],
1540 (char)(ctrl->radio.shortcuts ?
1541 ctrl->radio.shortcuts[i] :
1542 NO_SHORTCUT));
1543 buttons[i].id = base_id + 1 + i;
1544 if (ctrl->radio.shortcuts) {
1545 assert(nshortcuts < MAX_SHORTCUTS_PER_CTRL);
1546 shortcuts[nshortcuts++] = ctrl->radio.shortcuts[i];
1547 }
1548 }
1549
1550 radioline_common(&pos, escaped, base_id,
1551 ctrl->radio.ncolumns,
1552 buttons, ctrl->radio.nbuttons);
1553
1554 for (i = 0; i < ctrl->radio.nbuttons; i++) {
1555 sfree(buttons[i].text);
1556 }
1557 sfree(buttons);
1558 sfree(escaped);
1559 }
1560 break;
1561 case CTRL_CHECKBOX:
1562 num_ids = 1;
1563 escaped = shortcut_escape(ctrl->checkbox.label,
1564 ctrl->checkbox.shortcut);
1565 shortcuts[nshortcuts++] = ctrl->checkbox.shortcut;
1566 checkbox(&pos, escaped, base_id);
1567 sfree(escaped);
1568 break;
1569 case CTRL_BUTTON:
1570 escaped = shortcut_escape(ctrl->button.label,
1571 ctrl->button.shortcut);
1572 shortcuts[nshortcuts++] = ctrl->button.shortcut;
0bd8d76d 1573 if (ctrl->button.iscancel)
1574 actual_base_id = IDCANCEL;
fe8abbf4 1575 num_ids = 1;
0bd8d76d 1576 button(&pos, escaped, actual_base_id, ctrl->button.isdefault);
fe8abbf4 1577 sfree(escaped);
1578 break;
1579 case CTRL_LISTBOX:
1580 num_ids = 2;
1581 escaped = shortcut_escape(ctrl->listbox.label,
1582 ctrl->listbox.shortcut);
1583 shortcuts[nshortcuts++] = ctrl->listbox.shortcut;
1584 if (ctrl->listbox.draglist) {
3d88e64d 1585 data = snew(struct prefslist);
fe8abbf4 1586 num_ids = 4;
1587 prefslist(data, &pos, ctrl->listbox.height, escaped,
1588 base_id, base_id+1, base_id+2, base_id+3);
1589 shortcuts[nshortcuts++] = 'u'; /* Up */
1590 shortcuts[nshortcuts++] = 'd'; /* Down */
1591 } else if (ctrl->listbox.height == 0) {
1592 /* Drop-down list. */
1593 if (ctrl->listbox.percentwidth == 100) {
1594 staticddlbig(&pos, escaped,
1595 base_id, base_id+1);
1596 } else {
1597 staticddl(&pos, escaped, base_id,
1598 base_id+1, ctrl->listbox.percentwidth);
1599 }
1600 } else {
1601 /* Ordinary list. */
1602 listbox(&pos, escaped, base_id, base_id+1,
1603 ctrl->listbox.height, ctrl->listbox.multisel);
1604 }
1605 if (ctrl->listbox.ncols) {
1606 /*
1607 * This method of getting the box width is a bit of
1608 * a hack; we'd do better to try to retrieve the
1609 * actual width in dialog units from doctl() just
1610 * before MapDialogRect. But that's going to be no
1611 * fun, and this should be good enough accuracy.
1612 */
1613 int width = cp->width * ctrl->listbox.percentwidth;
1614 int *tabarray;
1615 int i, percent;
1616
3d88e64d 1617 tabarray = snewn(ctrl->listbox.ncols-1, int);
fe8abbf4 1618 percent = 0;
1619 for (i = 0; i < ctrl->listbox.ncols-1; i++) {
1620 percent += ctrl->listbox.percentages[i];
1621 tabarray[i] = width * percent / 10000;
1622 }
1623 SendDlgItemMessage(cp->hwnd, base_id+1, LB_SETTABSTOPS,
1624 ctrl->listbox.ncols-1, (LPARAM)tabarray);
1625 sfree(tabarray);
1626 }
1627 sfree(escaped);
1628 break;
1629 case CTRL_FILESELECT:
1630 num_ids = 3;
1631 escaped = shortcut_escape(ctrl->fileselect.label,
1632 ctrl->fileselect.shortcut);
1633 shortcuts[nshortcuts++] = ctrl->fileselect.shortcut;
1634 editbutton(&pos, escaped, base_id, base_id+1,
1635 "Bro&wse...", base_id+2);
1636 shortcuts[nshortcuts++] = 'w';
1637 sfree(escaped);
1638 break;
1639 case CTRL_FONTSELECT:
1640 num_ids = 3;
1641 escaped = shortcut_escape(ctrl->fontselect.label,
1642 ctrl->fontselect.shortcut);
1643 shortcuts[nshortcuts++] = ctrl->fontselect.shortcut;
1644 statictext(&pos, escaped, 1, base_id);
1645 staticbtn(&pos, "", base_id+1, "Change...", base_id+2);
1646 sfree(escaped);
3d88e64d 1647 data = snew(FontSpec);
fe8abbf4 1648 break;
1649 default:
1650 assert(!"Can't happen");
d1582b2e 1651 num_ids = 0; /* placate gcc */
fe8abbf4 1652 break;
1653 }
1654
1655 /*
1656 * Create a `struct winctrl' for this control, and advance
1657 * the dialog ID counter, if it's actually been created
1658 * (and isn't tabdelayed).
1659 */
1660 if (pos.hwnd) {
3d88e64d 1661 struct winctrl *c = snew(struct winctrl);
fe8abbf4 1662
1663 c->ctrl = ctrl;
0bd8d76d 1664 c->base_id = actual_base_id;
fe8abbf4 1665 c->num_ids = num_ids;
1666 c->data = data;
1667 memcpy(c->shortcuts, shortcuts, sizeof(shortcuts));
1668 winctrl_add(wc, c);
1669 winctrl_add_shortcuts(dp, c);
0bd8d76d 1670 if (actual_base_id == base_id)
1671 base_id += num_ids;
fe8abbf4 1672 }
1673
d1582b2e 1674 if (colstart >= 0) {
fe8abbf4 1675 /*
1676 * Update the ypos in all columns crossed by this
1677 * control.
1678 */
1679 int i;
1680 for (i = colstart; i < colstart+colspan; i++)
1681 columns[i].ypos = pos.ypos;
1682 }
d74d141c 1683 }
fe8abbf4 1684
1685 /*
1686 * We've now finished laying out the controls; so now update
1687 * the ctlpos and control ID that were passed in, terminate
1688 * any containing box, and return.
1689 */
1690 for (i = 0; i < ncols; i++)
1691 if (cp->ypos < columns[i].ypos)
1692 cp->ypos = columns[i].ypos;
1693 *id = base_id;
1694
1695 if (s->boxname && *s->boxname)
1696 endbox(cp);
1697}
1698
1699static void winctrl_set_focus(union control *ctrl, struct dlgparam *dp,
1700 int has_focus)
1701{
1702 if (has_focus) {
1703 if (dp->focused)
1704 dp->lastfocused = dp->focused;
1705 dp->focused = ctrl;
1706 } else if (!has_focus && dp->focused == ctrl) {
1707 dp->lastfocused = dp->focused;
1708 dp->focused = NULL;
1709 }
1710}
1711
0bd8d76d 1712union control *dlg_last_focused(union control *ctrl, void *dlg)
fe8abbf4 1713{
1714 struct dlgparam *dp = (struct dlgparam *)dlg;
0bd8d76d 1715 return dp->focused == ctrl ? dp->lastfocused : dp->focused;
fe8abbf4 1716}
1717
1718/*
1719 * The dialog-box procedure calls this function to handle Windows
1720 * messages on a control we manage.
1721 */
1722int winctrl_handle_command(struct dlgparam *dp, UINT msg,
1723 WPARAM wParam, LPARAM lParam)
1724{
1725 struct winctrl *c;
1726 union control *ctrl;
1727 int i, id, ret;
1728 static UINT draglistmsg = WM_NULL;
1729
1730 /*
1731 * Filter out pointless window messages. Our interest is in
1732 * WM_COMMAND and the drag list message, and nothing else.
1733 */
1734 if (draglistmsg == WM_NULL)
1735 draglistmsg = RegisterWindowMessage (DRAGLISTMSGSTRING);
1736
1737 if (msg != draglistmsg && msg != WM_COMMAND && msg != WM_DRAWITEM)
1738 return 0;
1739
1740 /*
1741 * Look up the control ID in our data.
1742 */
d1582b2e 1743 c = NULL;
fe8abbf4 1744 for (i = 0; i < dp->nctrltrees; i++) {
1745 c = winctrl_findbyid(dp->controltrees[i], LOWORD(wParam));
1746 if (c)
1747 break;
1748 }
1749 if (!c)
1750 return 0; /* we have nothing to do */
1751
1752 if (msg == WM_DRAWITEM) {
1753 /*
1754 * Owner-draw request for a panel title.
1755 */
1756 LPDRAWITEMSTRUCT di = (LPDRAWITEMSTRUCT) lParam;
1757 HDC hdc = di->hDC;
1758 RECT r = di->rcItem;
1759 SIZE s;
1760
97332719 1761 SetMapMode(hdc, MM_TEXT); /* ensure logical units == pixels */
1762
fe8abbf4 1763 GetTextExtentPoint32(hdc, (char *)c->data,
1764 strlen((char *)c->data), &s);
1765 DrawEdge(hdc, &r, EDGE_ETCHED, BF_ADJUST | BF_RECT);
1766 TextOut(hdc,
1767 r.left + (r.right-r.left-s.cx)/2,
1768 r.top + (r.bottom-r.top-s.cy)/2,
1769 (char *)c->data, strlen((char *)c->data));
1770
1771 return TRUE;
1772 }
1773
1774 ctrl = c->ctrl;
1775 id = LOWORD(wParam) - c->base_id;
1776
1777 if (!ctrl || !ctrl->generic.handler)
1778 return 0; /* nothing we can do here */
1779
1780 /*
1781 * From here on we do not issue `return' statements until the
1782 * very end of the dialog box: any event handler is entitled to
1783 * ask for a colour selector, so we _must_ always allow control
1784 * to reach the end of this switch statement so that the
1785 * subsequent code can test dp->coloursel_wanted().
1786 */
1787 ret = 0;
1788 dp->coloursel_wanted = FALSE;
1789
1790 /*
1791 * Now switch on the control type and the message.
1792 */
1793 switch (ctrl->generic.type) {
1794 case CTRL_EDITBOX:
1795 if (msg == WM_COMMAND && !ctrl->editbox.has_list &&
1796 (HIWORD(wParam) == EN_SETFOCUS || HIWORD(wParam) == EN_KILLFOCUS))
1797 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == EN_SETFOCUS);
1798 if (msg == WM_COMMAND && ctrl->editbox.has_list &&
1799 (HIWORD(wParam)==CBN_SETFOCUS || HIWORD(wParam)==CBN_KILLFOCUS))
1800 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == CBN_SETFOCUS);
1801
1802 if (msg == WM_COMMAND && !ctrl->editbox.has_list &&
1803 HIWORD(wParam) == EN_CHANGE)
1804 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1805 if (msg == WM_COMMAND &&
1806 ctrl->editbox.has_list) {
1807 if (HIWORD(wParam) == CBN_SELCHANGE) {
1808 int index, len;
1809 char *text;
1810
1811 index = SendDlgItemMessage(dp->hwnd, c->base_id+1,
1812 CB_GETCURSEL, 0, 0);
1813 len = SendDlgItemMessage(dp->hwnd, c->base_id+1,
1814 CB_GETLBTEXTLEN, index, 0);
3d88e64d 1815 text = snewn(len+1, char);
fe8abbf4 1816 SendDlgItemMessage(dp->hwnd, c->base_id+1, CB_GETLBTEXT,
1817 index, (LPARAM)text);
1818 SetDlgItemText(dp->hwnd, c->base_id+1, text);
1819 sfree(text);
1820 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1821 } else if (HIWORD(wParam) == CBN_EDITCHANGE) {
1822 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1823 } else if (HIWORD(wParam) == CBN_KILLFOCUS) {
1824 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_REFRESH);
1825 }
1826
1827 }
1828 break;
1829 case CTRL_RADIO:
1830 if (msg == WM_COMMAND &&
1831 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1832 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
1833 /*
1834 * We sometimes get spurious BN_CLICKED messages for the
1835 * radio button that is just about to _lose_ selection, if
1836 * we're switching using the arrow keys. Therefore we
1837 * double-check that the button in wParam is actually
1838 * checked before generating an event.
1839 */
1840 if (msg == WM_COMMAND &&
d1582b2e 1841 (HIWORD(wParam) == BN_CLICKED ||
1842 HIWORD(wParam) == BN_DOUBLECLICKED) &&
fe8abbf4 1843 IsDlgButtonChecked(dp->hwnd, LOWORD(wParam))) {
1844 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1845 }
1846 break;
1847 case CTRL_CHECKBOX:
1848 if (msg == WM_COMMAND &&
1849 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1850 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
1851 if (msg == WM_COMMAND &&
1852 (HIWORD(wParam) == BN_CLICKED ||
1853 HIWORD(wParam) == BN_DOUBLECLICKED)) {
1854 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1855 }
1856 break;
1857 case CTRL_BUTTON:
1858 if (msg == WM_COMMAND &&
1859 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1860 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
1861 if (msg == WM_COMMAND &&
1862 (HIWORD(wParam) == BN_CLICKED ||
1863 HIWORD(wParam) == BN_DOUBLECLICKED)) {
1864 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_ACTION);
1865 }
1866 break;
1867 case CTRL_LISTBOX:
1868 if (msg == WM_COMMAND && ctrl->listbox.height != 0 &&
1869 (HIWORD(wParam)==LBN_SETFOCUS || HIWORD(wParam)==LBN_KILLFOCUS))
1870 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == LBN_SETFOCUS);
1871 if (msg == WM_COMMAND && ctrl->listbox.height == 0 &&
1872 (HIWORD(wParam)==CBN_SETFOCUS || HIWORD(wParam)==CBN_KILLFOCUS))
1873 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == CBN_SETFOCUS);
1874 if (msg == WM_COMMAND && id >= 2 &&
1875 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1876 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
1877 if (ctrl->listbox.draglist) {
1878 int pret;
1879 pret = handle_prefslist(c->data, NULL, 0, (msg != WM_COMMAND),
1880 dp->hwnd, wParam, lParam);
1881 if (pret & 2)
1882 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1883 ret = pret & 1;
1884 } else {
1885 if (msg == WM_COMMAND && HIWORD(wParam) == LBN_DBLCLK) {
1886 SetCapture(dp->hwnd);
1887 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_ACTION);
1888 } else if (msg == WM_COMMAND && HIWORD(wParam) == LBN_SELCHANGE) {
1889 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_SELCHANGE);
1890 }
1891 }
1892 break;
1893 case CTRL_FILESELECT:
1894 if (msg == WM_COMMAND && id == 1 &&
1895 (HIWORD(wParam) == EN_SETFOCUS || HIWORD(wParam) == EN_KILLFOCUS))
1896 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == EN_SETFOCUS);
1897 if (msg == WM_COMMAND && id == 2 &&
1898 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1899 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
875e0b16 1900 if (msg == WM_COMMAND && id == 1 && HIWORD(wParam) == EN_CHANGE)
1901 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
fe8abbf4 1902 if (id == 2 &&
1903 (msg == WM_COMMAND &&
1904 (HIWORD(wParam) == BN_CLICKED ||
1905 HIWORD(wParam) == BN_DOUBLECLICKED))) {
1906 OPENFILENAME of;
1907 char filename[FILENAME_MAX];
1908 int ret;
1909
1910 memset(&of, 0, sizeof(of));
1911#ifdef OPENFILENAME_SIZE_VERSION_400
1912 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
1913#else
1914 of.lStructSize = sizeof(of);
1915#endif
1916 of.hwndOwner = dp->hwnd;
1917 if (ctrl->fileselect.filter)
1918 of.lpstrFilter = ctrl->fileselect.filter;
1919 else
1920 of.lpstrFilter = "All Files (*.*)\0*\0\0\0";
1921 of.lpstrCustomFilter = NULL;
1922 of.nFilterIndex = 1;
1923 of.lpstrFile = filename;
1924 GetDlgItemText(dp->hwnd, c->base_id+1, filename, lenof(filename));
1925 filename[lenof(filename)-1] = '\0';
1926 of.nMaxFile = lenof(filename);
1927 of.lpstrFileTitle = NULL;
1928 of.lpstrInitialDir = NULL;
1929 of.lpstrTitle = ctrl->fileselect.title;
1930 of.Flags = 0;
1931 if (ctrl->fileselect.for_writing)
1932 ret = GetSaveFileName(&of);
1933 else
1934 ret = GetOpenFileName(&of);
1935 if (ret) {
1936 SetDlgItemText(dp->hwnd, c->base_id + 1, filename);
1937 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1938 }
1939 }
1940 break;
1941 case CTRL_FONTSELECT:
1942 if (msg == WM_COMMAND && id == 2 &&
1943 (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
1944 winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
1945 if (id == 2 &&
1946 (msg == WM_COMMAND &&
1947 (HIWORD(wParam) == BN_CLICKED ||
1948 HIWORD(wParam) == BN_DOUBLECLICKED))) {
1949 CHOOSEFONT cf;
1950 LOGFONT lf;
1951 HDC hdc;
1952 FontSpec fs = *(FontSpec *)c->data;
1953
1954 hdc = GetDC(0);
1955 lf.lfHeight = -MulDiv(fs.height,
1956 GetDeviceCaps(hdc, LOGPIXELSY), 72);
1957 ReleaseDC(0, hdc);
1958 lf.lfWidth = lf.lfEscapement = lf.lfOrientation = 0;
1959 lf.lfItalic = lf.lfUnderline = lf.lfStrikeOut = 0;
1960 lf.lfWeight = (fs.isbold ? FW_BOLD : 0);
1961 lf.lfCharSet = fs.charset;
1962 lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
1963 lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1964 lf.lfQuality = DEFAULT_QUALITY;
1965 lf.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
1966 strncpy(lf.lfFaceName, fs.name,
1967 sizeof(lf.lfFaceName) - 1);
1968 lf.lfFaceName[sizeof(lf.lfFaceName) - 1] = '\0';
1969
1970 cf.lStructSize = sizeof(cf);
1971 cf.hwndOwner = dp->hwnd;
1972 cf.lpLogFont = &lf;
1973 cf.Flags = CF_FIXEDPITCHONLY | CF_FORCEFONTEXIST |
1974 CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS;
1975
1976 if (ChooseFont(&cf)) {
1977 strncpy(fs.name, lf.lfFaceName,
1978 sizeof(fs.name) - 1);
1979 fs.name[sizeof(fs.name) - 1] = '\0';
1980 fs.isbold = (lf.lfWeight == FW_BOLD);
1981 fs.charset = lf.lfCharSet;
1982 fs.height = cf.iPointSize / 10;
1983 dlg_fontsel_set(ctrl, dp, fs);
1984 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
1985 }
1986 }
1987 break;
1988 }
1989
1990 /*
1991 * If the above event handler has asked for a colour selector,
1992 * now is the time to generate one.
1993 */
1994 if (dp->coloursel_wanted) {
1995 static CHOOSECOLOR cc;
1996 static DWORD custom[16] = { 0 }; /* zero initialisers */
1997 cc.lStructSize = sizeof(cc);
1998 cc.hwndOwner = dp->hwnd;
1999 cc.hInstance = (HWND) hinst;
2000 cc.lpCustColors = custom;
2001 cc.rgbResult = RGB(dp->coloursel_result.r,
2002 dp->coloursel_result.g,
2003 dp->coloursel_result.b);
2004 cc.Flags = CC_FULLOPEN | CC_RGBINIT;
2005 if (ChooseColor(&cc)) {
2006 dp->coloursel_result.r =
2007 (unsigned char) (cc.rgbResult & 0xFF);
2008 dp->coloursel_result.g =
2009 (unsigned char) (cc.rgbResult >> 8) & 0xFF;
2010 dp->coloursel_result.b =
2011 (unsigned char) (cc.rgbResult >> 16) & 0xFF;
2012 dp->coloursel_result.ok = TRUE;
2013 } else
2014 dp->coloursel_result.ok = FALSE;
2015 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_CALLBACK);
2016 }
2017
2018 return ret;
2019}
2020
2021/*
2022 * This function can be called to produce context help on a
2023 * control. Returns TRUE if it has actually launched WinHelp.
2024 */
2025int winctrl_context_help(struct dlgparam *dp, HWND hwnd, int id)
2026{
2027 int i;
2028 struct winctrl *c;
2029 char *cmd;
2030
2031 /*
2032 * Look up the control ID in our data.
2033 */
d1582b2e 2034 c = NULL;
fe8abbf4 2035 for (i = 0; i < dp->nctrltrees; i++) {
2036 c = winctrl_findbyid(dp->controltrees[i], id);
2037 if (c)
2038 break;
2039 }
2040 if (!c)
2041 return 0; /* we have nothing to do */
2042
2043 /*
2044 * This is the Windows front end, so we're allowed to assume
2045 * `helpctx.p' is a context string.
2046 */
2047 if (!c->ctrl || !c->ctrl->generic.helpctx.p)
2048 return 0; /* no help available for this ctrl */
2049
2050 cmd = dupprintf("JI(`',`%s')", c->ctrl->generic.helpctx.p);
2051 WinHelp(hwnd, help_path, HELP_COMMAND, (DWORD)cmd);
2052 sfree(cmd);
2053 return 1;
2054}
2055
2056/*
2057 * Now the various functions that the platform-independent
2058 * mechanism can call to access the dialog box entries.
2059 */
2060
2061static struct winctrl *dlg_findbyctrl(struct dlgparam *dp, union control *ctrl)
2062{
2063 int i;
2064
2065 for (i = 0; i < dp->nctrltrees; i++) {
2066 struct winctrl *c = winctrl_findbyctrl(dp->controltrees[i], ctrl);
2067 if (c)
2068 return c;
2069 }
2070 return NULL;
2071}
2072
2073void dlg_radiobutton_set(union control *ctrl, void *dlg, int whichbutton)
2074{
2075 struct dlgparam *dp = (struct dlgparam *)dlg;
2076 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2077 assert(c && c->ctrl->generic.type == CTRL_RADIO);
2078 CheckRadioButton(dp->hwnd,
2079 c->base_id + 1,
2080 c->base_id + c->ctrl->radio.nbuttons,
2081 c->base_id + 1 + whichbutton);
2082}
2083
2084int dlg_radiobutton_get(union control *ctrl, void *dlg)
2085{
2086 struct dlgparam *dp = (struct dlgparam *)dlg;
2087 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2088 int i;
2089 assert(c && c->ctrl->generic.type == CTRL_RADIO);
2090 for (i = 0; i < c->ctrl->radio.nbuttons; i++)
2091 if (IsDlgButtonChecked(dp->hwnd, c->base_id + 1 + i))
2092 return i;
2093 assert(!"No radio button was checked?!");
2094 return 0;
2095}
2096
2097void dlg_checkbox_set(union control *ctrl, void *dlg, int checked)
2098{
2099 struct dlgparam *dp = (struct dlgparam *)dlg;
2100 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2101 assert(c && c->ctrl->generic.type == CTRL_CHECKBOX);
2102 CheckDlgButton(dp->hwnd, c->base_id, (checked != 0));
2103}
2104
2105int dlg_checkbox_get(union control *ctrl, void *dlg)
2106{
2107 struct dlgparam *dp = (struct dlgparam *)dlg;
2108 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2109 assert(c && c->ctrl->generic.type == CTRL_CHECKBOX);
2110 return 0 != IsDlgButtonChecked(dp->hwnd, c->base_id);
2111}
2112
2113void dlg_editbox_set(union control *ctrl, void *dlg, char const *text)
2114{
2115 struct dlgparam *dp = (struct dlgparam *)dlg;
2116 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2117 assert(c && c->ctrl->generic.type == CTRL_EDITBOX);
2118 SetDlgItemText(dp->hwnd, c->base_id+1, text);
2119}
2120
2121void dlg_editbox_get(union control *ctrl, void *dlg, char *buffer, int length)
2122{
2123 struct dlgparam *dp = (struct dlgparam *)dlg;
2124 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2125 assert(c && c->ctrl->generic.type == CTRL_EDITBOX);
2126 GetDlgItemText(dp->hwnd, c->base_id+1, buffer, length);
2127 buffer[length-1] = '\0';
2128}
2129
2130/* The `listbox' functions can also apply to combo boxes. */
2131void dlg_listbox_clear(union control *ctrl, void *dlg)
2132{
2133 struct dlgparam *dp = (struct dlgparam *)dlg;
2134 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2135 int msg;
2136 assert(c &&
2137 (c->ctrl->generic.type == CTRL_LISTBOX ||
d1582b2e 2138 (c->ctrl->generic.type == CTRL_EDITBOX &&
2139 c->ctrl->editbox.has_list)));
fe8abbf4 2140 msg = (c->ctrl->generic.type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
2141 LB_RESETCONTENT : CB_RESETCONTENT);
2142 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, 0);
2143}
2144
2145void dlg_listbox_del(union control *ctrl, void *dlg, int index)
2146{
2147 struct dlgparam *dp = (struct dlgparam *)dlg;
2148 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2149 int msg;
2150 assert(c &&
2151 (c->ctrl->generic.type == CTRL_LISTBOX ||
d1582b2e 2152 (c->ctrl->generic.type == CTRL_EDITBOX &&
2153 c->ctrl->editbox.has_list)));
fe8abbf4 2154 msg = (c->ctrl->generic.type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
2155 LB_DELETESTRING : CB_DELETESTRING);
2156 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
2157}
2158
2159void dlg_listbox_add(union control *ctrl, void *dlg, char const *text)
2160{
2161 struct dlgparam *dp = (struct dlgparam *)dlg;
2162 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2163 int msg;
2164 assert(c &&
2165 (c->ctrl->generic.type == CTRL_LISTBOX ||
d1582b2e 2166 (c->ctrl->generic.type == CTRL_EDITBOX &&
2167 c->ctrl->editbox.has_list)));
fe8abbf4 2168 msg = (c->ctrl->generic.type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
2169 LB_ADDSTRING : CB_ADDSTRING);
2170 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, (LPARAM)text);
2171}
2172
2173/*
2174 * Each listbox entry may have a numeric id associated with it.
2175 * Note that some front ends only permit a string to be stored at
2176 * each position, which means that _if_ you put two identical
2177 * strings in any listbox then you MUST not assign them different
2178 * IDs and expect to get meaningful results back.
2179 */
4eaff8d4 2180void dlg_listbox_addwithid(union control *ctrl, void *dlg,
2181 char const *text, int id)
fe8abbf4 2182{
2183 struct dlgparam *dp = (struct dlgparam *)dlg;
2184 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2185 int msg, msg2, index;
2186 assert(c &&
2187 (c->ctrl->generic.type == CTRL_LISTBOX ||
d1582b2e 2188 (c->ctrl->generic.type == CTRL_EDITBOX &&
2189 c->ctrl->editbox.has_list)));
fe8abbf4 2190 msg = (c->ctrl->generic.type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
2191 LB_ADDSTRING : CB_ADDSTRING);
2192 msg2 = (c->ctrl->generic.type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
2193 LB_SETITEMDATA : CB_SETITEMDATA);
2194 index = SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, (LPARAM)text);
2195 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg2, index, (LPARAM)id);
2196}
2197
2198int dlg_listbox_getid(union control *ctrl, void *dlg, int index)
2199{
2200 struct dlgparam *dp = (struct dlgparam *)dlg;
2201 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2202 int msg;
2203 assert(c && c->ctrl->generic.type == CTRL_LISTBOX);
2204 msg = (c->ctrl->listbox.height != 0 ? LB_GETITEMDATA : CB_GETITEMDATA);
2205 return
2206 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
2207}
2208
2209/* dlg_listbox_index returns <0 if no single element is selected. */
2210int dlg_listbox_index(union control *ctrl, void *dlg)
2211{
2212 struct dlgparam *dp = (struct dlgparam *)dlg;
2213 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2214 int msg, ret;
2215 assert(c && c->ctrl->generic.type == CTRL_LISTBOX &&
2216 !c->ctrl->listbox.multisel);
2217 msg = (c->ctrl->listbox.height != 0 ? LB_GETCURSEL : CB_GETCURSEL);
2218 ret = SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, 0);
2219 if (ret == LB_ERR)
2220 return -1;
2221 else
2222 return ret;
2223}
2224
2225int dlg_listbox_issel(union control *ctrl, void *dlg, int index)
2226{
2227 struct dlgparam *dp = (struct dlgparam *)dlg;
2228 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2229 assert(c && c->ctrl->generic.type == CTRL_LISTBOX &&
2230 c->ctrl->listbox.multisel &&
2231 c->ctrl->listbox.height != 0);
2232 return
2233 SendDlgItemMessage(dp->hwnd, c->base_id+1, LB_GETSEL, index, 0);
2234}
2235
2236void dlg_listbox_select(union control *ctrl, void *dlg, int index)
2237{
2238 struct dlgparam *dp = (struct dlgparam *)dlg;
2239 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2240 int msg;
2241 assert(c && c->ctrl->generic.type == CTRL_LISTBOX &&
2242 !c->ctrl->listbox.multisel);
2243 msg = (c->ctrl->listbox.height != 0 ? LB_SETCURSEL : CB_SETCURSEL);
2244 SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
2245}
2246
2247void dlg_text_set(union control *ctrl, void *dlg, char const *text)
2248{
2249 struct dlgparam *dp = (struct dlgparam *)dlg;
2250 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2251 assert(c && c->ctrl->generic.type == CTRL_TEXT);
2252 SetDlgItemText(dp->hwnd, c->base_id, text);
2253}
2254
2255void dlg_filesel_set(union control *ctrl, void *dlg, Filename fn)
2256{
2257 struct dlgparam *dp = (struct dlgparam *)dlg;
2258 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2259 assert(c && c->ctrl->generic.type == CTRL_FILESELECT);
2260 SetDlgItemText(dp->hwnd, c->base_id+1, fn.path);
2261}
2262
2263void dlg_filesel_get(union control *ctrl, void *dlg, Filename *fn)
2264{
2265 struct dlgparam *dp = (struct dlgparam *)dlg;
2266 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2267 assert(c && c->ctrl->generic.type == CTRL_FILESELECT);
2268 GetDlgItemText(dp->hwnd, c->base_id+1, fn->path, lenof(fn->path));
2269 fn->path[lenof(fn->path)-1] = '\0';
2270}
2271
2272void dlg_fontsel_set(union control *ctrl, void *dlg, FontSpec fs)
2273{
2274 char *buf, *boldstr;
2275 struct dlgparam *dp = (struct dlgparam *)dlg;
2276 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2277 assert(c && c->ctrl->generic.type == CTRL_FONTSELECT);
2278
2279 *(FontSpec *)c->data = fs; /* structure copy */
2280
2281 boldstr = (fs.isbold ? "bold, " : "");
2282 if (fs.height == 0)
2283 buf = dupprintf("Font: %s, %sdefault height", fs.name, boldstr);
2284 else
ab469323 2285 buf = dupprintf("Font: %s, %s%d-%s", fs.name, boldstr,
2286 (fs.height < 0 ? -fs.height : fs.height),
2287 (fs.height < 0 ? "pixel" : "point"));
fe8abbf4 2288 SetDlgItemText(dp->hwnd, c->base_id+1, buf);
2289 sfree(buf);
2290}
2291
2292void dlg_fontsel_get(union control *ctrl, void *dlg, FontSpec *fs)
2293{
2294 struct dlgparam *dp = (struct dlgparam *)dlg;
2295 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2296 assert(c && c->ctrl->generic.type == CTRL_FONTSELECT);
2297 *fs = *(FontSpec *)c->data; /* structure copy */
2298}
2299
2300/*
2301 * Bracketing a large set of updates in these two functions will
2302 * cause the front end (if possible) to delay updating the screen
2303 * until it's all complete, thus avoiding flicker.
2304 */
2305void dlg_update_start(union control *ctrl, void *dlg)
2306{
2307 struct dlgparam *dp = (struct dlgparam *)dlg;
2308 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2309 if (c && c->ctrl->generic.type == CTRL_LISTBOX) {
2310 SendDlgItemMessage(dp->hwnd, c->base_id+1, WM_SETREDRAW, FALSE, 0);
2311 }
2312}
2313
2314void dlg_update_done(union control *ctrl, void *dlg)
2315{
2316 struct dlgparam *dp = (struct dlgparam *)dlg;
2317 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2318 if (c && c->ctrl->generic.type == CTRL_LISTBOX) {
2319 HWND hw = GetDlgItem(dp->hwnd, c->base_id+1);
2320 SendMessage(hw, WM_SETREDRAW, TRUE, 0);
2321 InvalidateRect(hw, NULL, TRUE);
2322 }
2323}
2324
2325void dlg_set_focus(union control *ctrl, void *dlg)
2326{
2327 struct dlgparam *dp = (struct dlgparam *)dlg;
2328 struct winctrl *c = dlg_findbyctrl(dp, ctrl);
2329 int id;
2330 HWND ctl;
2331 switch (ctrl->generic.type) {
2332 case CTRL_EDITBOX: id = c->base_id + 1; break;
2333 case CTRL_RADIO:
2334 for (id = c->base_id + ctrl->radio.nbuttons; id > 1; id--)
2335 if (IsDlgButtonChecked(dp->hwnd, id))
2336 break;
2337 /*
2338 * In the theoretically-unlikely case that no button was
2339 * selected, id should come out of this as 1, which is a
2340 * reasonable enough choice.
2341 */
2342 break;
2343 case CTRL_CHECKBOX: id = c->base_id; break;
2344 case CTRL_BUTTON: id = c->base_id; break;
2345 case CTRL_LISTBOX: id = c->base_id + 1; break;
2346 case CTRL_FILESELECT: id = c->base_id + 1; break;
2347 case CTRL_FONTSELECT: id = c->base_id + 2; break;
2348 default: id = c->base_id; break;
2349 }
2350 ctl = GetDlgItem(dp->hwnd, id);
2351 SetFocus(ctl);
2352}
2353
2354/*
2355 * During event processing, you might well want to give an error
2356 * indication to the user. dlg_beep() is a quick and easy generic
2357 * error; dlg_error() puts up a message-box or equivalent.
2358 */
2359void dlg_beep(void *dlg)
2360{
2361 /* struct dlgparam *dp = (struct dlgparam *)dlg; */
2362 MessageBeep(0);
2363}
2364
2365void dlg_error_msg(void *dlg, char *msg)
2366{
2367 struct dlgparam *dp = (struct dlgparam *)dlg;
2368 MessageBox(dp->hwnd, msg,
2369 dp->errtitle ? dp->errtitle : NULL,
2370 MB_OK | MB_ICONERROR);
2371}
2372
2373/*
2374 * This function signals to the front end that the dialog's
2375 * processing is completed, and passes an integer value (typically
2376 * a success status).
2377 */
2378void dlg_end(void *dlg, int value)
2379{
2380 struct dlgparam *dp = (struct dlgparam *)dlg;
2381 dp->ended = TRUE;
2382 dp->endresult = value;
2383}
2384
2385void dlg_refresh(union control *ctrl, void *dlg)
2386{
2387 struct dlgparam *dp = (struct dlgparam *)dlg;
2388 int i, j;
2389 struct winctrl *c;
2390
2391 if (!ctrl) {
2392 /*
2393 * Send EVENT_REFRESH to absolutely everything.
2394 */
2395 for (j = 0; j < dp->nctrltrees; j++) {
2396 for (i = 0;
2397 (c = winctrl_findbyindex(dp->controltrees[j], i)) != NULL;
2398 i++) {
2399 if (c->ctrl && c->ctrl->generic.handler != NULL)
2400 c->ctrl->generic.handler(c->ctrl, dp,
2401 dp->data, EVENT_REFRESH);
2402 }
2403 }
2404 } else {
2405 /*
2406 * Send EVENT_REFRESH to a specific control.
2407 */
2408 if (ctrl->generic.handler != NULL)
2409 ctrl->generic.handler(ctrl, dp, dp->data, EVENT_REFRESH);
2410 }
2411}
2412
2413void dlg_coloursel_start(union control *ctrl, void *dlg, int r, int g, int b)
2414{
2415 struct dlgparam *dp = (struct dlgparam *)dlg;
2416 dp->coloursel_wanted = TRUE;
2417 dp->coloursel_result.r = r;
2418 dp->coloursel_result.g = g;
2419 dp->coloursel_result.b = b;
2420}
2421
2422int dlg_coloursel_results(union control *ctrl, void *dlg,
2423 int *r, int *g, int *b)
2424{
2425 struct dlgparam *dp = (struct dlgparam *)dlg;
2426 if (dp->coloursel_result.ok) {
2427 *r = dp->coloursel_result.r;
2428 *g = dp->coloursel_result.g;
2429 *b = dp->coloursel_result.b;
2430 return 1;
2431 } else
2432 return 0;
d74d141c 2433}
4e6d4091 2434
2435struct perctrl_privdata {
2436 union control *ctrl;
2437 void *data;
2438 int needs_free;
2439};
2440
2441static int perctrl_privdata_cmp(void *av, void *bv)
2442{
2443 struct perctrl_privdata *a = (struct perctrl_privdata *)av;
2444 struct perctrl_privdata *b = (struct perctrl_privdata *)bv;
2445 if (a->ctrl < b->ctrl)
2446 return -1;
2447 else if (a->ctrl > b->ctrl)
2448 return +1;
2449 return 0;
2450}
2451
2452void dp_init(struct dlgparam *dp)
2453{
2454 dp->nctrltrees = 0;
2455 dp->data = NULL;
2456 dp->ended = FALSE;
2457 dp->focused = dp->lastfocused = NULL;
2458 memset(dp->shortcuts, 0, sizeof(dp->shortcuts));
2459 dp->hwnd = NULL;
f6f450e2 2460 dp->wintitle = dp->errtitle = NULL;
4e6d4091 2461 dp->privdata = newtree234(perctrl_privdata_cmp);
2462}
2463
2464void dp_add_tree(struct dlgparam *dp, struct winctrls *wc)
2465{
2466 assert(dp->nctrltrees < lenof(dp->controltrees));
2467 dp->controltrees[dp->nctrltrees++] = wc;
2468}
2469
2470void dp_cleanup(struct dlgparam *dp)
2471{
2472 struct perctrl_privdata *p;
2473
2474 if (dp->privdata) {
2475 while ( (p = index234(dp->privdata, 0)) != NULL ) {
2476 del234(dp->privdata, p);
2477 if (p->needs_free)
2478 sfree(p->data);
2479 sfree(p);
2480 }
2481 freetree234(dp->privdata);
2482 dp->privdata = NULL;
2483 }
f6f450e2 2484 sfree(dp->wintitle);
2485 sfree(dp->errtitle);
4e6d4091 2486}
2487
2488void *dlg_get_privdata(union control *ctrl, void *dlg)
2489{
2490 struct dlgparam *dp = (struct dlgparam *)dlg;
2491 struct perctrl_privdata tmp, *p;
2492 tmp.ctrl = ctrl;
2493 p = find234(dp->privdata, &tmp, NULL);
2494 if (p)
2495 return p->data;
2496 else
2497 return NULL;
2498}
2499
2500void dlg_set_privdata(union control *ctrl, void *dlg, void *ptr)
2501{
2502 struct dlgparam *dp = (struct dlgparam *)dlg;
2503 struct perctrl_privdata tmp, *p;
2504 tmp.ctrl = ctrl;
2505 p = find234(dp->privdata, &tmp, NULL);
2506 if (!p) {
3d88e64d 2507 p = snew(struct perctrl_privdata);
4e6d4091 2508 p->ctrl = ctrl;
2509 p->needs_free = FALSE;
2510 add234(dp->privdata, p);
2511 }
2512 p->data = ptr;
2513}
2514
2515void *dlg_alloc_privdata(union control *ctrl, void *dlg, size_t size)
2516{
2517 struct dlgparam *dp = (struct dlgparam *)dlg;
2518 struct perctrl_privdata tmp, *p;
2519 tmp.ctrl = ctrl;
2520 p = find234(dp->privdata, &tmp, NULL);
2521 if (!p) {
3d88e64d 2522 p = snew(struct perctrl_privdata);
4e6d4091 2523 p->ctrl = ctrl;
2524 p->needs_free = FALSE;
2525 add234(dp->privdata, p);
2526 }
2527 assert(!p->needs_free);
2528 p->needs_free = TRUE;
3d88e64d 2529 /*
2530 * This is an internal allocation routine, so it's allowed to
2531 * use smalloc directly.
2532 */
4e6d4091 2533 p->data = smalloc(size);
2534 return p->data;
2535}
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator