e16/src/dialog.c

/*
 * Copyright (C) 1999 Carsten Haitzler, Geoff Harrison and various contributors
 * *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * *
 * The above copyright notice and this permission notice shall be included in
 * all copies of the Software, its documentation and marketing & publicity
 * materials, and acknowledgment shall be given in the documentation, materials
 * and software packages that this Software was used.
 * *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "E.h"
static ImageClass  *d_ic_default = NULL;
static TextClass   *d_tc_default = NULL;

static void         DialogRealizeTClassDefault(void);
static void         DialogRealizeIClassDefault(void);

static void
DialogRealizeTClassDefault(void)
{
   if (!d_tc_default)
     {
	d_tc_default = CreateTclass();
	d_tc_default->norm.normal = CreateTextState();
	d_tc_default->norm.normal->fontname =
	   duplicate("-*-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*");
	d_tc_default->norm.normal->fg_col.r = 0;
	d_tc_default->norm.normal->fg_col.g = 0;
	d_tc_default->norm.normal->fg_col.b = 0;
     }
}

static void
DialogRealizeIClassDefault(void)
{
   if (!d_ic_default)
     {
	d_ic_default = CreateIclass();
	d_ic_default->name = NULL;

	d_ic_default->norm.normal = CreateImageState();
	d_ic_default->norm.normal->hihi.r = 255;
	d_ic_default->norm.normal->hihi.g = 255;
	d_ic_default->norm.normal->hihi.b = 255;
	d_ic_default->norm.normal->hi.r = 220;
	d_ic_default->norm.normal->hi.g = 220;
	d_ic_default->norm.normal->hi.b = 220;
	d_ic_default->norm.normal->bg.r = 160;
	d_ic_default->norm.normal->bg.g = 160;
	d_ic_default->norm.normal->bg.b = 160;
	d_ic_default->norm.normal->lo.r = 100;
	d_ic_default->norm.normal->lo.g = 100;
	d_ic_default->norm.normal->lo.b = 100;
	d_ic_default->norm.normal->lolo.r = 0;
	d_ic_default->norm.normal->lolo.g = 0;
	d_ic_default->norm.normal->lolo.b = 0;
	d_ic_default->norm.normal->bevelstyle = BEVEL_NEXT;

	d_ic_default->norm.hilited = CreateImageState();
	d_ic_default->norm.hilited->hihi.r = 255;
	d_ic_default->norm.hilited->hihi.g = 255;
	d_ic_default->norm.hilited->hihi.b = 255;
	d_ic_default->norm.hilited->hi.r = 240;
	d_ic_default->norm.hilited->hi.g = 240;
	d_ic_default->norm.hilited->hi.b = 240;
	d_ic_default->norm.hilited->bg.r = 200;
	d_ic_default->norm.hilited->bg.g = 200;
	d_ic_default->norm.hilited->bg.b = 200;
	d_ic_default->norm.hilited->lo.r = 160;
	d_ic_default->norm.hilited->lo.g = 160;
	d_ic_default->norm.hilited->lo.b = 160;
	d_ic_default->norm.hilited->lolo.r = 0;
	d_ic_default->norm.hilited->lolo.g = 0;
	d_ic_default->norm.hilited->lolo.b = 0;
	d_ic_default->norm.hilited->bevelstyle = BEVEL_NEXT;

	d_ic_default->norm.clicked = CreateImageState();
	d_ic_default->norm.clicked->hihi.r = 0;
	d_ic_default->norm.clicked->hihi.g = 0;
	d_ic_default->norm.clicked->hihi.b = 0;
	d_ic_default->norm.clicked->hi.r = 100;
	d_ic_default->norm.clicked->hi.g = 100;
	d_ic_default->norm.clicked->hi.b = 100;
	d_ic_default->norm.clicked->bg.r = 160;
	d_ic_default->norm.clicked->bg.g = 160;
	d_ic_default->norm.clicked->bg.b = 160;
	d_ic_default->norm.clicked->lo.r = 220;
	d_ic_default->norm.clicked->lo.g = 220;
	d_ic_default->norm.clicked->lo.b = 220;
	d_ic_default->norm.clicked->lolo.r = 255;
	d_ic_default->norm.clicked->lolo.g = 255;
	d_ic_default->norm.clicked->lolo.b = 255;
	d_ic_default->norm.clicked->bevelstyle = BEVEL_NEXT;

	d_ic_default->active.normal = CreateImageState();
	d_ic_default->active.normal->hihi.r = 0;
	d_ic_default->active.normal->hihi.g = 0;
	d_ic_default->active.normal->hihi.b = 0;
	d_ic_default->active.normal->hi.r = 100;
	d_ic_default->active.normal->hi.g = 100;
	d_ic_default->active.normal->hi.b = 100;
	d_ic_default->active.normal->bg.r = 160;
	d_ic_default->active.normal->bg.g = 160;
	d_ic_default->active.normal->bg.b = 160;
	d_ic_default->active.normal->lo.r = 220;
	d_ic_default->active.normal->lo.g = 220;
	d_ic_default->active.normal->lo.b = 220;
	d_ic_default->active.normal->lolo.r = 255;
	d_ic_default->active.normal->lolo.g = 255;
	d_ic_default->active.normal->lolo.b = 255;
	d_ic_default->active.normal->bevelstyle = BEVEL_NEXT;

	d_ic_default->active.hilited = CreateImageState();
	d_ic_default->active.hilited->hihi.r = 0;
	d_ic_default->active.hilited->hihi.g = 0;
	d_ic_default->active.hilited->hihi.b = 0;
	d_ic_default->active.hilited->hi.r = 100;
	d_ic_default->active.hilited->hi.g = 100;
	d_ic_default->active.hilited->hi.b = 100;
	d_ic_default->active.hilited->bg.r = 160;
	d_ic_default->active.hilited->bg.g = 160;
	d_ic_default->active.hilited->bg.b = 160;
	d_ic_default->active.hilited->lo.r = 220;
	d_ic_default->active.hilited->lo.g = 220;
	d_ic_default->active.hilited->lo.b = 220;
	d_ic_default->active.hilited->lolo.r = 255;
	d_ic_default->active.hilited->lolo.g = 255;
	d_ic_default->active.hilited->lolo.b = 255;
	d_ic_default->active.hilited->bevelstyle = BEVEL_NEXT;

	d_ic_default->active.clicked = CreateImageState();
	d_ic_default->active.clicked->hihi.r = 0;
	d_ic_default->active.clicked->hihi.g = 0;
	d_ic_default->active.clicked->hihi.b = 0;
	d_ic_default->active.clicked->hi.r = 100;
	d_ic_default->active.clicked->hi.g = 100;
	d_ic_default->active.clicked->hi.b = 100;
	d_ic_default->active.clicked->bg.r = 160;
	d_ic_default->active.clicked->bg.g = 160;
	d_ic_default->active.clicked->bg.b = 160;
	d_ic_default->active.clicked->lo.r = 220;
	d_ic_default->active.clicked->lo.g = 220;
	d_ic_default->active.clicked->lo.b = 220;
	d_ic_default->active.clicked->lolo.r = 255;
	d_ic_default->active.clicked->lolo.g = 255;
	d_ic_default->active.clicked->lolo.b = 255;
	d_ic_default->active.clicked->bevelstyle = BEVEL_NEXT;

	d_ic_default->padding.left = 8;
	d_ic_default->padding.right = 8;
	d_ic_default->padding.top = 8;
	d_ic_default->padding.bottom = 8;
     }
   IclassPopulate(d_ic_default);
}

void
DialogBindKey(Dialog * d, char *key, void (*func) (int val, void *data),
	      int val, void *data)
{
   d->num_bindings++;
   if (!d->keybindings)
      d->keybindings = Emalloc(sizeof(DKeyBind) * d->num_bindings);
   else
      d->keybindings = Erealloc(d->keybindings, sizeof(DKeyBind) * d->num_bindings);
   d->keybindings[d->num_bindings - 1].val = val;
   d->keybindings[d->num_bindings - 1].data = data;
   d->keybindings[d->num_bindings - 1].func = func;
   d->keybindings[d->num_bindings - 1].key =
      XKeysymToKeycode(disp, XStringToKeysym(key));;
}

Dialog             *
CreateDialog(char *name)
{
   Dialog             *d;

   d = Emalloc(sizeof(Dialog));
   d->name = duplicate(name);
   d->title = NULL;
   d->text = NULL;
   d->num_buttons = 0;
   d->win = 0;
   d->button = NULL;
   d->win = ECreateWindow(root.win, -20, -20, 2, 2, 0);

   d->item = NULL;
   d->exit_func = NULL;
   d->exit_val = 0;
   d->exit_data = NULL;

   d->tclass = FindItem("DIALOG", 0, LIST_FINDBY_NAME, LIST_TYPE_TCLASS);
   if (!d->tclass)
     {
	DialogRealizeTClassDefault();
	d->tclass = d_tc_default;
     }
   if (d->tclass)
      d->tclass->ref_count++;

   d->iclass = FindItem("DIALOG", 0, LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
   if (!d->iclass)
     {
	DialogRealizeIClassDefault();
	d->iclass = d_ic_default;
     }
   if (d->iclass)
      d->iclass->ref_count++;
   d->num_bindings = 0;
   d->keybindings = NULL;

   return d;
}

void
FreeDButton(DButton * db)
{
   if (db->text)
      Efree(db->text);
   if (db->iclass)
      db->iclass->ref_count--;
   if (db->tclass)
      db->tclass->ref_count--;
   Efree(db);
}

void
FreeDialog(Dialog * d)
{
   int                 i;

   if (d->name)
      Efree(d->name);
   if (d->title)
      Efree(d->title);
   if (d->text)
      Efree(d->text);
   for (i = 0; i < d->num_buttons; i++)
      FreeDButton(d->button[i]);
   if (d->button)
      Efree(d->button);
   if (d->item)
      DialogFreeItem(d->item);
   if (d->iclass)
      d->iclass->ref_count--;
   if (d->tclass)
      d->tclass->ref_count--;
   if (d->keybindings)
      Efree(d->keybindings);
   Efree(d);
}

void
DialogRestart(int val, void *data)
{
   doExit("restart");
   val = 0;
   data = NULL;
}

void
DialogQuit(int val, void *data)
{
   doExit("error");
   val = 0;
   data = NULL;
}

void
DialogAlert(char *fmt,...)
{
   char                text[10240];
   va_list             ap;

   SC_Kill();
   va_start(ap, fmt);
   Evsnprintf(text, 10240, fmt, ap);
   va_end(ap);
   Alert(text);
}

void
DialogAlertOK(char *fmt,...)
{
   char                text[10240];
   va_list             ap;

   va_start(ap, fmt);
   Evsnprintf(text, 10240, fmt, ap);
   va_end(ap);
   ASSIGN_ALERT("Attention !!!", "OK", " ", " ");
   Alert(text);
   RESET_ALERT;
}

void
DialogSetParamText(Dialog * d, char *fmt,...)
{
   char                text[10240];
   va_list             ap;

   va_start(ap, fmt);
   Evsnprintf(text, 10240, fmt, ap);
   va_end(ap);
   DialogSetText(d, text);
}

void
DialogSetText(Dialog * d, char *text)
{
   int                 w, h;

   if (d->text)
      Efree(d->text);

   d->text = duplicate(text);
   if ((!d->tclass) || (!d->iclass))
      return;
   TextSize(d->tclass, 0, 0, STATE_NORMAL, text, &w, &h, 17);
   d->w = w + d->iclass->padding.left + d->iclass->padding.right;
   d->h = h + d->iclass->padding.top + d->iclass->padding.bottom;
}

void
DialogSetTitle(Dialog * d, char *title)
{
   if (d->title)
      Efree(d->title);
   d->title = duplicate(title);
}

void
DialogSetExitFunction(Dialog * d, void (*func) (int val, void *data),
		      int val, void *data)
{
   d->exit_func = func;
   d->exit_val = val;
   d->exit_data = data;
}

void
DialogAddButton(Dialog * d, char *text, void (*func) (int val, void *data),
		char close)
{
   DButton            *db;
   int                 w, h;

   db = Emalloc(sizeof(DButton));
   d->num_buttons++;
   d->button = Erealloc(d->button, d->num_buttons * (sizeof(DButton *)));
   d->button[d->num_buttons - 1] = db;
   db->text = duplicate(text);
   db->func = func;
   db->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
   EMapWindow(disp, db->win);
   db->x = -1;
   db->y = -1;
   db->w = -1;
   db->h = -1;
   db->hilited = 0;
   db->clicked = 0;
   db->close = close;

   db->tclass = FindItem("DIALOG_BUTTON", 0,
			 LIST_FINDBY_NAME, LIST_TYPE_TCLASS);
   if (!db->tclass)
     {
	DialogRealizeTClassDefault();
	db->tclass = d_tc_default;
     }
   if (db->tclass)
      db->tclass->ref_count++;

   db->iclass = FindItem("DIALOG_BUTTON", 0,
			 LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
   if (!db->iclass)
     {
	DialogRealizeTClassDefault();
	db->iclass = d_ic_default;
     }
   if (db->iclass)
      db->iclass->ref_count++;

   TextSize(db->tclass, 0, 0, STATE_NORMAL, text, &w, &h, 17);
   db->w = w + db->iclass->padding.left + db->iclass->padding.right;
   db->h = h + db->iclass->padding.top + db->iclass->padding.bottom;
   XSelectInput(disp, db->win, EnterWindowMask | LeaveWindowMask |
		ButtonPressMask | ButtonReleaseMask | ExposureMask);
}

void
DialogDrawButton(Dialog * d, int bnum)
{
   int                 state;

   state = STATE_NORMAL;
   if ((d->button[bnum]->hilited) && (d->button[bnum]->clicked))
     {
	state = STATE_CLICKED;
     }
   else if ((d->button[bnum]->hilited) && (!d->button[bnum]->clicked))
     {
	state = STATE_HILITED;
     }
   else if (!(d->button[bnum]->hilited) && (d->button[bnum]->clicked))
     {
	state = STATE_CLICKED;
     }
   IclassApply(d->button[bnum]->iclass, d->button[bnum]->win,
	       d->button[bnum]->w, d->button[bnum]->h, 0, 0,
	       state, 0);
   TclassApply(d->button[bnum]->iclass, d->button[bnum]->win,
	       d->button[bnum]->w, d->button[bnum]->h,
	       0, 0, state, 1, d->button[bnum]->tclass,
	       d->button[bnum]->text);
}

void
DialogActivateButton(Window win, int inclick)
{
   Dialog             *d;
   int                 bnum;
   char                doact = 0;

   d = FindDialogButton(win, &bnum);
   if (!d)
      return;
   if ((d->button[bnum]->hilited) && (d->button[bnum]->clicked) &&
       (inclick == 3))
      doact = 1;
   if (inclick == 0)
      d->button[bnum]->hilited = 1;
   if (inclick == 1)
      d->button[bnum]->hilited = 0;
   if (inclick == 2)
      d->button[bnum]->clicked = 1;
   if (inclick == 3)
      d->button[bnum]->clicked = 0;
   DialogDrawButton(d, bnum);
   if ((doact) && (d->button[bnum]->func))
      (d->button[bnum]->func) (bnum, d);
   if ((doact) && (d->button[bnum]->close))
      DialogClose(d);
}

void
DialogDraw(Dialog * d)
{
   if ((!d->tclass) || (!d->iclass))
      return;

   if (d->text)
     {
	TclassApply(d->iclass, d->win, d->w, d->h,
		    0, 0, STATE_NORMAL, 1, d->tclass,
		    d->text);
     }
   else if (d->item)
     {
	DialogDrawItems(d, d->item, 0, 0, 99999, 99999);
     }
}

void
DialogDrawArea(Dialog * d, int x, int y, int w, int h)
{
   if ((!d->tclass) || (!d->iclass))
      return;

   if (d->text)
     {
	TclassApply(d->iclass, d->win, d->w, d->h,
		    0, 0, STATE_NORMAL, 1, d->tclass,
		    d->text);
     }
   else if (d->item)
     {
	DialogDrawItems(d, d->item, x, y, w, h);
     }
}

void
DialogRedraw(Dialog * d)
{
   int                 i;

   if ((!d->tclass) || (!d->iclass))
      return;
   for (i = 0; i < d->num_buttons; i++)
      DialogDrawButton(d, i);
   DialogDraw(d);
}

void
ShowDialog(Dialog * d)
{
   char                pq;
   int                 i, w, h, mw, mh;
   EWin               *ewin;
   XTextProperty       xtp;
   XClassHint         *xch;
   Snapshot           *sn;

   SC_Kill();
   if (d->title)
     {
	xtp.encoding = XA_STRING;
	xtp.format = 8;
	xtp.value = (unsigned char *)(d->title);
	xtp.nitems = strlen((char *)(xtp.value));
	XSetWMName(disp, d->win, &xtp);
	xch = XAllocClassHint();
	xch->res_name = d->name;
	xch->res_class = "Enlightenment_Dialog";
	XSetClassHint(disp, d->win, xch);
	XFree(xch);
     }
   ewin = FindEwinByDialog(d);
   if (ewin)
     {
	if (ewin->desktop != desks.current)
	   MoveEwinToDesktopAt(ewin, desks.current, ewin->x, ewin->y);
	RaiseEwin(ewin);
	ShowEwin(ewin);
	return;
     }
   if (d->item)
      DialogItemsRealize(d);

   w = d->w;
   h = d->h;
   mw = 0;
   mh = 0;
   for (i = 0; i < d->num_buttons; i++)
     {
	if (d->button[i]->w > mw)
	   mw = d->button[i]->w;
	if (d->button[i]->h > mh)
	   mh = d->button[i]->h;
     }
   h += d->iclass->padding.top + d->iclass->padding.bottom + mh;

   if ((d->iclass->padding.left + d->iclass->padding.right +
	(d->num_buttons * (mw + d->iclass->padding.left +
			   d->iclass->padding.right)))
       > w)
      w = d->iclass->padding.left + d->iclass->padding.right +
	 (d->num_buttons * (mw + d->iclass->padding.left +
			    d->iclass->padding.right));

   for (i = 0; i < d->num_buttons; i++)
     {
	d->button[i]->x =
	   (((w - (d->iclass->padding.left + d->iclass->padding.right)) -
	     (d->num_buttons * (mw + d->iclass->padding.left +
				d->iclass->padding.right))) / 2) +
	   d->iclass->padding.left +
	   (i * (mw + d->iclass->padding.left + d->iclass->padding.right)) +
	   d->iclass->padding.left;
	d->button[i]->y = d->h - d->iclass->padding.bottom +
	   d->iclass->padding.top;

	d->button[i]->w = mw;
	d->button[i]->h = mh;
	EMoveResizeWindow(disp, d->button[i]->win,
			  d->button[i]->x, d->button[i]->y,
			  d->button[i]->w, d->button[i]->h);
     }
   d->w = w;
   d->h = d->h - d->iclass->padding.bottom;
   EResizeWindow(disp, d->win, w, h);
   pq = queue_up;
   queue_up = 0;
   IclassApply(d->iclass, d->win, w, h, 0, 0, STATE_NORMAL, 0);

   for (i = 0; i < d->num_buttons; i++)
      IclassApply(d->button[i]->iclass, d->button[i]->win,
		  d->button[i]->w, d->button[i]->h, 0, 0,
		  STATE_NORMAL, 0);
   queue_up = pq;

   ewin = AddInternalToFamily(d->win, 1, NULL, 0, d);
   XSelectInput(disp, d->win, ExposureMask | PointerMotionMask |
		EnterWindowMask | LeaveWindowMask |
		FocusChangeMask | KeyPressMask);
   if (ewin)
     {
	DesktopRemoveEwin(ewin);
	ewin->layer = 4;
	DesktopAddEwinToTop(ewin);
	sn = FindSnapshot(ewin);
	/* get the size right damnit! */
	if (sn)
	  {
	     if (sn->use_wh)
		ResizeEwin(ewin, sn->w, sn->h);
	     if (sn->use_xy)
	       {
		  MoveEwin(ewin, sn->x, sn->y);
	       }
	     else
	       {
		  if (FindADialog())
		    {
		       ArrangeEwin(ewin);
		    }
		  else
		    {
		       MoveEwin(ewin, ((root.w - (ewin->w)) / 2),
				((root.h - (ewin->h)) / 2));
		    }
	       }
	  }
	else
	  {
	     if (FindADialog())
	       {
		  ArrangeEwin(ewin);
	       }
	     else
	       {
		  MoveEwin(ewin, ((root.w - (ewin->w)) / 2),
			   ((root.h - (ewin->h)) / 2));
	       }
	  }
	RestackEwin(ewin);
	ShowEwin(ewin);
	ewin->dialog = d;
     }
   if (!FindDialog(d->win))
      AddItem(d, d->name, d->win, LIST_TYPE_DIALOG);
   XSync(disp, False);
   DialogRedraw(d);
}

