[u/mdw/putty] / dialog.c

/*
 * dialog.c - a reasonably platform-independent mechanism for
 * describing dialog boxes.
 */

#include <assert.h>
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>

#define DEFINE_INTORPTR_FNS

#include "putty.h"
#include "dialog.h"

int ctrl_path_elements(char *path)
{
    int i = 1;
    while (*path) {
	if (*path == '/') i++;
	path++;
    }
    return i;
}

/* Return the number of matching path elements at the starts of p1 and p2,
 * or INT_MAX if the paths are identical. */
int ctrl_path_compare(char *p1, char *p2)
{
    int i = 0;
    while (*p1 || *p2) {
	if ((*p1 == '/' || *p1 == '\0') &&
	    (*p2 == '/' || *p2 == '\0'))
	    i++;		       /* a whole element matches, ooh */
	if (*p1 != *p2)
	    return i;		       /* mismatch */
	p1++, p2++;
    }
    return INT_MAX;		       /* exact match */
}

struct controlbox *ctrl_new_box(void)
{
    struct controlbox *ret = snew(struct controlbox);

    ret->nctrlsets = ret->ctrlsetsize = 0;
    ret->ctrlsets = NULL;
    ret->nfrees = ret->freesize = 0;
    ret->frees = NULL;

    return ret;
}

void ctrl_free_box(struct controlbox *b)
{
    int i;

    for (i = 0; i < b->nctrlsets; i++) {
	ctrl_free_set(b->ctrlsets[i]);
    }
    for (i = 0; i < b->nfrees; i++)
	sfree(b->frees[i]);
    sfree(b->ctrlsets);
    sfree(b->frees);
    sfree(b);
}

void ctrl_free_set(struct controlset *s)
{
    int i;

    sfree(s->pathname);
    sfree(s->boxname);
    sfree(s->boxtitle);
    for (i = 0; i < s->ncontrols; i++) {
	ctrl_free(s->ctrls[i]);
    }
    sfree(s->ctrls);
    sfree(s);
}

/*
 * Find the index of first controlset in a controlbox for a given
 * path. If that path doesn't exist, return the index where it
 * should be inserted.
 */
static int ctrl_find_set(struct controlbox *b, char *path, int start)
{
    int i, last, thisone;

    last = 0;
    for (i = 0; i < b->nctrlsets; i++) {
	thisone = ctrl_path_compare(path, b->ctrlsets[i]->pathname);
	/*
	 * If `start' is true and there exists a controlset with
	 * exactly the path we've been given, we should return the
	 * index of the first such controlset we find. Otherwise,
	 * we should return the index of the first entry in which
	 * _fewer_ path elements match than they did last time.
	 */
	if ((start && thisone == INT_MAX) || thisone < last)
	    return i;
	last = thisone;
    }
    return b->nctrlsets;	       /* insert at end */
}

/*
 * Find the index of next controlset in a controlbox for a given
 * path, or -1 if no such controlset exists. If -1 is passed as
 * input, finds the first.
 */
int ctrl_find_path(struct controlbox *b, char *path, int index)
{
    if (index < 0)
	index = ctrl_find_set(b, path, 1);
    else
	index++;

    if (index < b->nctrlsets && !strcmp(path, b->ctrlsets[index]->pathname))
	return index;
    else
	return -1;
}

/* Set up a panel title. */
struct controlset *ctrl_settitle(struct controlbox *b,
				 char *path, char *title)
{
    
    struct controlset *s = snew(struct controlset);
    int index = ctrl_find_set(b, path, 1);
    s->pathname = dupstr(path);
    s->boxname = NULL;
    s->boxtitle = dupstr(title);
    s->ncontrols = s->ctrlsize = 0;
    s->ncolumns = 0;		       /* this is a title! */
    s->ctrls = NULL;
    if (b->nctrlsets >= b->ctrlsetsize) {
	b->ctrlsetsize = b->nctrlsets + 32;
	b->ctrlsets = sresize(b->ctrlsets, b->ctrlsetsize,struct controlset *);
    }
    if (index < b->nctrlsets)
	memmove(&b->ctrlsets[index+1], &b->ctrlsets[index],
		(b->nctrlsets-index) * sizeof(*b->ctrlsets));
    b->ctrlsets[index] = s;
    b->nctrlsets++;
    return s;
}