void
DialogClose(Dialog * d)
{
   EWin               *ewin;
   XEvent              ev;

   if (!d)
      return;
   ewin = FindEwinByDialog(d);
   EDestroyWindow(disp, d->win);
   if (ewin)
     {
	HideEwin(ewin);
	ev.xunmap.window = d->win;
	HandleUnmap(&ev);
     }
   if (d->exit_func)
      (d->exit_func) (d->exit_val, d->exit_data);
   RemoveItem(NULL, d->win, LIST_FINDBY_ID, LIST_TYPE_DIALOG);
   FreeDialog(d);
}

DItem              *
DialogInitItem(Dialog * d)
{
   if (!d->item)
     {
	DItem              *di;

	di = Emalloc(sizeof(DItem));
	d->item = di;
	di->type = DITEM_TABLE;
	di->func = NULL;
	di->val = 0;
	di->data = NULL;
	di->iclass = NULL;
	di->tclass = NULL;
	di->padding.left = 0;
	di->padding.right = 0;
	di->padding.top = 0;
	di->padding.bottom = 0;
	di->fill_h = 0;
	di->fill_v = 0;
	di->align_h = 512;
	di->align_v = 512;
	di->row_span = 1;
	di->col_span = 1;
	di->x = 0;
	di->y = 0;
	di->w = 0;
	di->h = 0;
	di->hilited = 0;
	di->clicked = 0;
	di->win = 0;
	di->item.table.num_columns = 1;
	di->item.table.border = 0;
	di->item.table.homogenous_h = 0;
	di->item.table.homogenous_v = 0;
	di->item.table.num_items = 0;
	di->item.table.items = NULL;
	return di;
     }
   return NULL;
}

DItem              *
DialogAddItem(DItem * dii, int type)
{
   DItem              *di;

   di = Emalloc(sizeof(DItem));
   di->type = type;
   di->func = NULL;
   di->val = 0;
   di->data = NULL;
   di->iclass = NULL;
   di->tclass = NULL;
   di->padding.left = 0;
   di->padding.right = 0;
   di->padding.top = 0;
   di->padding.bottom = 0;
   di->fill_h = 1;
   di->fill_v = 1;
   di->align_h = 512;
   di->align_v = 512;
   di->row_span = 1;
   di->col_span = 1;

   di->x = 0;
   di->y = 0;
   di->w = 0;
   di->h = 0;
   di->hilited = 0;
   di->clicked = 0;
   di->win = 0;
   switch (di->type)
     {
     case DITEM_NONE:
	break;
     case DITEM_AREA:
	di->item.area.area_win = 0;
	di->item.area.w = 32;
	di->item.area.h = 32;
	di->item.area.event_func = NULL;
	break;
     case DITEM_BUTTON:
	di->item.button.text = NULL;
	break;
     case DITEM_CHECKBUTTON:
	di->item.check_button.text = NULL;
	di->item.check_button.check_win = 0;
	di->item.check_button.onoff = 0;
	di->item.check_button.onoff_ptr = NULL;
	di->item.check_button.check_orig_w = 10;
	di->item.check_button.check_orig_h = 10;
	break;
     case DITEM_TEXT:
	di->item.text.text = NULL;
	break;
     case DITEM_TABLE:
	di->item.table.num_columns = 1;
	di->item.table.border = 0;
	di->item.table.homogenous_h = 0;
	di->item.table.homogenous_v = 0;
	di->item.table.num_items = 0;
	di->item.table.items = NULL;
	break;
     case DITEM_IMAGE:
	di->item.image.image = NULL;
	break;
     case DITEM_SEPARATOR:
	di->item.separator.horizontal = 0;
	break;
     case DITEM_RADIOBUTTON:
	di->item.radio_button.text = NULL;
	di->item.radio_button.radio_win = 0;
	di->item.radio_button.onoff = 0;
	di->item.radio_button.val = 0;
	di->item.radio_button.val_ptr = 0;
	di->item.radio_button.next = NULL;
	di->item.radio_button.first = NULL;
	di->item.radio_button.radio_orig_w = 10;
	di->item.radio_button.radio_orig_h = 10;
	break;
     case DITEM_SLIDER:
	di->item.slider.horizontal = 1;
	di->item.slider.numeric = 0;
	di->item.slider.numeric_side = 0;
	di->item.slider.upper = 100;
	di->item.slider.lower = 0;
	di->item.slider.unit = 10;
	di->item.slider.jump = 20;
	di->item.slider.val = 0;
	di->item.slider.val_ptr = NULL;
	di->item.slider.min_length = 64;
	di->item.slider.ic_base = NULL;
	di->item.slider.ic_knob = NULL;
	di->item.slider.ic_border = NULL;
	di->item.slider.base_win = 0;
	di->item.slider.knob_win = 0;
	di->item.slider.border_win = 0;
	di->item.slider.base_orig_w = 10;
	di->item.slider.base_orig_h = 10;
	di->item.slider.knob_orig_w = 6;
	di->item.slider.knob_orig_h = 6;
	di->item.slider.border_orig_w = 14;
	di->item.slider.border_orig_h = 14;
	di->item.slider.base_x = 0;
	di->item.slider.base_y = 0;
	di->item.slider.base_w = 0;
	di->item.slider.base_h = 0;
	di->item.slider.knob_x = 0;
	di->item.slider.knob_y = 0;
	di->item.slider.knob_w = 0;
	di->item.slider.knob_h = 0;
	di->item.slider.border_x = 0;
	di->item.slider.border_y = 0;
	di->item.slider.border_w = 0;
	di->item.slider.border_h = 0;
	di->item.slider.numeric_x = 0;
	di->item.slider.numeric_y = 0;
	di->item.slider.numeric_w = 0;
	di->item.slider.numeric_h = 0;
	di->item.slider.in_drag = 0;
	di->item.slider.wanted_val = 0;
	break;
     default:
	break;
     }

   if (dii)
     {
	dii->item.table.num_items++;
	dii->item.table.items = Erealloc(dii->item.table.items,
					 sizeof(DItem *) *
					 dii->item.table.num_items);
	dii->item.table.items[dii->item.table.num_items - 1] = di;
     }
   return di;
}