/* Retrieve a pointer to a controlset, creating it if absent. */
struct controlset *ctrl_getset(struct controlbox *b,
			       char *path, char *name, char *boxtitle)
{
    struct controlset *s;
    int index = ctrl_find_set(b, path, 1);
    while (index < b->nctrlsets &&
	   !strcmp(b->ctrlsets[index]->pathname, path)) {
	if (b->ctrlsets[index]->boxname &&
	    !strcmp(b->ctrlsets[index]->boxname, name))
	    return b->ctrlsets[index];
	index++;
    }
    s = snew(struct controlset);
    s->pathname = dupstr(path);
    s->boxname = dupstr(name);
    s->boxtitle = boxtitle ? dupstr(boxtitle) : NULL;
    s->ncolumns = 1;
    s->ncontrols = s->ctrlsize = 0;
    s->ctrls = NULL;
    if (b->nctrlsets >= b->ctrlsetsize) {
	b->ctrlsetsize = b->nctrlsets + 32;
	b->ctrlsets = sresize(b->ctrlsets, b->ctrlsetsize,struct controlset *);
    }
    if (index < b->nctrlsets)
	memmove(&b->ctrlsets[index+1], &b->ctrlsets[index],
		(b->nctrlsets-index) * sizeof(*b->ctrlsets));
    b->ctrlsets[index] = s;
    b->nctrlsets++;
    return s;
}

/* Allocate some private data in a controlbox. */
void *ctrl_alloc(struct controlbox *b, size_t size)
{
    void *p;
    /*
     * This is an internal allocation routine, so it's allowed to
     * use smalloc directly.
     */
    p = smalloc(size);
    if (b->nfrees >= b->freesize) {
	b->freesize = b->nfrees + 32;
	b->frees = sresize(b->frees, b->freesize, void *);
    }
    b->frees[b->nfrees++] = p;
    return p;
}

static union control *ctrl_new(struct controlset *s, int type,
			       intorptr helpctx, handler_fn handler,
			       intorptr context)
{
    union control *c = snew(union control);
    if (s->ncontrols >= s->ctrlsize) {
	s->ctrlsize = s->ncontrols + 32;
	s->ctrls = sresize(s->ctrls, s->ctrlsize, union control *);
    }
    s->ctrls[s->ncontrols++] = c;
    /*
     * Fill in the standard fields.
     */
    c->generic.type = type;
    c->generic.tabdelay = 0;
    c->generic.column = COLUMN_FIELD(0, s->ncolumns);
    c->generic.helpctx = helpctx;
    c->generic.handler = handler;
    c->generic.context = context;
    c->generic.label = NULL;
    return c;
}

/* `ncolumns' is followed by that many percentages, as integers. */
union control *ctrl_columns(struct controlset *s, int ncolumns, ...)
{
    union control *c = ctrl_new(s, CTRL_COLUMNS, P(NULL), NULL, P(NULL));
    assert(s->ncolumns == 1 || ncolumns == 1);
    c->columns.ncols = ncolumns;
    s->ncolumns = ncolumns;
    if (ncolumns == 1) {
	c->columns.percentages = NULL;
    } else {
	va_list ap;
	int i;
	c->columns.percentages = snewn(ncolumns, int);
	va_start(ap, ncolumns);
	for (i = 0; i < ncolumns; i++)
	    c->columns.percentages[i] = va_arg(ap, int);
	va_end(ap);
    }
    return c;
}

union control *ctrl_editbox(struct controlset *s, char *label, char shortcut,
			    int percentage,
			    intorptr helpctx, handler_fn handler,
			    intorptr context, intorptr context2)
{
    union control *c = ctrl_new(s, CTRL_EDITBOX, helpctx, handler, context);
    c->editbox.label = label ? dupstr(label) : NULL;
    c->editbox.shortcut = shortcut;
    c->editbox.percentwidth = percentage;
    c->editbox.password = 0;
    c->editbox.has_list = 0;
    c->editbox.context2 = context2;
    return c;
}