void
DialogItemSetCallback(DItem * di, void (*func) (int val, void *data),
		      int val, char *data)
{
   di->func = func;
   di->val = val;
   di->data = data;
}

void
DialogItemSetClass(DItem * di, ImageClass * iclass, TextClass * tclass)
{
   if (di->iclass)
      di->iclass->ref_count--;
   di->iclass = iclass;
   if (di->iclass)
      di->iclass->ref_count++;

   if (di->tclass)
      di->tclass->ref_count--;
   di->tclass = tclass;
   if (di->tclass)
      di->tclass->ref_count++;
}

void
DialogItemSetPadding(DItem * di, int left, int right, int top, int bottom)
{
   di->padding.left = left;
   di->padding.right = right;
   di->padding.top = top;
   di->padding.bottom = bottom;
}

void
DialogItemSetFill(DItem * di, char fill_h, char fill_v)
{
   di->fill_h = fill_h;
   di->fill_v = fill_v;
}

void
DialogItemSetAlign(DItem * di, int align_h, int align_v)
{
   di->align_h = align_h;
   di->align_v = align_v;
}

void
DialogItemSetRowSpan(DItem * di, int row_span)
{
   di->row_span = row_span;
}

void
DialogItemSetColSpan(DItem * di, int col_span)
{
   di->col_span = col_span;
}