union control *ctrl_combobox(struct controlset *s, char *label, char shortcut,
			     int percentage,
			     intorptr helpctx, handler_fn handler,
			     intorptr context, intorptr context2)
{
    union control *c = ctrl_new(s, CTRL_EDITBOX, helpctx, handler, context);
    c->editbox.label = label ? dupstr(label) : NULL;
    c->editbox.shortcut = shortcut;
    c->editbox.percentwidth = percentage;
    c->editbox.password = 0;
    c->editbox.has_list = 1;
    c->editbox.context2 = context2;
    return c;
}

/*
 * `ncolumns' is followed by (alternately) radio button titles and
 * intorptrs, until a NULL in place of a title string is seen. Each
 * title is expected to be followed by a shortcut _iff_ `shortcut'
 * is NO_SHORTCUT.
 */
union control *ctrl_radiobuttons(struct controlset *s, char *label,
				 char shortcut, int ncolumns, intorptr helpctx,
				 handler_fn handler, intorptr context, ...)
{
    va_list ap;
    int i;
    union control *c = ctrl_new(s, CTRL_RADIO, helpctx, handler, context);
    c->radio.label = label ? dupstr(label) : NULL;
    c->radio.shortcut = shortcut;
    c->radio.ncolumns = ncolumns;
    /*
     * Initial pass along variable argument list to count the
     * buttons.
     */
    va_start(ap, context);
    i = 0;
    while (va_arg(ap, char *) != NULL) {
	i++;
	if (c->radio.shortcut == NO_SHORTCUT)
	    (void)va_arg(ap, int);     /* char promotes to int in arg lists */
	(void)va_arg(ap, intorptr);
    }
    va_end(ap);
    c->radio.nbuttons = i;
    if (c->radio.shortcut == NO_SHORTCUT)
	c->radio.shortcuts = snewn(c->radio.nbuttons, char);
    else
	c->radio.shortcuts = NULL;
    c->radio.buttons = snewn(c->radio.nbuttons, char *);
    c->radio.buttondata = snewn(c->radio.nbuttons, intorptr);
    /*
     * Second pass along variable argument list to actually fill in
     * the structure.
     */
    va_start(ap, context);
    for (i = 0; i < c->radio.nbuttons; i++) {
	c->radio.buttons[i] = dupstr(va_arg(ap, char *));
	if (c->radio.shortcut == NO_SHORTCUT)
	    c->radio.shortcuts[i] = va_arg(ap, int);
				       /* char promotes to int in arg lists */
	c->radio.buttondata[i] = va_arg(ap, intorptr);
    }
    va_end(ap);
    return c;
}

union control *ctrl_pushbutton(struct controlset *s,char *label,char shortcut,
			       intorptr helpctx, handler_fn handler,
			       intorptr context)
{
    union control *c = ctrl_new(s, CTRL_BUTTON, helpctx, handler, context);
    c->button.label = label ? dupstr(label) : NULL;
    c->button.shortcut = shortcut;
    c->button.isdefault = 0;
    c->button.iscancel = 0;
    return c;
}

union control *ctrl_listbox(struct controlset *s,char *label,char shortcut,
			    intorptr helpctx, handler_fn handler,
			    intorptr context)
{
    union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);
    c->listbox.label = label ? dupstr(label) : NULL;
    c->listbox.shortcut = shortcut;
    c->listbox.height = 5;	       /* *shrug* a plausible default */
    c->listbox.draglist = 0;
    c->listbox.multisel = 0;
    c->listbox.percentwidth = 100;
    c->listbox.ncols = 0;
    c->listbox.percentages = NULL;
    return c;
}

union control *ctrl_droplist(struct controlset *s, char *label, char shortcut,
			     int percentage, intorptr helpctx,
			     handler_fn handler, intorptr context)
{
    union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);
    c->listbox.label = label ? dupstr(label) : NULL;
    c->listbox.shortcut = shortcut;
    c->listbox.height = 0;	       /* means it's a drop-down list */
    c->listbox.draglist = 0;
    c->listbox.multisel = 0;
    c->listbox.percentwidth = percentage;
    return c;
}

union control *ctrl_draglist(struct controlset *s,char *label,char shortcut,
			     intorptr helpctx, handler_fn handler,
			     intorptr context)
{
    union control *c = ctrl_new(s, CTRL_LISTBOX, helpctx, handler, context);
    c->listbox.label = label ? dupstr(label) : NULL;
    c->listbox.shortcut = shortcut;
    c->listbox.height = 5;	       /* *shrug* a plausible default */
    c->listbox.draglist = 1;
    c->listbox.multisel = 0;
    c->listbox.percentwidth = 100;
    return c;
}

union control *ctrl_filesel(struct controlset *s,char *label,char shortcut,
			    char const *filter, int write, char *title,
			    intorptr helpctx, handler_fn handler,
			    intorptr context)
{
    union control *c = ctrl_new(s, CTRL_FILESELECT, helpctx, handler, context);
    c->fileselect.label = label ? dupstr(label) : NULL;
    c->fileselect.shortcut = shortcut;
    c->fileselect.filter = filter;
    c->fileselect.for_writing = write;
    c->fileselect.title = dupstr(title);
    return c;
}

union control *ctrl_fontsel(struct controlset *s,char *label,char shortcut,
			    intorptr helpctx, handler_fn handler,
			    intorptr context)
{
    union control *c = ctrl_new(s, CTRL_FONTSELECT, helpctx, handler, context);
    c->fontselect.label = label ? dupstr(label) : NULL;
    c->fontselect.shortcut = shortcut;
    return c;
}

union control *ctrl_tabdelay(struct controlset *s, union control *ctrl)
{
    union control *c = ctrl_new(s, CTRL_TABDELAY, P(NULL), NULL, P(NULL));
    c->tabdelay.ctrl = ctrl;
    return c;
}

union control *ctrl_text(struct controlset *s, char *text, intorptr helpctx)
{
    union control *c = ctrl_new(s, CTRL_TEXT, helpctx, NULL, P(NULL));
    c->text.label = dupstr(text);
    return c;
}

union control *ctrl_checkbox(struct controlset *s, char *label, char shortcut,
			     intorptr helpctx, handler_fn handler,
			     intorptr context)
{
    union control *c = ctrl_new(s, CTRL_CHECKBOX, helpctx, handler, context);
    c->checkbox.label = label ? dupstr(label) : NULL;
    c->checkbox.shortcut = shortcut;
    return c;
}

void ctrl_free(union control *ctrl)
{
    int i;

    sfree(ctrl->generic.label);
    switch (ctrl->generic.type) {
      case CTRL_RADIO:
	for (i = 0; i < ctrl->radio.nbuttons; i++)
	    sfree(ctrl->radio.buttons[i]);
	sfree(ctrl->radio.buttons);
	sfree(ctrl->radio.shortcuts);
	sfree(ctrl->radio.buttondata);
	break;
      case CTRL_COLUMNS:
	sfree(ctrl->columns.percentages);
	break;
      case CTRL_LISTBOX:
	sfree(ctrl->listbox.percentages);
	break;
      case CTRL_FILESELECT:
	sfree(ctrl->fileselect.title);
	break;
    }
    sfree(ctrl);
}

void dlg_stdradiobutton_handler(union control *ctrl, void *dlg,
				void *data, int event)
{
    int button;
    /*
     * For a standard radio button set, the context parameter gives
     * offsetof(targetfield, Config), and the extra data per button
     * gives the value the target field should take if that button
     * is the one selected.
     */
    if (event == EVENT_REFRESH) {
	for (button = 0; button < ctrl->radio.nbuttons; button++)
	    if (*(int *)ATOFFSET(data, ctrl->radio.context.i) ==
		ctrl->radio.buttondata[button].i)
		break;
	/* We expected that `break' to happen, in all circumstances. */
	assert(button < ctrl->radio.nbuttons);
	dlg_radiobutton_set(ctrl, dlg, button);
    } else if (event == EVENT_VALCHANGE) {
	button = dlg_radiobutton_get(ctrl, dlg);
	assert(button >= 0 && button < ctrl->radio.nbuttons);
	*(int *)ATOFFSET(data, ctrl->radio.context.i) =
	    ctrl->radio.buttondata[button].i;
    }
}