void
DialogRealizeItem(Dialog * d, DItem * di)
{
   char               *def = NULL;
   int                 iw = 0, ih = 0;

   if (di->type == DITEM_BUTTON)
     {
	def = "DIALOG_WIDGET_BUTTON";
     }
   else if (di->type == DITEM_CHECKBUTTON)
     {
	def = "DIALOG_WIDGET_CHECK_BUTTON";
     }
   else if (di->type == DITEM_TEXT)
     {
	def = "DIALOG_WIDGET_TEXT";
     }
   else if (di->type == DITEM_SEPARATOR)
     {
	def = "DIALOG_WIDGET_SEPARATOR";
     }
   else if (di->type == DITEM_TABLE)
     {
	def = "DIALOG_WIDGET_TABLE";
     }
   else if (di->type == DITEM_RADIOBUTTON)
     {
	def = "DIALOG_WIDGET_RADIO_BUTTON";
     }
   else if (di->type == DITEM_AREA)
     {
	def = "DIALOG_WIDGET_AREA";
     }
   else
     {
	def = "DIALOG_WIDGET_BUTTON";
     }

   if (def)
     {
	if (!di->tclass)
	   di->tclass = FindItem(def, 0, LIST_FINDBY_NAME, LIST_TYPE_TCLASS);
	if (!di->iclass)
	   di->iclass = FindItem(def, 0, LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
     }
   if (!di->tclass)
     {
	DialogRealizeTClassDefault();
	di->tclass = d_tc_default;
     }
   if (di->tclass)
      di->tclass->ref_count++;

   if (!di->iclass)
     {
	DialogRealizeIClassDefault();
	di->iclass = d_ic_default;
     }
   if (di->iclass)
      di->iclass->ref_count++;

   if (di->type == DITEM_TABLE)
     {
	int                 i;

	for (i = 0; i < di->item.table.num_items; i++)
	   DialogRealizeItem(d, di->item.table.items[i]);
     }
   switch (di->type)
     {
     case DITEM_SLIDER:
	if (di->item.slider.numeric)
	  {
	     di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	     EMapWindow(disp, di->win);
	     XSelectInput(disp, di->win, EnterWindowMask | LeaveWindowMask |
			  ButtonPressMask | ButtonReleaseMask);
	  }
	di->item.slider.base_win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->item.slider.base_win);
	di->item.slider.knob_win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->item.slider.knob_win);
	XSelectInput(disp, di->item.slider.base_win,
		     EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		     ButtonReleaseMask);
	XSelectInput(disp, di->item.slider.knob_win,
		     ButtonPressMask |
		     ButtonReleaseMask | PointerMotionMask);
	if (!di->item.slider.ic_base)
	  {
	     if (di->item.slider.horizontal)
	       {
		  di->item.slider.ic_base =
		     FindItem("DIALOG_WIDGET_SLIDER_BASE_HORIZONTAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	     else
	       {
		  di->item.slider.ic_base =
		     FindItem("DIALOG_WIDGET_SLIDER_BASE_VERTICAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	  }
	if (!di->item.slider.ic_base)
	  {
	     DialogRealizeIClassDefault();
	     di->item.slider.ic_base = d_ic_default;
	  }
	if (di->item.slider.ic_base->norm.normal->im_file)
	  {
	     ImlibImage         *im;

	     im = ELoadImage(di->item.slider.ic_base->norm.normal->im_file);
	     if (im)
	       {
		  di->item.slider.base_orig_w = im->rgb_width;
		  di->item.slider.base_orig_h = im->rgb_height;
		  Imlib_destroy_image(id, im);
	       }
	  }
	if (di->item.slider.ic_base)
	   di->item.slider.ic_base->ref_count++;

	if (!di->item.slider.ic_knob)
	  {
	     if (di->item.slider.horizontal)
	       {
		  di->item.slider.ic_knob =
		     FindItem("DIALOG_WIDGET_SLIDER_KNOB_HORIZONTAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	     else
	       {
		  di->item.slider.ic_knob =
		     FindItem("DIALOG_WIDGET_SLIDER_KNOB_VERTICAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	  }
	if (!di->item.slider.ic_knob)
	  {
	     DialogRealizeIClassDefault();
	     di->item.slider.ic_knob = d_ic_default;
	  }
	if (di->item.slider.ic_knob)
	   di->item.slider.ic_knob->ref_count++;

	if (di->item.slider.ic_knob->norm.normal->im_file)
	  {
	     ImlibImage         *im;

	     im = ELoadImage(di->item.slider.ic_knob->norm.normal->im_file);
	     if (im)
	       {
		  di->item.slider.knob_orig_w = im->rgb_width;
		  di->item.slider.knob_orig_h = im->rgb_height;
		  Imlib_destroy_image(id, im);
	       }
	  }
	if (!di->item.slider.ic_border)
	  {
	     if (di->item.slider.horizontal)
	       {
		  di->item.slider.ic_border =
		     FindItem("DIALOG_WIDGET_SLIDER_BORDER_HORIZONTAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	     else
	       {
		  di->item.slider.ic_border =
		     FindItem("DIALOG_WIDGET_SLIDER_BORDER_VERTICAL", 0,
			      LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
	       }
	  }
	if (di->item.slider.ic_border)
	  {
	     if (di->item.slider.ic_border->norm.normal->im_file)
	       {
		  ImlibImage         *im;

		  im = ELoadImage(di->item.slider.ic_border->norm.normal->im_file);
		  if (im)
		    {
		       di->item.slider.border_orig_w = im->rgb_width;
		       di->item.slider.border_orig_h = im->rgb_height;
		       Imlib_destroy_image(id, im);
		       di->item.slider.border_win = ECreateWindow(d->win, -20,
								-20, 2, 2, 0);
		       EMapWindow(disp, di->item.slider.border_win);
		    }
	       }
	     di->item.slider.ic_border->ref_count++;
	  }
	if (di->item.slider.horizontal)
	  {
	     iw = di->item.slider.min_length +
		di->item.slider.ic_base->padding.left +
		di->item.slider.ic_base->padding.right;
	     ih = di->item.slider.base_orig_h;
	  }
	else
	  {
	     iw = di->item.slider.base_orig_w;
	     ih = di->item.slider.min_length +
		di->item.slider.ic_base->padding.top +
		di->item.slider.ic_base->padding.bottom;
	  }
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_BUTTON:
	TextSize(di->tclass, 0, 0, STATE_NORMAL, di->item.button.text,
		 &iw, &ih, 17);
	iw += di->iclass->padding.left + di->iclass->padding.right;
	ih += di->iclass->padding.top + di->iclass->padding.bottom;
	di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->win);
	XSelectInput(disp, di->win, EnterWindowMask | LeaveWindowMask |
		     ButtonPressMask | ButtonReleaseMask | ExposureMask);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_AREA:
	iw = di->item.area.w;
	ih = di->item.area.h;
	iw += di->iclass->padding.left + di->iclass->padding.right;
	ih += di->iclass->padding.top + di->iclass->padding.bottom;
	di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->win);
	XSelectInput(disp, di->win, ExposureMask);
	di->item.area.area_win = ECreateWindow(di->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->item.area.area_win);
	XSelectInput(disp, di->item.area.area_win, EnterWindowMask |
		     LeaveWindowMask | ButtonPressMask | ButtonReleaseMask |
		     ExposureMask | PointerMotionMask);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_CHECKBUTTON:
	if (di->iclass->norm.normal->im_file)
	  {
	     ImlibImage         *im;

	     im = ELoadImage(di->iclass->norm.normal->im_file);
	     if (im)
	       {
		  di->item.check_button.check_orig_w = im->rgb_width;
		  di->item.check_button.check_orig_h = im->rgb_height;
		  Imlib_destroy_image(id, im);
	       }
	  }
	TextSize(di->tclass, 0, 0, STATE_NORMAL, di->item.check_button.text,
		 &iw, &ih, 17);
	if (ih < di->item.check_button.check_orig_h)
	   ih = di->item.check_button.check_orig_h;
	iw += di->item.check_button.check_orig_w + di->iclass->padding.left;
	di->item.check_button.check_win = ECreateWindow(d->win, -20, -20,
							2, 2, 0);
	di->win = ECreateEventWindow(d->win, -20, -20, 2, 2);
	EMapWindow(disp, di->item.check_button.check_win);
	EMapWindow(disp, di->win);
	XSelectInput(disp, di->win, EnterWindowMask | LeaveWindowMask |
		     ButtonPressMask | ButtonReleaseMask | ExposureMask);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_TEXT:
	TextSize(di->tclass, 0, 0, STATE_NORMAL, di->item.text.text,
		 &iw, &ih, 17);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_IMAGE:
	{
	   ImlibImage         *im;

	   im = ELoadImage(di->item.image.image);
	   if (im)
	     {
		iw = im->rgb_width;
		ih = im->rgb_height;
		di->win = ECreateWindow(d->win, 0, 0, iw, ih, 0);
		EMapWindow(disp, di->win);
		Imlib_apply_image(id, im, di->win);
		Imlib_destroy_image(id, im);
	     }
	}
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_SEPARATOR:
	iw = di->iclass->padding.left + di->iclass->padding.right;
	ih = di->iclass->padding.top + di->iclass->padding.bottom;
	di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
	EMapWindow(disp, di->win);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_RADIOBUTTON:
	if (di->iclass->norm.normal->im_file)
	  {
	     ImlibImage         *im;

	     im = ELoadImage(di->iclass->norm.normal->im_file);
	     if (im)
	       {
		  di->item.radio_button.radio_orig_w = im->rgb_width;
		  di->item.radio_button.radio_orig_h = im->rgb_height;
		  Imlib_destroy_image(id, im);
	       }
	  }
	TextSize(di->tclass, 0, 0, STATE_NORMAL, di->item.radio_button.text,
		 &iw, &ih, 17);
	if (ih < di->item.radio_button.radio_orig_h)
	   ih = di->item.radio_button.radio_orig_h;
	iw += di->item.radio_button.radio_orig_w + di->iclass->padding.left;
	di->item.radio_button.radio_win = ECreateWindow(d->win, -20, -20,
							2, 2, 0);
	di->win = ECreateEventWindow(d->win, -20, -20, 2, 2);
	EMapWindow(disp, di->item.radio_button.radio_win);
	EMapWindow(disp, di->win);
	XSelectInput(disp, di->win, EnterWindowMask | LeaveWindowMask |
		     ButtonPressMask | ButtonReleaseMask | ExposureMask);
	di->w = iw;
	di->h = ih;
	break;
     case DITEM_TABLE:
	{
	   int                 cols, rows;

	   cols = di->item.table.num_columns;
	   rows = 1;
	   if ((cols > 0) && (rows > 0))
	     {
		int                 i, *col_size, *row_size = NULL, r = 0,
		                    c = 0, x = 0, y = 0;

		col_size = Emalloc(sizeof(int) * cols);
		row_size = Erealloc(row_size, sizeof(int));

		row_size[0] = 0;
		for (i = 0; i < cols; i++)
		   col_size[i] = 0;
		for (i = 0; i < di->item.table.num_items; i++)
		  {
		     DItem              *dii;
		     int                 w, h, j, csum = 0;

		     dii = di->item.table.items[i];
		     w = dii->w + (dii->padding.left + dii->padding.right);
		     h = dii->h + (dii->padding.top + dii->padding.bottom);
		     for (j = 0; j < dii->col_span; j++)
			csum += col_size[c + j];
		     if (w > csum)
			col_size[c + di->col_span - 1] += (w - csum);
		     if (h > row_size[r])
			row_size[r] = h;
		     c += dii->col_span;
		     if (c >= cols)
		       {
			  c = 0;
			  r++;
			  rows++;
			  row_size = Erealloc(row_size, sizeof(int) * rows);

			  row_size[rows - 1] = 0;
		       }
		  }
		if (di->item.table.homogenous_h)
		  {
		     int                 max = 0;

		     for (i = 0; i < cols; i++)
		       {
			  if (col_size[i] > max)
			     max = col_size[i];
		       }
		     for (i = 0; i < cols; i++)
			col_size[i] = max;
		  }
		if (di->item.table.homogenous_v)
		  {
		     int                 max = 0;

		     for (i = 0; i < rows; i++)
		       {
			  if (row_size[i] > max)
			     max = row_size[i];
		       }
		     for (i = 0; i < rows; i++)
			row_size[i] = max;
		  }
		iw = 0;
		ih = 0;
		for (i = 0; i < cols; i++)
		   iw += col_size[i];
		for (i = 0; i < rows; i++)
		   ih += row_size[i];
		di->w = iw;
		di->h = ih;
		r = 0;
		c = 0;
		for (i = 0; i < di->item.table.num_items; i++)
		  {
		     DItem              *dii;
		     int                 j, sw = 0, sh = 0;

		     dii = di->item.table.items[i];

		     for (j = 0; j < dii->col_span; j++)
			sw += col_size[c + j];
		     for (j = 0; j < dii->row_span; j++)
			sh += row_size[r + j];
		     if (dii->fill_h)
			dii->w = sw - (dii->padding.left
				       + dii->padding.right);
		     if (dii->fill_v)
			dii->h = sh - (dii->padding.top
				       + dii->padding.bottom);
		     if (dii->type == DITEM_TABLE)
		       {
			  int                 dx, dy, newx, newy;

			  newx = di->x + x + d->iclass->padding.left +
			     dii->padding.left +
			     (((sw - (dii->padding.left
				      + dii->padding.right) -
				dii->w) * dii->align_h) >> 10);
			  newy = di->y + y + d->iclass->padding.top +
			     dii->padding.top +
			     (((sh - (dii->padding.top
				      + dii->padding.bottom) -
				dii->h) * dii->align_v) >> 10);
			  dx = newx - dii->x - d->iclass->padding.left;
			  dy = newy - dii->y - d->iclass->padding.top;
			  MoveTableBy(d, dii, dx, dy);
		       }
		     else
		       {
			  dii->x = di->x + x + d->iclass->padding.left +
			     dii->padding.left +
			     (((sw - (dii->padding.left
				      + dii->padding.right) -
				dii->w) * dii->align_h) >> 10);
			  dii->y = di->y + y + d->iclass->padding.top +
			     dii->padding.top +
			     (((sh - (dii->padding.top + dii->padding.bottom)
				- dii->h) * dii->align_v) >> 10);
			  if (dii->win)
			     EMoveResizeWindow(disp, dii->win, dii->x, dii->y,
					       dii->w, dii->h);
			  if (dii->type == DITEM_CHECKBUTTON)
			     EMoveResizeWindow(disp,
					     dii->item.check_button.check_win,
					       dii->x, dii->y +
					       ((dii->h -
				    dii->item.check_button.check_orig_h) / 2),
					  dii->item.check_button.check_orig_w,
					 dii->item.check_button.check_orig_h);
			  if (dii->type == DITEM_RADIOBUTTON)
			     EMoveResizeWindow(disp,
					     dii->item.radio_button.radio_win,
					       dii->x, dii->y +
					       ((dii->h -
				    dii->item.radio_button.radio_orig_h) / 2),
					  dii->item.radio_button.radio_orig_w,
					 dii->item.radio_button.radio_orig_h);
			  if (dii->type == DITEM_AREA)
			    {
			       dii->item.area.w = dii->w -
				  (dii->iclass->padding.left +
				   dii->iclass->padding.right);
			       dii->item.area.h = dii->h -
				  (dii->iclass->padding.top +
				   dii->iclass->padding.bottom);
			       EMoveResizeWindow(disp, dii->item.area.area_win,
						 dii->iclass->padding.left,
						 dii->iclass->padding.top,
						 dii->item.area.w,
						 dii->item.area.h);
			    }
			  if (dii->type == DITEM_SLIDER)
			    {
			       dii->item.slider.base_x = 0;
			       dii->item.slider.base_y = 0;
			       dii->item.slider.base_w = dii->w;
			       dii->item.slider.base_h = dii->h;
			       dii->item.slider.border_x = 0;
			       dii->item.slider.border_y = 0;
			       dii->item.slider.border_w = dii->w;
			       dii->item.slider.border_h = dii->h;
			       dii->item.slider.knob_w =
				  dii->item.slider.knob_orig_w;
			       dii->item.slider.knob_h =
				  dii->item.slider.knob_orig_h;
			       if (dii->item.slider.base_win)
				  EMoveResizeWindow(disp,
						    dii->item.slider.base_win,
					     dii->x + dii->item.slider.base_x,
					     dii->y + dii->item.slider.base_y,
						    dii->item.slider.base_w,
						    dii->item.slider.base_h);
			       if (dii->item.slider.border_win)
				  EMoveResizeWindow(disp,
						  dii->item.slider.border_win,
					   dii->x + dii->item.slider.border_x,
					   dii->y + dii->item.slider.border_y,
						    dii->item.slider.border_w,
						    dii->item.slider.border_h);
			       if (dii->win)
				  EMoveResizeWindow(disp, dii->win,
					  dii->x + dii->item.slider.numeric_x,
					  dii->y + dii->item.slider.numeric_y,
						    dii->item.slider.numeric_w,
						  dii->item.slider.numeric_h);
			    }
		       }
		     x += sw;
		     c += dii->col_span;
		     if (c >= cols)
		       {
			  x = 0;
			  y += row_size[r];
			  c = 0;
			  r++;
		       }
		  }
		if (col_size)
		   Efree(col_size);
		if (row_size)
		   Efree(row_size);
	     }
	}
	break;
     case DITEM_NONE:
     default:
	di->w = 0;
	di->h = 0;
	break;
     }
}

void
MoveTableBy(Dialog * d, DItem * di, int dx, int dy)
{
   int                 i;

   di->x += dx;
   di->y += dy;
   for (i = 0; i < di->item.table.num_items; i++)
     {
	DItem              *dii;

	dii = di->item.table.items[i];
	dii->x += dx;
	dii->y += dy;
	if (dii->type == DITEM_TABLE)
	   MoveTableBy(d, dii, dx, dy);
	if (dii->win)
	   EMoveWindow(disp, dii->win, dii->x, dii->y);
	if (dii->type == DITEM_CHECKBUTTON)
	   EMoveWindow(disp, dii->item.check_button.check_win,
		       dii->x, dii->y +
		       ((dii->h - dii->item.check_button.check_orig_h) / 2));
	if (dii->type == DITEM_RADIOBUTTON)
	   EMoveWindow(disp, dii->item.radio_button.radio_win,
		       dii->x, dii->y +
		       ((dii->h - dii->item.radio_button.radio_orig_h) / 2));
	if (dii->type == DITEM_SLIDER)
	  {
	     if (dii->item.slider.base_win)
		EMoveResizeWindow(disp, dii->item.slider.base_win,
				  dii->x + dii->item.slider.base_x,
				  dii->y + dii->item.slider.base_y,
				  dii->item.slider.base_w,
				  dii->item.slider.base_h);
	     if (dii->item.slider.knob_win)
		EMoveResizeWindow(disp, dii->item.slider.knob_win,
				  dii->x + dii->item.slider.knob_x,
				  dii->y + dii->item.slider.knob_y,
				  dii->item.slider.knob_w,
				  dii->item.slider.knob_h);
	     if (dii->item.slider.border_win)
		EMoveResizeWindow(disp, dii->item.slider.border_win,
				  dii->x + dii->item.slider.border_x,
				  dii->y + dii->item.slider.border_y,
				  dii->item.slider.border_w,
				  dii->item.slider.border_h);
	     if (dii->win)
		EMoveResizeWindow(disp, dii->win,
				  dii->x + dii->item.slider.numeric_x,
				  dii->y + dii->item.slider.numeric_y,
				  dii->item.slider.numeric_w,
				  dii->item.slider.numeric_h);
	  }
     }
}

#define INTERSECTS(x, y, w, h, xx, yy, ww, hh) \
((x < (xx + ww)) && \
 (y < (yy + hh)) && \
 ((x + w) > xx) && \
 ((y + h) > yy))

void
DialogDrawItems(Dialog * d, DItem * di, int x, int y, int w, int h)
{
   int                 state;

   if (queue_up)
     {
	DrawQueue          *dq;

	dq = Emalloc(sizeof(DrawQueue));
	dq->win = 0;
	dq->iclass = NULL;
	dq->w = w;
	dq->h = h;
	dq->active = 0;
	dq->sticky = 0;
	dq->state = 0;
	dq->expose = 0;
	dq->tclass = NULL;
	dq->text = NULL;
	dq->shape_propagate = 0;
	dq->pager = NULL;
	dq->redraw_pager = NULL;
	dq->d = d;
	dq->di = di;
	dq->x = x;
	dq->y = y;
	AddItem(dq, "DRAW", 0, LIST_TYPE_DRAW);
	EDBUG_RETURN_;
     }
   if (di->type == DITEM_TABLE)
     {
	int                 i;

	if (INTERSECTS(x, y, w, h,
		       di->x, di->y, di->w, di->h))
	  {
	     for (i = 0; i < di->item.table.num_items; i++)
		DialogDrawItems(d, di->item.table.items[i], x, y, w, h);
	  }
	return;
     }
   if (INTERSECTS(x, y, w, h,
		  di->x, di->y, di->w, di->h))
     {
	switch (di->type)
	  {
	  case DITEM_SLIDER:
	     if (di->item.slider.horizontal)
	       {
		  di->item.slider.knob_x = di->item.slider.base_x +
		     (((di->item.slider.base_w - di->item.slider.knob_w) *
		       (di->item.slider.val - di->item.slider.lower)) /
		      (di->item.slider.upper - di->item.slider.lower));
		  di->item.slider.knob_y = di->item.slider.base_y +
		     ((di->item.slider.base_h - di->item.slider.knob_h) / 2);
	       }
	     else
	       {
		  di->item.slider.knob_y = (di->item.slider.base_y +
					    di->item.slider.base_h -
					    di->item.slider.knob_h) -
		     (((di->item.slider.base_h - di->item.slider.knob_h) *
		       (di->item.slider.val - di->item.slider.lower)) /
		      (di->item.slider.upper - di->item.slider.lower));
		  di->item.slider.knob_x = di->item.slider.base_x +
		     ((di->item.slider.base_w - di->item.slider.knob_w) / 2);
	       }
	     if (di->item.slider.knob_win)
		EMoveResizeWindow(disp, di->item.slider.knob_win,
				  di->x + di->item.slider.knob_x,
				  di->y + di->item.slider.knob_y,
				  di->item.slider.knob_w,
				  di->item.slider.knob_h);
	     if (di->item.slider.base_win)
		IclassApply(di->item.slider.ic_base,
			    di->item.slider.base_win,
			    di->item.slider.base_w, di->item.slider.base_h,
			    0, 0, STATE_NORMAL, 0);
	     if (di->item.slider.border_win)
		IclassApply(di->item.slider.ic_border,
			    di->item.slider.border_win,
			    di->item.slider.border_w, di->item.slider.border_h,
			    0, 0, STATE_NORMAL, 0);
	     state = STATE_NORMAL;
	     if ((di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     else if ((di->hilited) && (!di->clicked))
		state = STATE_HILITED;
	     else if (!(di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     if (di->item.slider.knob_win)
		IclassApply(di->item.slider.ic_knob,
			    di->item.slider.knob_win,
			    di->item.slider.knob_w, di->item.slider.knob_h,
			    0, 0, state, 0);
	     break;
	  case DITEM_BUTTON:
	     state = STATE_NORMAL;
	     if ((di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     else if ((di->hilited) && (!di->clicked))
		state = STATE_HILITED;
	     else if (!(di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     IclassApply(di->iclass, di->win, di->w, di->h, 0, 0, state, 0);
	     TclassApply(di->iclass, di->win, di->w, di->h, 0, 0, state, 1,
			 di->tclass, di->item.button.text);
	     break;
	  case DITEM_AREA:
	     IclassApply(di->iclass, di->win, di->w, di->h,
			 0, 0, STATE_NORMAL, 0);
	     break;
	  case DITEM_CHECKBUTTON:
	     state = STATE_NORMAL;
	     if ((di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     else if ((di->hilited) && (!di->clicked))
		state = STATE_HILITED;
	     else if (!(di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     if (di->item.check_button.onoff)
		IclassApply(di->iclass, di->item.check_button.check_win,
			    di->item.check_button.check_orig_w,
			    di->item.check_button.check_orig_h, 1, 0,
			    state, 0);
	     else
		IclassApply(di->iclass, di->item.check_button.check_win,
			    di->item.check_button.check_orig_w,
			    di->item.check_button.check_orig_h, 0, 0,
			    state, 0);
	     XClearArea(disp, d->win, di->x, di->y, di->w, di->h, False);
	     TextDraw(di->tclass, d->win, 0, 0, STATE_NORMAL,
		      di->item.check_button.text,
		      di->x + di->item.check_button.check_orig_w +
		      di->iclass->padding.left, di->y,
		      di->w - di->item.check_button.check_orig_w -
		      di->iclass->padding.left, 99999,
		      17, di->tclass->justification);
	     break;
	  case DITEM_TEXT:
	     XClearArea(disp, d->win, di->x, di->y, di->w, di->h, False);
	     TextDraw(di->tclass, d->win, 0, 0, STATE_NORMAL,
		      di->item.text.text, di->x, di->y, di->w,
		      99999, 17, di->tclass->justification);
	     break;
	  case DITEM_IMAGE:
	     break;
	  case DITEM_SEPARATOR:
	     if (di->item.separator.horizontal)
		IclassApply(di->iclass, di->win, di->w,
			    di->h, 0, 0, STATE_NORMAL, 0);
	     else
		IclassApply(di->iclass, di->win, di->w,
			    di->h, 0, 0, STATE_CLICKED, 0);
	     break;
	  case DITEM_RADIOBUTTON:
	     state = STATE_NORMAL;
	     if ((di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     else if ((di->hilited) && (!di->clicked))
		state = STATE_HILITED;
	     else if (!(di->hilited) && (di->clicked))
		state = STATE_CLICKED;
	     if (di->item.radio_button.onoff)
		IclassApply(di->iclass, di->item.radio_button.radio_win,
			    di->item.radio_button.radio_orig_w,
			    di->item.radio_button.radio_orig_h, 1, 0,
			    state, 0);
	     else
		IclassApply(di->iclass, di->item.radio_button.radio_win,
			    di->item.radio_button.radio_orig_w,
			    di->item.radio_button.radio_orig_w, 0, 0,
			    state, 0);
	     XClearArea(disp, d->win, di->x, di->y, di->w, di->h, False);
	     TextDraw(di->tclass, d->win, 0, 0, STATE_NORMAL,
		      di->item.radio_button.text,
		      di->x + di->item.radio_button.radio_orig_w +
		      di->iclass->padding.left, di->y,
		      di->w - di->item.radio_button.radio_orig_w -
		      di->iclass->padding.left, 99999,
		      17, di->tclass->justification);
	     break;
	  default:
	     break;
	  }
     }
}

void
DialogItemsRealize(Dialog * d)
{
   char                pq;

   if (!d->item)
      return;
   DialogRealizeItem(d, d->item);
   pq = queue_up;
   queue_up = 0;
   DialogDrawItems(d, d->item, 0, 0, 99999, 99999);
   queue_up = pq;
   d->w = d->item->w + d->iclass->padding.left + d->iclass->padding.right;
   d->h = d->item->h + d->iclass->padding.top + d->iclass->padding.bottom;
}

void
DialogItemButtonSetText(DItem * di, char *text)
{
   if (di->item.button.text)
      Efree(di->item.button.text);
   di->item.button.text = duplicate(text);
}

void
DialogItemCheckButtonSetText(DItem * di, char *text)
{
   if (di->item.check_button.text)
      Efree(di->item.check_button.text);
   di->item.check_button.text = duplicate(text);
}

void
DialogItemTextSetText(DItem * di, char *text)
{
   if (di->item.text.text)
      Efree(di->item.text.text);
   di->item.text.text = duplicate(text);
}

void
DialogItemRadioButtonSetText(DItem * di, char *text)
{
   if (di->item.check_button.text)
      Efree(di->item.check_button.text);
   di->item.check_button.text = duplicate(text);
}

void
DialogItemRadioButtonSetFirst(DItem * di, DItem * first)
{
   di->item.radio_button.first = first;
   if (di == first)
      return;
   while (first->item.radio_button.next)
      first = first->item.radio_button.next;
   first->item.radio_button.next = di;
}

void
DialogItemRadioButtonGroupSetValPtr(DItem * di, int *val_ptr)
{
   while (di)
     {
	di->item.radio_button.val_ptr = val_ptr;
	if (*val_ptr == di->item.radio_button.val)
	   di->item.check_button.onoff = 1;
	di = di->item.radio_button.next;
     }
}

void
DialogItemRadioButtonGroupSetVal(DItem * di, int val)
{
   di->item.radio_button.val = val;
}

void
DialogItemCheckButtonSetState(DItem * di, char onoff)
{
   di->item.check_button.onoff = onoff;
}

void
DialogItemCheckButtonSetPtr(DItem * di, char *onoff_ptr)
{
   di->item.check_button.onoff_ptr = onoff_ptr;
}

void
DialogItemTableSetOptions(DItem * di, int num_columns, char border,
			  char homogenous_h, char homogenous_v)
{
   di->item.table.num_columns = num_columns;
   di->item.table.border = border;
   di->item.table.homogenous_h = homogenous_h;
   di->item.table.homogenous_v = homogenous_v;
}

void
DialogItemSeparatorSetOrientation(DItem * di, char horizontal)
{
   di->item.separator.horizontal = horizontal;
}

void
DialogItemImageSetFile(DItem * di, char *image)
{
   if (di->item.image.image)
      Efree(di->item.image.image);
   di->item.image.image = duplicate(image);
   di->fill_h = 0;
   di->fill_v = 0;
}

void
DialogItemSliderSetVal(DItem * di, int val)
{
   di->item.slider.val = val;
   if (val < di->item.slider.lower)
     {
	di->item.slider.val = di->item.slider.lower;
     }
   else if (val > di->item.slider.upper)
     {
	di->item.slider.val = di->item.slider.upper;
     }
}

void
DialogItemSliderSetBounds(DItem * di, int lower, int upper)
{
   if (lower < upper)
     {
	di->item.slider.lower = lower;
	di->item.slider.upper = upper;
     }
   else
     {
	di->item.slider.lower = upper;
	di->item.slider.upper = lower;
     }
   if (di->item.slider.upper <= di->item.slider.lower)
      di->item.slider.upper = di->item.slider.lower + 1;
}

void
DialogItemSliderSetUnits(DItem * di, int units)
{
   di->item.slider.unit = units;
}

void
DialogItemSliderSetJump(DItem * di, int jump)
{
   di->item.slider.jump = jump;
}

void
DialogItemSliderSetMinLength(DItem * di, int min)
{
   di->item.slider.min_length = min;
}

void
DialogItemSliderSetValPtr(DItem * di, int *val_ptr)
{
   di->item.slider.val_ptr = val_ptr;
}

void
DialogItemSliderSetOrientation(DItem * di, char horizontal)
{
   di->item.slider.horizontal = horizontal;
}

void
DialogItemAreaSetSize(DItem * di, int w, int h)
{
   di->item.area.w = w;
   di->item.area.h = h;
}

Window
DialogItemAreaGetWindow(DItem * di)
{
   return di->item.area.area_win;
}

void
DialogItemAreaGetSize(DItem * di, int *w, int *h)
{
   *w = di->item.area.w;
   *h = di->item.area.h;
}

void
DialogItemAreaSetEventFunc(DItem * di, void (*func) (int val, void *data))
{
   di->item.area.event_func = func;
}

void
DialogFreeItem(DItem * di)
{
   if (di->type == DITEM_TABLE)
     {
	int                 i;

	for (i = 0; i < di->item.table.num_items; i++)
	   DialogFreeItem(di->item.table.items[i]);
     }
   switch (di->type)
     {
     case DITEM_BUTTON:
	if (di->item.text.text)
	   Efree(di->item.text.text);
	break;
     case DITEM_CHECKBUTTON:
	if (di->item.text.text)
	   Efree(di->item.text.text);
	break;
     case DITEM_TEXT:
	if (di->item.text.text)
	   Efree(di->item.text.text);
	break;
     case DITEM_IMAGE:
	if (di->item.image.image)
	   Efree(di->item.image.image);
	break;
     case DITEM_SLIDER:
	if (di->item.slider.ic_base)
	   di->item.slider.ic_base->ref_count--;
	if (di->item.slider.ic_knob)
	   di->item.slider.ic_knob->ref_count--;
	if (di->item.slider.ic_border)
	   di->item.slider.ic_border->ref_count--;
	break;
     case DITEM_SEPARATOR:
	break;
     case DITEM_TABLE:
	if (di->item.table.items)
	   Efree(di->item.table.items);
	break;
     default:
	break;
     }

   if (di->iclass)
      di->iclass->ref_count--;
   if (di->tclass)
      di->tclass->ref_count--;

   Efree(di);
}

DItem              *
DialogItemFindWindow(DItem * di, Window win)
{
   DItem              *dii = NULL;

   if (di->type == DITEM_TABLE)
     {
	int                 i;

	for (i = 0; i < di->item.table.num_items; i++)
	  {
	     if ((dii = DialogItemFindWindow(di->item.table.items[i], win)))
		return dii;
	  }
     }
   else if ((di->win == win) || ((di->type == DITEM_SLIDER) &&
				 ((di->item.slider.base_win == win) ||
				  (di->item.slider.knob_win == win))) ||
	    ((di->type == DITEM_AREA) &&
	     (di->item.area.area_win == win)))
     {
	return di;
     }
   return NULL;
}