void dlg_stdcheckbox_handler(union control *ctrl, void *dlg,
				void *data, int event)
{
    int offset, invert;

    /*
     * For a standard checkbox, the context parameter gives
     * offsetof(targetfield, Config), optionally ORed with
     * CHECKBOX_INVERT.
     */
    offset = ctrl->checkbox.context.i;
    if (offset & CHECKBOX_INVERT) {
	offset &= ~CHECKBOX_INVERT;
	invert = 1;
    } else
	invert = 0;

    /*
     * C lacks a logical XOR, so the following code uses the idiom
     * (!a ^ !b) to obtain the logical XOR of a and b. (That is, 1
     * iff exactly one of a and b is nonzero, otherwise 0.)
     */

    if (event == EVENT_REFRESH) {
	dlg_checkbox_set(ctrl,dlg, (!*(int *)ATOFFSET(data,offset) ^ !invert));
    } else if (event == EVENT_VALCHANGE) {
	*(int *)ATOFFSET(data, offset) = !dlg_checkbox_get(ctrl,dlg) ^ !invert;
    }
}

void dlg_stdeditbox_handler(union control *ctrl, void *dlg,
			    void *data, int event)
{
    /*
     * The standard edit-box handler expects the main `context'
     * field to contain the `offsetof' a field in the structure
     * pointed to by `data'. The secondary `context2' field
     * indicates the type of this field:
     *
     *  - if context2 > 0, the field is a char array and context2
     *    gives its size.
     *  - if context2 == -1, the field is an int and the edit box
     *    is numeric.
     *  - if context2 < -1, the field is an int and the edit box is
     *    _floating_, and (-context2) gives the scale. (E.g. if
     *    context2 == -1000, then typing 1.2 into the box will set
     *    the field to 1200.)
     */
    int offset = ctrl->editbox.context.i;
    int length = ctrl->editbox.context2.i;

    if (length > 0) {
	char *field = (char *)ATOFFSET(data, offset);
	if (event == EVENT_REFRESH) {
	    dlg_editbox_set(ctrl, dlg, field);
	} else if (event == EVENT_VALCHANGE) {
	    dlg_editbox_get(ctrl, dlg, field, length);
	}
    } else if (length < 0) {
	int *field = (int *)ATOFFSET(data, offset);
	char data[80];
	if (event == EVENT_REFRESH) {
	    if (length == -1)
		sprintf(data, "%d", *field);
	    else
		sprintf(data, "%g", (double)*field / (double)(-length));
	    dlg_editbox_set(ctrl, dlg, data);
	} else if (event == EVENT_VALCHANGE) {
	    dlg_editbox_get(ctrl, dlg, data, lenof(data));
	    if (length == -1)
		*field = atoi(data);
	    else
		*field = (int)((-length) * atof(data));
	}
    }
}

void dlg_stdfilesel_handler(union control *ctrl, void *dlg,
			    void *data, int event)
{
    /*
     * The standard file-selector handler expects the `context'
     * field to contain the `offsetof' a Filename field in the
     * structure pointed to by `data'.
     */
    int offset = ctrl->fileselect.context.i;

    if (event == EVENT_REFRESH) {
	dlg_filesel_set(ctrl, dlg, *(Filename *)ATOFFSET(data, offset));
    } else if (event == EVENT_VALCHANGE) {
	dlg_filesel_get(ctrl, dlg, (Filename *)ATOFFSET(data, offset));
    }
}

void dlg_stdfontsel_handler(union control *ctrl, void *dlg,
			    void *data, int event)
{
    /*
     * The standard file-selector handler expects the `context'
     * field to contain the `offsetof' a FontSpec field in the
     * structure pointed to by `data'.
     */
    int offset = ctrl->fontselect.context.i;

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