/*
 * Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
 * Copyright (C) 2004-2007 Kim Woelders
 *
 * 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"
#include "container.h"
#include "dialog.h"
#include "e16-ecore_list.h"
#include "emodule.h"
#include "eobj.h"
#include "ewins.h"
#include "hints.h"
#include "iclass.h"
#include "menus.h"

extern const ContainerOps IconboxOps;
extern const ContainerOps SystrayOps;

static void         ContainersConfigSave(void);

static void         ContainerLayout(Container * ct, int *px, int *py, int *pw,
				    int *ph);
static void         ContainerDraw(Container * ct);

static void         ContainerEventScrollWin(Win win, XEvent * ev, void *prm);
static void         ContainerEventScrollbarWin(Win win, XEvent * ev, void *prm);
static void         ContainerEventCoverWin(Win win, XEvent * ev, void *prm);
static void         ContainerEventArrow1Win(Win win, XEvent * ev, void *prm);
static void         ContainerEventArrow2Win(Win win, XEvent * ev, void *prm);
static void         ContainerEventIconWin(Win win, XEvent * ev, void *prm);

ContainerCfg        Conf_containers;

Ecore_List         *container_list = NULL;

static int
_ContainerMatchName(const void *data, const void *match)
{
   return strcmp(((const Container *)data)->name, match);
}

static Container   *
ContainerFind(const char *name)
{
   return ecore_list_find(container_list, _ContainerMatchName, name);
}

static Container   *
ContainerCreate(const char *name)
{
   Container          *ct;

   if (ContainerFind(name))
      return NULL;

   ct = Ecalloc(1, sizeof(Container));
   if (!ct)
      return NULL;

   if (!container_list)
      container_list = ecore_list_new();
   ecore_list_append(container_list, ct);

   ct->name = Estrdup(name);
   ct->type = (name && !strcmp(name, "_ST_")) ?
      IB_TYPE_SYSTRAY : IB_TYPE_ICONBOX;
   ct->orientation = 0;
   ct->scrollbar_side = 1;
   ct->arrow_side = 1;
   ct->nobg = 0;
   ct->shownames = 1;
   ct->iconsize = 48;
   ct->icon_mode = 2;
   ct->auto_resize = 0;
   ct->draw_icon_base = 0;
   ct->scrollbar_hide = 0;
   ct->cover_hide = 0;
   ct->auto_resize_anchor = 0;
   /* FIXME: need to have theme settable params for this and get them */
   ct->scroll_thickness = 12;
   ct->arrow_thickness = 12;
   ct->bar_thickness = 8;
   ct->knob_length = 8;

   ct->w = 0;
   ct->h = 0;
   ct->pos = 0;
   ct->max = 1;
   ct->arrow1_hilited = 0;
   ct->arrow1_clicked = 0;
   ct->arrow2_hilited = 0;
   ct->arrow2_clicked = 0;
   ct->icon_clicked = 0;
   ct->scrollbar_hilited = 0;
   ct->scrollbar_clicked = 0;
   ct->scrollbox_clicked = 0;

   ct->win = ECreateClientWindow(VRoot.win, 0, 0, 1, 1);
   ct->icon_win = ECreateWindow(ct->win, 0, 0, 128, 26, 0);
   EventCallbackRegister(ct->icon_win, 0, ContainerEventIconWin, ct);
   ct->cover_win = ECreateWindow(ct->win, 0, 0, 128, 26, 0);
   EventCallbackRegister(ct->cover_win, 0, ContainerEventCoverWin, ct);
   ct->scroll_win = ECreateWindow(ct->win, 6, 26, 116, 6, 0);
   EventCallbackRegister(ct->scroll_win, 0, ContainerEventScrollWin, ct);
   ct->arrow1_win = ECreateWindow(ct->win, 0, 26, 6, 6, 0);
   EventCallbackRegister(ct->arrow1_win, 0, ContainerEventArrow1Win, ct);
   ct->arrow2_win = ECreateWindow(ct->win, 122, 26, 6, 6, 0);
   EventCallbackRegister(ct->arrow2_win, 0, ContainerEventArrow2Win, ct);
   ct->scrollbar_win = ECreateWindow(ct->scroll_win, 122, 26, 6, 6, 0);
   EventCallbackRegister(ct->scrollbar_win, 0, ContainerEventScrollbarWin, ct);
   ct->scrollbarknob_win = ECreateWindow(ct->scrollbar_win, -20, -20, 4, 4, 0);

   ESelectInput(ct->icon_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask | PointerMotionMask);
   ESelectInput(ct->scroll_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask);
   ESelectInput(ct->cover_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask);
   ESelectInput(ct->arrow1_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask);
   ESelectInput(ct->arrow2_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask);
   ESelectInput(ct->scrollbar_win,
		EnterWindowMask | LeaveWindowMask | ButtonPressMask |
		ButtonReleaseMask | PointerMotionMask);

   EMapWindow(ct->icon_win);
   EMapWindow(ct->scrollbar_win);

   ct->ewin = NULL;
   ct->num_objs = 0;
   ct->objs = NULL;

   if (ct->type == IB_TYPE_ICONBOX)
      ct->ops = &IconboxOps;
   else if (ct->type == IB_TYPE_SYSTRAY)
      ct->ops = &SystrayOps;

   ct->ops->Init(ct);

   return ct;
}

static void
ContainerDestroy(Container * ct, int exiting)
{
   ecore_list_remove_node(container_list, ct);

   ct->ops->Exit(ct, exiting);

   if (ct->name)
      Efree(ct->name);

   EDestroyWindow(ct->win);

   if (ct->objs)
      Efree(ct->objs);

   Efree(ct);

   if (!exiting)
      ContainersConfigSave();
}

static void
ContainerReconfigure(Container * ct)
{
   ImageClass         *ic, *ic2;
   EImageBorder       *pad;
   EWin               *ewin;
   int                 extra;
   unsigned int        wmin, hmin, wmax, hmax;

   ewin = ct->ewin;

   wmin = hmin = 8;
   wmax = hmax = 16384;

   extra = 0;
   if (ct->orientation)
     {
	ic = ImageclassFind("ICONBOX_VERTICAL", 0);
	pad = ImageclassGetPadding(ic);
	if (ic)
	   extra = pad->left + pad->right;
	if (ct->draw_icon_base)
	  {
	     ic2 = ImageclassFind("DEFAULT_ICON_BUTTON", 0);
	     pad = ImageclassGetPadding(ic2);
	     if (ic2)
		extra += pad->left + pad->right;
	  }
	wmax = wmin = ct->iconsize + ct->scroll_thickness + extra;
	ct->max_min = hmin;
     }
   else
     {
	ic = ImageclassFind("ICONBOX_HORIZONTAL", 0);
	pad = ImageclassGetPadding(ic);
	if (ic)
	   extra = pad->top + pad->bottom;
	if (ct->draw_icon_base)
	  {
	     ic2 = ImageclassFind("DEFAULT_ICON_BUTTON", 0);
	     pad = ImageclassGetPadding(ic2);
	     if (ic2)
		extra += pad->top + pad->bottom;
	  }
	hmax = hmin = ct->iconsize + ct->scroll_thickness + extra;
	ct->max_min = wmin;
     }

   ICCCM_SetSizeConstraints(ewin, wmin, hmin, wmax, hmax, 0, 0, 1, 1,
			    0.0, 65535.0);
}

static void
ContainerEwinLayout(EWin * ewin, int *px, int *py, int *pw, int *ph)
{
   Container          *ct = ewin->data;

   ContainerLayout(ct, px, py, pw, ph);

   if (*pw != ct->w || *ph != ct->h)
      ct->do_update = 1;
}

static void
ContainerEwinMoveResize(EWin * ewin, int resize)
{
   Container          *ct = ewin->data;

   if (!resize && !ct->do_update && !TransparencyUpdateNeeded())
      return;

   ct->w = ewin->client.w;
   ct->h = ewin->client.h;

   ContainerDraw(ct);
   ct->do_update = 0;
}

static void
ContainerEwinClose(EWin * ewin)
{
   ContainerDestroy(ewin->data, 0);
   ewin->client.win = NULL;
   ewin->data = NULL;
}

static const EWinOps ContainerEwinOps = {
   ContainerEwinLayout,
   ContainerEwinMoveResize,
   ContainerEwinClose,
};

static void
ContainerEwinInit(EWin * ewin, void *ptr)
{
   ewin->data = (Container *) ptr;
   ewin->ops = &ContainerEwinOps;

   ewin->props.skip_ext_task = 1;
   ewin->props.skip_ext_pager = 1;
   ewin->props.skip_focuslist = 1;
   ewin->props.skip_winlist = 1;
   EwinInhSetWM(ewin, focus, 1);
   EwinInhSetWM(ewin, iconify, 1);
   ewin->props.autosave = 1;

   EoSetSticky(ewin, 1);
}

static void
ContainerShow(Container * ct)
{
   EWin               *ewin;

   if (!ct)
      return;

   HintsSetWindowName(ct->win, ct->wm_name);
   HintsSetWindowClass(ct->win, ct->name, "Enlightenment_IconBox");

   ewin = AddInternalToFamily(ct->win, "ICONBOX", EWIN_TYPE_ICONBOX, ct,
			      ContainerEwinInit);
   ct->ewin = ewin;
   if (!ewin)
      return;

   ContainerReconfigure(ct);

   if (ewin->state.placed)
     {
	EwinMoveToDesktop(ewin, EoGetDesk(ewin));
	EwinMoveResize(ewin, EoGetX(ewin), EoGetY(ewin), ewin->client.w,
		       ewin->client.h);
     }
   else
     {
	/* The first one */
	EwinMoveToDesktop(ewin, EoGetDesk(ewin));
	EwinResize(ewin, 128, 32);
	EwinMove(ewin, VRoot.w - EoGetW(ewin), VRoot.h - EoGetH(ewin));
     }

   EwinShow(ewin);
}

/*
 * Return index, -1 if not found.
 */
int
ContainerObjectFind(Container * ct, void *obj)
{
   int                 i;

   for (i = 0; i < ct->num_objs; i++)
      if (ct->objs[i].obj == obj)
	 return i;

   return -1;
}

int
ContainerObjectAdd(Container * ct, void *obj)
{
   /* Not if already there */
   if (ContainerObjectFind(ct, obj) >= 0)
      return -1;

   ct->num_objs++;
   ct->objs = Erealloc(ct->objs, sizeof(ContainerObject) * ct->num_objs);
   ct->objs[ct->num_objs - 1].obj = obj;

   return ct->num_objs - 1;	/* Success */
}

int
ContainerObjectDel(Container * ct, void *obj)
{
   int                 i, j;

   /* Quit if not there */
   i = ContainerObjectFind(ct, obj);
   if (i < 0)
      return -1;

   for (j = i; j < ct->num_objs - 1; j++)
      ct->objs[j] = ct->objs[j + 1];
   ct->num_objs--;
   if (ct->num_objs > 0)
      ct->objs = Erealloc(ct->objs, sizeof(ContainerObject) * ct->num_objs);
   else
     {
	Efree(ct->objs);
	ct->objs = NULL;
     }

   return 0;			/* Success */
}

void               *
ContainerObjectFindByXY(Container * ct, int px, int py)
{
   int                 i;
   ContainerObject    *cto;

   for (i = 0; i < ct->num_objs; i++)
     {
	cto = &ct->objs[i];

	if (px >= cto->xo - 1 && py >= cto->yo - 1 &&
	    px < cto->xo + cto->wo + 1 && py < cto->yo + cto->ho + 1)
	   return cto->obj;
     }

   return NULL;
}

static void
ContainerLayoutImageWin(Container * ct)
{
   int                 i, xo, yo;
   int                 item_pad, padl, padr, padt, padb;
   ContainerObject    *cto;
   EImageBorder       *pad, *pad_base;

   if (ct->orientation)
      ct->ic_box = ImageclassFind("ICONBOX_VERTICAL", 0);
   else
      ct->ic_box = ImageclassFind("ICONBOX_HORIZONTAL", 0);

   if (ct->draw_icon_base && !ct->im_item_base)
     {
	ct->ic_item_base = ImageclassFind("DEFAULT_ICON_BUTTON", 0);
	if (ct->ic_item_base)
	   ct->im_item_base =
	      ImageclassGetImage(ct->ic_item_base, 0, 0, STATE_NORMAL);
	if (!ct->im_item_base)
	  {
	     ct->ic_item_base = NULL;
	     ct->draw_icon_base = 0;
	  }
     }

   if (ct->draw_icon_base)
     {
	pad_base = ImageclassGetPadding(ct->ic_item_base);
	padl = pad_base->left;
	padr = pad_base->right;
	padt = pad_base->top;
	padb = pad_base->bottom;

	item_pad = 0;
     }
   else
     {
	pad_base = NULL;
	padl = padr = padt = padb = 0;

	item_pad = 2;
     }

   xo = 0;
   yo = 0;
   if (ct->ic_box)
     {
	pad = ImageclassGetPadding(ct->ic_box);
	xo += pad->left;
	yo += pad->top;
     }

   for (i = 0; i < ct->num_objs; i++)
     {
	cto = &ct->objs[i];

	/* Inner size */
	ct->ops->ObjSizeCalc(ct, cto);

	/* Outer size */
	if (ct->draw_icon_base && ct->im_item_base)
	  {
	     if (cto->wi > 0 && cto->hi > 0)
	       {
		  cto->wo = ct->iconsize + padl + padr;
		  cto->ho = ct->iconsize + padt + padb;
	       }
	     else
	       {
		  cto->wo = cto->ho = 0;
	       }
	  }
	else
	  {
	     if (cto->wi > 0 && cto->hi > 0)
	       {
		  if (ct->orientation)
		    {
		       cto->wo = ct->iconsize;
		       cto->ho = cto->hi;
		    }
		  else
		    {
		       cto->wo = cto->wi;
		       cto->ho = ct->iconsize;
		    }
	       }
	     else
	       {
		  cto->wo = cto->ho = 0;
	       }
	  }

	cto->xo = xo;
	cto->yo = yo;
	cto->xi = xo + (cto->wo - cto->wi) / 2;
	cto->yi = yo + (cto->ho - cto->hi) / 2;
#if 0
	Eprintf("xo,yo=%d,%d wo,ho=%d,%d  xi,yi=%d,%d wi,hi=%d,%d\n",
		cto->xo, cto->yo, cto->wo, cto->ho, cto->xi, cto->yi, cto->wi,
		cto->hi);
#endif

	if (ct->orientation)
	   yo += cto->ho + item_pad;
	else
	   xo += cto->wo + item_pad;
     }

   if (ct->ic_box)
     {
	pad = ImageclassGetPadding(ct->ic_box);
	xo += pad->right;
	yo += pad->bottom;
     }

   if (ct->orientation)
      ct->max = yo - item_pad;
   else
      ct->max = xo - item_pad;

   if (ct->max < ct->max_min)
      ct->max = ct->max_min;
}

static void
ContainerDrawScroll(Container * ct)
{
   ImageClass         *ic;
   EImageBorder       *pad;
   int                 arrow_mode = ct->arrow_side;
   int                 bs, bw, bx;
   int                 state;

   switch (ct->orientation)
     {
     default:
	if (ct->h < 2 * ct->arrow_thickness + ct->knob_length)
	   arrow_mode = 3;	/* No arrows */

	ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_VERTICAL", 0);
	pad = ImageclassGetPadding(ic);
	if (arrow_mode < 3)
	   bs = ct->h - (ct->arrow_thickness * 2);
	else
	   bs = ct->h;
	if (ic)
	   bs -= pad->top + pad->bottom;
	bw = (ct->h * bs) / ct->max;
	if (bs < 1)
	   bs = 1;
	if (bw > bs)
	   bw = bs;
	if (bw < 1)
	   bw = 1;
	bx = ((ct->pos * bs) / ct->max);
	if (ic)
	   bx += pad->top;
	if ((ct->scrollbar_hide) && (bw == bs))
	   goto do_hide_sb;

	EMapWindow(ct->scroll_win);
	if (arrow_mode < 3)
	  {
	     EMapWindow(ct->arrow1_win);
	     EMapWindow(ct->arrow2_win);
	  }
	else
	  {
	     EUnmapWindow(ct->arrow1_win);
	     EUnmapWindow(ct->arrow2_win);
	  }

	/* fix this area */
	if (ct->scrollbar_side == 1)
	   /* right */
	  {
	     /* start */
	     if (arrow_mode == 0)
	       {
		  EMoveResizeWindow(ct->arrow1_win,
				    ct->w - ct->scroll_thickness, 0,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->scroll_thickness,
				    ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->w - ct->scroll_thickness,
				    ct->arrow_thickness * 2,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* both ends */
	     else if (arrow_mode == 1)
	       {
		  EMoveResizeWindow(ct->arrow1_win,
				    ct->w - ct->scroll_thickness, 0,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->scroll_thickness,
				    ct->h - ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->w - ct->scroll_thickness,
				    ct->arrow_thickness,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* end */
	     else if (arrow_mode == 2)
	       {
		  EMoveResizeWindow(ct->arrow1_win,
				    ct->w - ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2),
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->scroll_thickness,
				    ct->h - ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->w - ct->scroll_thickness, 0,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* no arrows */
	     else
	       {
		  EMoveResizeWindow(ct->scroll_win,
				    ct->w - ct->scroll_thickness, 0,
				    ct->scroll_thickness, ct->h);
	       }
	  }
	else
	   /* left */
	  {
	     /* start */
	     if (arrow_mode == 0)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0, 0,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win, 0,
				    ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win, 0,
				    ct->arrow_thickness * 2,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* both ends */
	     else if (arrow_mode == 1)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0, 0,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win, 0,
				    ct->h - ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win, 0,
				    ct->arrow_thickness,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* end */
	     else if (arrow_mode == 2)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0,
				    ct->h - (ct->arrow_thickness * 2),
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->arrow2_win, 0,
				    ct->h - ct->arrow_thickness,
				    ct->scroll_thickness, ct->arrow_thickness);
		  EMoveResizeWindow(ct->scroll_win, 0, 0,
				    ct->scroll_thickness,
				    ct->h - (ct->arrow_thickness * 2));
	       }
	     /* no arrows */
	     else
	       {
		  EMoveResizeWindow(ct->scroll_win, 0, 0,
				    ct->scroll_thickness, ct->h);
	       }
	  }

	ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_VERTICAL", 0);
	if (ic)
	   ImageclassApply(ic, ct->scroll_win, -1, -1, 0, 0, STATE_NORMAL,
			   ST_ICONBOX);

	EMoveResizeWindow(ct->scrollbar_win,
			  (ct->scroll_thickness - ct->bar_thickness) / 2, bx,
			  ct->bar_thickness, bw);

	ic = ImageclassFind("ICONBOX_SCROLLBAR_KNOB_VERTICAL", 0);
	if (ic)
	  {
	     state = STATE_NORMAL;
	     if (ct->scrollbar_hilited)
		state = STATE_HILITED;
	     if (ct->scrollbar_clicked)
		state = STATE_CLICKED;
	     ImageclassApply(ic, ct->scrollbar_win, -1, -1, 0, 0, state,
			     ST_ICONBOX);
	  }

	ic = ImageclassFind("ICONBOX_SCROLLKNOB_VERTICAL", 0);
	if ((ic) && (bw > ct->knob_length))
	  {
	     EMapWindow(ct->scrollbarknob_win);
	     EMoveResizeWindow(ct->scrollbarknob_win, 0,
			       (bw - ct->knob_length) / 2, ct->bar_thickness,
			       ct->knob_length);

	     state = STATE_NORMAL;
	     if (ct->scrollbar_hilited)
		state = STATE_HILITED;
	     if (ct->scrollbar_clicked)
		state = STATE_CLICKED;
	     ImageclassApply(ic, ct->scrollbarknob_win, -1, -1, 0, 0, state,
			     ST_ICONBOX);
	  }
	else
	  {
	     EUnmapWindow(ct->scrollbarknob_win);
	  }

	if (arrow_mode < 3)
	  {
	     ic = ImageclassFind("ICONBOX_ARROW_UP", 0);
	     if (ic)
	       {
		  state = STATE_NORMAL;
		  if (ct->arrow1_hilited)
		     state = STATE_HILITED;
		  if (ct->arrow1_clicked)
		     state = STATE_CLICKED;
		  ImageclassApply(ic, ct->arrow1_win, -1, -1, 0, 0, state,
				  ST_ICONBOX);
	       }

	     ic = ImageclassFind("ICONBOX_ARROW_DOWN", 0);
	     if (ic)
	       {
		  state = STATE_NORMAL;
		  if (ct->arrow2_hilited)
		     state = STATE_HILITED;
		  if (ct->arrow2_clicked)
		     state = STATE_CLICKED;
		  ImageclassApply(ic, ct->arrow2_win, -1, -1, 0, 0, state,
				  ST_ICONBOX);
	       }
	  }
	break;

     case 0:
	if (ct->w < 2 * ct->arrow_thickness + ct->knob_length)
	   arrow_mode = 3;	/* No arrows */

	ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_HORIZONTAL", 0);
	pad = ImageclassGetPadding(ic);
	if (arrow_mode < 3)
	   bs = ct->w - (ct->arrow_thickness * 2);
	else
	   bs = ct->w;
	if (ic)
	   bs -= pad->left + pad->right;
	bw = (ct->w * bs) / ct->max;
	if (bs < 1)
	   bs = 1;
	if (bw > bs)
	   bw = bs;
	if (bw < 1)
	   bw = 1;
	bx = ((ct->pos * bs) / ct->max);
	if (ic)
	   bx += pad->left;
	if ((ct->scrollbar_hide) && (bw == bs))
	   goto do_hide_sb;

	EMapWindow(ct->scroll_win);
	if (arrow_mode < 3)
	  {
	     EMapWindow(ct->arrow1_win);
	     EMapWindow(ct->arrow2_win);
	  }
	else
	  {
	     EUnmapWindow(ct->arrow1_win);
	     EUnmapWindow(ct->arrow2_win);
	  }

	if (ct->scrollbar_side == 1)
	   /* bottom */
	  {
	     /* start */
	     if (arrow_mode == 0)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0,
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->arrow_thickness,
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->arrow_thickness * 2,
				    ct->h - ct->scroll_thickness,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* both ends */
	     else if (arrow_mode == 1)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0,
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->arrow_thickness,
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->arrow_thickness,
				    ct->h - ct->scroll_thickness,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* end */
	     else if (arrow_mode == 2)
	       {
		  EMoveResizeWindow(ct->arrow1_win,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->arrow_thickness,
				    ct->h - ct->scroll_thickness,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win, 0,
				    ct->h - ct->scroll_thickness,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* no arrows */
	     else
	       {
		  EMoveResizeWindow(ct->scroll_win, 0,
				    ct->h - ct->scroll_thickness, ct->w,
				    ct->scroll_thickness);
	       }
	  }
	else
	   /* top */
	  {
	     /* start */
	     if (arrow_mode == 0)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0, 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->arrow_thickness, 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->arrow_thickness * 2, 0,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* both ends */
	     else if (arrow_mode == 1)
	       {
		  EMoveResizeWindow(ct->arrow1_win, 0, 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->arrow_thickness, 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win,
				    ct->arrow_thickness, 0,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* end */
	     else if (arrow_mode == 2)
	       {
		  EMoveResizeWindow(ct->arrow1_win,
				    ct->w - (ct->arrow_thickness * 2), 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->arrow2_win,
				    ct->w - ct->arrow_thickness, 0,
				    ct->arrow_thickness, ct->scroll_thickness);
		  EMoveResizeWindow(ct->scroll_win, 0, 0,
				    ct->w - (ct->arrow_thickness * 2),
				    ct->scroll_thickness);
	       }
	     /* no arrows */
	     else
	       {
		  EMoveResizeWindow(ct->scroll_win, 0, 0, ct->w,
				    ct->scroll_thickness);
	       }
	  }

	EMoveResizeWindow(ct->scrollbar_win, bx,
			  (ct->scroll_thickness - ct->bar_thickness) / 2, bw,
			  ct->bar_thickness);

	ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_HORIZONTAL", 0);
	if (ic)
	   ImageclassApply(ic, ct->scroll_win, -1, -1, 0, 0, STATE_NORMAL,
			   ST_ICONBOX);

	ic = ImageclassFind("ICONBOX_SCROLLBAR_KNOB_HORIZONTAL", 0);
	if (ic)
	  {
	     state = STATE_NORMAL;
	     if (ct->scrollbar_hilited)
		state = STATE_HILITED;
	     if (ct->scrollbar_clicked)
		state = STATE_CLICKED;
	     ImageclassApply(ic, ct->scrollbar_win, -1, -1, 0, 0, state,
			     ST_ICONBOX);
	  }

	ic = ImageclassFind("ICONBOX_SCROLLKNOB_HORIZONTAL", 0);
	if ((ic) && (bw > ct->knob_length))
	  {
	     EMapWindow(ct->scrollbarknob_win);
	     EMoveResizeWindow(ct->scrollbarknob_win,
			       (bw - ct->knob_length) / 2, 0, ct->knob_length,
			       ct->bar_thickness);

	     state = STATE_NORMAL;
	     if (ct->scrollbar_hilited)
		state = STATE_HILITED;
	     if (ct->scrollbar_clicked)
		state = STATE_CLICKED;
	     ImageclassApply(ic, ct->scrollbarknob_win, -1, -1, 0, 0, state,
			     ST_ICONBOX);
	  }
	else
	  {
	     EUnmapWindow(ct->scrollbarknob_win);
	  }

	if (arrow_mode < 3)
	  {
	     ic = ImageclassFind("ICONBOX_ARROW_LEFT", 0);
	     if (ic)
	       {
		  state = STATE_NORMAL;
		  if (ct->arrow1_hilited)
		     state = STATE_HILITED;
		  if (ct->arrow1_clicked)
		     state = STATE_CLICKED;
		  ImageclassApply(ic, ct->arrow1_win, -1, -1, 0, 0, state,
				  ST_ICONBOX);
	       }

	     ic = ImageclassFind("ICONBOX_ARROW_RIGHT", 0);
	     if (ic)
	       {
		  state = STATE_NORMAL;
		  if (ct->arrow2_hilited)
		     state = STATE_HILITED;
		  if (ct->arrow2_clicked)
		     state = STATE_CLICKED;
		  ImageclassApply(ic, ct->arrow2_win, -1, -1, 0, 0, state,
				  ST_ICONBOX);
	       }
	  }
	break;

      do_hide_sb:
	EUnmapWindow(ct->scroll_win);
	EUnmapWindow(ct->arrow1_win);
	EUnmapWindow(ct->arrow2_win);
	break;
     }
}

static void
ContainerFixPos(Container * ct)
{
   int                 v;

   if (ct->orientation)
      v = ct->max - ct->h;
   else
      v = ct->max - ct->w;

   if (ct->pos > v)
      ct->pos = v;
   if (ct->pos < 0)
      ct->pos = 0;
}

static void
ContainerLayout(Container * ct, int *px, int *py, int *pw, int *ph)
{
   int                 x, y, w, h;
   EWin               *ewin = ct->ewin;

   x = *px;
   y = *py;
   w = *pw;
   h = *ph;
   ICCCM_SizeMatch(ewin, w, h, &w, &h);

   ContainerLayoutImageWin(ct);

   if (ct->auto_resize)
     {
	int                 add = 0;
	int                 bl, br, bt, bb;

	EwinBorderGetSize(ct->ewin, &bl, &br, &bt, &bb);

	if (ct->orientation)
	  {
	     add = ct->max;
	     if (ct->ewin->border)
	       {
		  if ((bt + bb + add) > VRoot.h)
		     add = VRoot.h - (bt + bb);
	       }
	     y += (((ct->ewin->client.h - add) * ct->auto_resize_anchor) >> 10);
	     h = add;
	     if (ct->ewin->border)
	       {
		  if ((EoGetY(ct->ewin) + bt + bb + add) > VRoot.h)
		     y = VRoot.h - (bt + bb + add);
	       }
	  }
	else
	  {
	     add = ct->max;
	     if (ct->ewin->border)
	       {
		  if ((bl + br + add) > VRoot.w)
		     add = VRoot.w - (bl + br);
	       }
	     x += (((ct->ewin->client.w - add) * ct->auto_resize_anchor) >> 10);
	     w = add;
	     if (ct->ewin->border)
	       {
		  if ((EoGetX(ct->ewin) + bl + br + add) > VRoot.w)
		     x = VRoot.w - (bl + br + add);
	       }
	  }
     }

   ContainerFixPos(ct);

   *px = x;
   *py = y;
   *pw = w;
   *ph = h;
}

static void
ContainerDraw(Container * ct)
{
   int                 i, w, h;
   ImageClass         *ib_ic_cover;
   int                 ib_xlt, ib_ylt, ib_ww, ib_hh;
   int                 ib_x0, ib_y0, ib_w0, ib_h0;
   EImage             *im;
   int                 ww, hh;
   Pixmap              pmap, mask;

   if (!ct->ic_box)
      ContainerLayoutImageWin(ct);

   w = ct->w;
   h = ct->h;

   ContainerDrawScroll(ct);

   /* Geometry of iconbox window, excluding scrollbar */
   ib_xlt = 0;
   ib_ylt = 0;
   ib_ww = w;
   ib_hh = h;
   if (ct->orientation)
     {
	ib_ic_cover = ImageclassFind("ICONBOX_COVER_VERTICAL", 0);
	if (ct->scrollbar_side == 0)
	   ib_xlt = ct->scroll_thickness;
	ib_ww -= ct->scroll_thickness;

	/* Geometry of icon window (including invisible parts) */
	ib_x0 = ib_xlt;
	ib_y0 = ib_ylt - ct->pos;
	ib_w0 = ib_ww;
	ib_h0 = ib_hh;
	if (ib_h0 < ct->max)
	   ib_h0 = ct->max;
     }
   else
     {
	ib_ic_cover = ImageclassFind("ICONBOX_COVER_HORIZONTAL", 0);
	if (ct->scrollbar_side == 0)
	   ib_ylt = ct->scroll_thickness;
	ib_hh -= ct->scroll_thickness;

	/* Geometry of icon window (including invisible parts) */
	ib_x0 = ib_xlt - ct->pos;
	ib_y0 = ib_ylt;
	ib_w0 = ib_ww;
	if (ib_w0 < ct->max)
	   ib_w0 = ct->max;
	ib_h0 = ib_hh;
     }

   EMoveResizeWindow(ct->icon_win, ib_x0, ib_y0, ib_w0, ib_h0);

   if (ib_ic_cover && !ct->cover_hide)
     {
	EMoveResizeWindow(ct->cover_win, ib_xlt, ib_ylt, ib_ww, ib_hh);
	EMapWindow(ct->cover_win);
	ImageclassApply(ib_ic_cover, ct->cover_win, -1, -1, 0, 0, STATE_NORMAL,
			ST_ICONBOX);
     }
   else
     {
	EMoveResizeWindow(ct->cover_win, -30000, -30000, 2, 2);
	EUnmapWindow(ct->cover_win);
     }

   if (ct->nobg && ct->num_objs == 0)
     {
	im = NULL;
     }
   else if (ct->ic_box &&
	    (!ct->nobg || (ct->type == IB_TYPE_SYSTRAY && !ct->draw_icon_base)))
     {
	/* Start out with iconbox image class image */
	im = ImageclassGetImageBlended(ct->ic_box, ct->icon_win, ib_w0, ib_h0,
				       0, 0, STATE_NORMAL, ST_ICONBOX);
     }
   else
     {
	/* Start out with blank image */
	im = EImageCreate(ib_w0, ib_h0);
	EImageSetHasAlpha(im, 1);
	EImageFill(im, 0, 0, ib_w0, ib_h0, 0, 0, 0, 0);
     }

   for (i = 0; i < ct->num_objs; i++)
     {
	ContainerObject    *cto;

	cto = &ct->objs[i];

	if (ct->draw_icon_base && ct->im_item_base)
	  {
	     EImageGetSize(ct->im_item_base, &ww, &hh);
	     EImageBlend(im, ct->im_item_base, 1, 0, 0, ww, hh,
			 cto->xo, cto->yo, cto->wo, cto->ho, 1, 0);
	  }

	ct->ops->ObjPlace(ct, cto, im);
     }

   if (im)
     {
	EMapWindow(ct->icon_win);
	EImageRenderPixmaps(im, ct->icon_win, &pmap, &mask, 0, 0);
	ESetWindowBackgroundPixmap(ct->icon_win, pmap);
	EShapeCombineMask(ct->icon_win, ShapeBounding, 0, 0, mask, ShapeSet);
	EImagePixmapFree(pmap);
	EImageFree(im);
	EClearWindow(ct->icon_win);

	if (ct->type == IB_TYPE_SYSTRAY && ct->nobg && !ct->draw_icon_base)
	   EShapePropagate(ct->icon_win);
     }
   else
     {
	/* Transparent and no objects */
	EUnmapWindow(ct->icon_win);
     }
   EShapePropagate(ct->win);
   EwinUpdateShapeInfo(ct->ewin);
   ct->ewin->update.shape = 1;
   EwinPropagateShapes(ct->ewin);
}

void
ContainerRedraw(Container * ct)
{
   EWin               *ewin = ct->ewin;

   ct->do_update = 1;
   EwinResize(ct->ewin, ewin->client.w, ewin->client.h);
}

static int
ContainerScroll(Container * ct, int dir)
{
   int                 ppos;

   ppos = ct->pos;
   ct->pos += dir;
   ContainerFixPos(ct);
   if (ct->pos == ppos)
      return 0;

   ContainerDraw(ct);
   return 1;
}

static void
ContainerShowMenu(Container * ct, int x __UNUSED__, int y __UNUSED__)
{
   static Menu        *p_menu = NULL;
   MenuItem           *mi;
   char                s[1024];

   if (p_menu)
      MenuDestroy(p_menu);

   p_menu = MenuCreate("__CT_MENU", ct->menu_title, NULL, NULL);

   Esnprintf(s, sizeof(s), "ibox cfg %s", ct->name);
   mi = MenuItemCreate(_("Settings..."), NULL, s, NULL);
   MenuAddItem(p_menu, mi);

   Esnprintf(s, sizeof(s), "wop %#lx cl", WinGetXwin(ct->win));
   mi = MenuItemCreate(_("Close"), NULL, s, NULL);
   MenuAddItem(p_menu, mi);

   if (ct->type == IB_TYPE_ICONBOX)
     {
	mi = MenuItemCreate(_("Create New Iconbox"), NULL, "ibox new", NULL);
	MenuAddItem(p_menu, mi);
     }

   EFunc(NULL, "menus show __CT_MENU");
}

static void
ContainersShow(void)
{
   Container          *ct;

   if (ecore_list_nodes(container_list) > 0)
     {
	ECORE_LIST_FOR_EACH(container_list, ct) ContainerShow(ct);
     }
   else if (Conf.startup.firsttime)
     {
	ct = ContainerCreate("_IB_0");
	ContainerShow(ct);
	ContainersConfigSave();
     }
}

static void
ContainersDestroy(void)
{
   Container          *ct;

   ECORE_LIST_FOR_EACH(container_list, ct) ContainerDestroy(ct, 1);
}

static void
ContainerEventScrollWin(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;
   int                 x, y, w, h;

   switch (ev->type)
     {
     case ButtonPress:
	if (ev->xbutton.button == 1)
	   ct->scrollbox_clicked = 1;
	else if (ev->xbutton.button == 3)
	   ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	break;

     case ButtonRelease:
	if (!ct->scrollbox_clicked)
	   break;
	ct->scrollbox_clicked = 0;
	EGetGeometry(ct->scrollbar_win, NULL, &x, &y, &w, &h, NULL, NULL);
	if (ct->orientation)
	  {
	     if (ev->xbutton.y < y)
		ContainerScroll(ct, -8);
	     else if (ev->xbutton.y > (y + h))
		ContainerScroll(ct, 8);
	  }
	else
	  {
	     if (ev->xbutton.x < x)
		ContainerScroll(ct, -8);
	     else if (ev->xbutton.x > (x + w))
		ContainerScroll(ct, 8);
	  }
	break;
     }
}

static void
ContainerEventScrollbarWin(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;
   static int          px, py, pos0;
   int                 bs, dp;
   ImageClass         *ic;
   EImageBorder       *pad;

   switch (ev->type)
     {
     case ButtonPress:
	if (ev->xbutton.button == 1)
	  {
	     px = ev->xbutton.x_root;
	     py = ev->xbutton.y_root;
	     pos0 = ct->pos;
	     ct->scrollbar_clicked = 1;
	  }
	else if (ev->xbutton.button == 3)
	   ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	break;

     case ButtonRelease:
	if (ct->scrollbar_clicked)
	   ct->scrollbar_clicked = 0;
	break;

     case EnterNotify:
	ct->scrollbar_hilited = 1;
	break;

     case LeaveNotify:
	ct->scrollbar_hilited = 0;
	break;

     case MotionNotify:
	if (!ct->scrollbar_clicked)
	   break;

	if (ct->orientation)
	  {
	     ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_VERTICAL", 0);
	     pad = ImageclassGetPadding(ic);
	     bs = ct->h - (ct->arrow_thickness * 2);
	     if (ic)
		bs -= pad->top + pad->bottom;
	     if (bs < 1)
		bs = 1;
	     dp = ev->xmotion.y_root - py;
	  }
	else
	  {
	     ic = ImageclassFind("ICONBOX_SCROLLBAR_BASE_HORIZONTAL", 0);
	     pad = ImageclassGetPadding(ic);
	     bs = ct->w - (ct->arrow_thickness * 2);
	     if (ic)
		bs -= pad->left + pad->right;
	     if (bs < 1)
		bs = 1;
	     dp = ev->xmotion.x_root - px;
	  }
	dp = pos0 + (dp * ct->max) / bs - ct->pos;
	if (dp)
	   ContainerScroll(ct, dp);
	return;
     }
   ContainerDrawScroll(ct);
}

static void
ContainerEventCoverWin(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;

   switch (ev->type)
     {
     case ButtonPress:
	ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	break;
     case ButtonRelease:
	break;
     }
}

static void
ContainerEventArrow1Win(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;

   switch (ev->type)
     {
     case ButtonPress:
	if (ev->xbutton.button == 1)
	   ct->arrow1_clicked = 1;
	else if (ev->xbutton.button == 3)
	   ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	break;

     case ButtonRelease:
	if (!ct->arrow1_clicked)
	   break;
	ct->arrow1_clicked = 0;
	if (ContainerScroll(ct, -8))
	   return;
	break;

     case EnterNotify:
	ct->arrow1_hilited = 1;
	break;

     case LeaveNotify:
	ct->arrow1_hilited = 0;
	break;
     }
   ContainerDrawScroll(ct);
}

static void
ContainerEventArrow2Win(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;

   switch (ev->type)
     {
     case ButtonPress:
	if (ev->xbutton.button == 1)
	   ct->arrow2_clicked = 1;
	else if (ev->xbutton.button == 3)
	   ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	break;

     case ButtonRelease:
	if (!ct->arrow2_clicked)
	   break;
	ct->arrow2_clicked = 0;
	if (ContainerScroll(ct, 8))
	   return;
	break;

     case EnterNotify:
	ct->arrow2_hilited = 1;
	break;

     case LeaveNotify:
	ct->arrow2_hilited = 0;
	break;
     }
   ContainerDrawScroll(ct);
}

static void
ContainerEventIconWin(Win win __UNUSED__, XEvent * ev, void *prm)
{
   Container          *ct = (Container *) prm;

   switch (ev->type)
     {
     case ButtonPress:
	if (ev->xbutton.button != 3)
	   break;
	ContainerShowMenu(ct, ev->xbutton.x, ev->xbutton.y);
	return;
     }

   if (ct->ops->Event)
      ct->ops->Event(ct, ev);
}

/*
 * Configuration dialog
 */
static char        *tmp_ib_name = NULL;
static char         tmp_ib_nobg;
static char         tmp_ib_shownames;
static int          tmp_ib_vert;
static int          tmp_ib_side;
static int          tmp_ib_arrows;
static int          tmp_ib_iconsize;
static int          tmp_ib_mode;
static char         tmp_ib_auto_resize;
static char         tmp_ib_draw_icon_base;
static char         tmp_ib_scrollbar_hide;
static char         tmp_ib_cover_hide;
static int          tmp_ib_autoresize_anchor;
static char         tmp_ib_anim_mode;

static void
CB_ConfigureContainer(Dialog * d __UNUSED__, int val, void *data __UNUSED__)
{
   if (val < 2)
     {
	Container          *ct;

	if (!tmp_ib_name)
	   return;
	ct = ContainerFind(tmp_ib_name);
	if (!ct)
	   return;

	ct->nobg = tmp_ib_nobg;
	ct->shownames = tmp_ib_shownames;
	ct->orientation = tmp_ib_vert;
	ct->scrollbar_side = tmp_ib_side;
	ct->arrow_side = tmp_ib_arrows;
	ct->iconsize = tmp_ib_iconsize;
	ct->icon_mode = tmp_ib_mode;
	ct->auto_resize = tmp_ib_auto_resize;
	ct->draw_icon_base = tmp_ib_draw_icon_base;
	ct->scrollbar_hide = tmp_ib_scrollbar_hide;
	ct->cover_hide = tmp_ib_cover_hide;
	ct->auto_resize_anchor = tmp_ib_autoresize_anchor;
	ct->anim_mode = tmp_ib_anim_mode;

	ContainerReconfigure(ct);
	ContainerRedraw(ct);
	ContainersConfigSave();
     }
}

static void
CB_IconSizeSlider(Dialog * d, int val __UNUSED__, void *data)
{
   DItem              *di;
   char                s[256];

   di = data;
   Esnprintf(s, sizeof(s), _("Icon size: %2d"), tmp_ib_iconsize);
   DialogItemSetText(di, s);
   DialogDrawItems(d, di, 0, 0, 99999, 99999);
}

static void
_DlgFillContainer(Dialog * d, DItem * table, void *data)
{
   Container          *ct = data;
   DItem              *di, *table2;
   DItem              *radio1, *radio2, *radio3, *radio4, *label;
   char                s[256];

   if (!ct)
      return;

   tmp_ib_nobg = ct->nobg;
   tmp_ib_shownames = ct->shownames;
   tmp_ib_vert = ct->orientation;
   tmp_ib_side = ct->scrollbar_side;
   tmp_ib_arrows = ct->arrow_side;
   tmp_ib_iconsize = ct->iconsize;
   tmp_ib_mode = ct->icon_mode;
   tmp_ib_auto_resize = ct->auto_resize;
   tmp_ib_draw_icon_base = ct->draw_icon_base;
   tmp_ib_scrollbar_hide = ct->scrollbar_hide;
   tmp_ib_cover_hide = ct->cover_hide;
   tmp_ib_autoresize_anchor = ct->auto_resize_anchor;
   tmp_ib_anim_mode = ct->anim_mode;
   if (tmp_ib_name)
      Efree(tmp_ib_name);
   tmp_ib_name = Estrdup(ct->name);

   DialogSetTitle(d, ct->dlg_title);

   DialogItemTableSetOptions(table, 1, 0, 0, 0);

   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Transparent background"));
   DialogItemCheckButtonSetPtr(di, &tmp_ib_nobg);

   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Hide inner border"));
   DialogItemCheckButtonSetPtr(di, &tmp_ib_cover_hide);

   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Draw base image behind Icons"));
   DialogItemCheckButtonSetPtr(di, &tmp_ib_draw_icon_base);

   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Hide scrollbar when not needed"));
   DialogItemCheckButtonSetPtr(di, &tmp_ib_scrollbar_hide);

   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Automatically resize to fit Icons"));
   DialogItemCheckButtonSetPtr(di, &tmp_ib_auto_resize);

   di = DialogAddItem(table, DITEM_TEXT);
   DialogItemSetFill(di, 0, 0);
   DialogItemSetAlign(di, 0, 512);
   DialogItemSetText(di,
		     _("Alignment of anchoring when automatically resizing:"));

   di = DialogAddItem(table, DITEM_SLIDER);
   DialogItemSliderSetBounds(di, 0, 1024);
   DialogItemSliderSetUnits(di, 1);
   DialogItemSliderSetJump(di, 8);
   DialogItemSliderSetValPtr(di, &tmp_ib_autoresize_anchor);

   di = DialogAddItem(table, DITEM_SEPARATOR);

   label = di = DialogAddItem(table, DITEM_TEXT);
   DialogItemSetFill(di, 0, 0);
   DialogItemSetAlign(di, 0, 512);
   Esnprintf(s, sizeof(s), _("Icon size: %2d"), tmp_ib_iconsize);
   DialogItemSetText(di, s);

   di = DialogAddItem(table, DITEM_SLIDER);
   DialogItemSliderSetBounds(di, 4, 128);
   DialogItemSliderSetUnits(di, 1);
   DialogItemSliderSetJump(di, 8);
   DialogItemSliderSetValPtr(di, &tmp_ib_iconsize);
   DialogItemSetCallback(di, CB_IconSizeSlider, 0, label);

   di = DialogAddItem(table, DITEM_SEPARATOR);

   table2 = DialogAddItem(table, DITEM_TABLE);
   DialogItemTableSetOptions(table2, 3, 0, 0, 0);

   di = DialogAddItem(table2, DITEM_TEXT);
   DialogItemSetFill(di, 0, 0);
   DialogItemSetAlign(di, 0, 512);
   DialogItemSetText(di, _("Orientation:"));

   di = DialogAddItem(table2, DITEM_TEXT);
   DialogItemSetFill(di, 0, 0);
   DialogItemSetAlign(di, 0, 512);
   DialogItemSetText(di, _("Scrollbar side:"));

   di = DialogAddItem(table2, DITEM_TEXT);
   DialogItemSetFill(di, 0, 0);
   DialogItemSetAlign(di, 0, 512);
   DialogItemSetText(di, _("Scrollbar arrows:"));

   radio1 = di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Horizontal"));
   DialogItemRadioButtonSetFirst(di, radio1);
   DialogItemRadioButtonGroupSetVal(di, 0);

   radio2 = di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Left / Top"));
   DialogItemRadioButtonSetFirst(di, radio2);
   DialogItemRadioButtonGroupSetVal(di, 0);

   radio3 = di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Start"));
   DialogItemRadioButtonSetFirst(di, radio3);
   DialogItemRadioButtonGroupSetVal(di, 0);

   di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Vertical"));
   DialogItemRadioButtonSetFirst(di, radio1);
   DialogItemRadioButtonGroupSetVal(di, 1);
   DialogItemRadioButtonGroupSetValPtr(radio1, &tmp_ib_vert);

   di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Right / Bottom"));
   DialogItemRadioButtonSetFirst(di, radio2);
   DialogItemRadioButtonGroupSetVal(di, 1);
   DialogItemRadioButtonGroupSetValPtr(radio2, &tmp_ib_side);

   di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("Both ends"));
   DialogItemRadioButtonSetFirst(di, radio3);
   DialogItemRadioButtonGroupSetVal(di, 1);

   di = DialogAddItem(table2, DITEM_NONE);
   di = DialogAddItem(table2, DITEM_NONE);

   di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("End"));
   DialogItemRadioButtonSetFirst(di, radio3);
   DialogItemRadioButtonGroupSetVal(di, 2);

   di = DialogAddItem(table2, DITEM_NONE);
   di = DialogAddItem(table2, DITEM_NONE);

   di = DialogAddItem(table2, DITEM_RADIOBUTTON);
   DialogItemSetText(di, _("None"));
   DialogItemRadioButtonSetFirst(di, radio3);
   DialogItemRadioButtonGroupSetVal(di, 3);
   DialogItemRadioButtonGroupSetValPtr(radio3, &tmp_ib_arrows);

   di = DialogAddItem(table, DITEM_SEPARATOR);

   if (ct->type == IB_TYPE_ICONBOX)
     {
	di = DialogAddItem(table, DITEM_CHECKBUTTON);
	DialogItemSetText(di, _("Show icon names"));
	DialogItemCheckButtonSetPtr(di, &tmp_ib_shownames);

	di = DialogAddItem(table, DITEM_CHECKBUTTON);
	DialogItemSetText(di, _("Animate when iconifying to this Iconbox"));
	DialogItemCheckButtonSetPtr(di, &tmp_ib_anim_mode);

	di = DialogAddItem(table, DITEM_SEPARATOR);

	di = DialogAddItem(table, DITEM_TEXT);
	DialogItemSetFill(di, 0, 0);
	DialogItemSetAlign(di, 0, 512);
	DialogItemSetText(di,
			  _
			  ("Icon image display policy (if one operation fails, try the next):"));

	radio4 = di = DialogAddItem(table, DITEM_RADIOBUTTON);
	DialogItemSetText(di,
			  _
			  ("Snapshot Windows, Use application icon, Use Enlightenment Icon"));
	DialogItemRadioButtonSetFirst(di, radio4);
	DialogItemRadioButtonGroupSetVal(di, 0);

	di = DialogAddItem(table, DITEM_RADIOBUTTON);
	DialogItemSetText(di,
			  _
			  ("Use application icon, Use Enlightenment Icon, Snapshot Window"));
	DialogItemRadioButtonSetFirst(di, radio4);
	DialogItemRadioButtonGroupSetVal(di, 1);

	di = DialogAddItem(table, DITEM_RADIOBUTTON);
	DialogItemSetText(di, _("Use Enlightenment Icon, Snapshot Window"));
	DialogItemRadioButtonSetFirst(di, radio4);
	DialogItemRadioButtonGroupSetVal(di, 2);
	DialogItemRadioButtonGroupSetValPtr(radio4, &tmp_ib_mode);
     }
}

static const DialogDef DlgContainer = {
   "CONFIGURE_ICONBOX",
   NULL,
   NULL,
   "SOUND_SETTINGS_ICONBOX",
   "pix/iconbox.png",
   N_("Enlightenment Iconbox\n" "Settings Dialog\n"),
   _DlgFillContainer,
   DLG_OAC, CB_ConfigureContainer,
};

/*
 * Configuration load/save
 */
#include "conf.h"

static void
ContainersConfigLoad(void)
{
   int                 err = 0;
   FILE               *fs;
   char                s[FILEPATH_LEN_MAX];
   char                s2[FILEPATH_LEN_MAX];
   int                 i1, i2;
   int                 fields;
   Container          *ct;

   Esnprintf(s, sizeof(s), "%s.ibox", EGetSavePrefix());
   fs = fopen(s, "r");
   if (!fs)
      return;

   ct = NULL;
   while (fgets(s, sizeof(s), fs))
     {
	s2[0] = 0;
	i1 = CONFIG_INVALID;
	fields = sscanf(s, "%i %4000s", &i1, s2);

	if (fields < 1)
	   i1 = CONFIG_INVALID;
	else if (i1 == CONFIG_CLOSE)
	  {
	     if (fields != 1)
		Alert(_("CONFIG: ignoring extra data in \"%s\"\n"), s);
	  }

	switch (i1)
	  {
	  case CONFIG_IBOX:
	     err = -1;
	     i2 = atoi(s2);
	     if (i2 != CONFIG_OPEN)
		goto done;
	     break;
	  case CONFIG_CLOSE:
	     ct = NULL;
	     err = 0;
	     break;

	  case CONFIG_CLASSNAME:	/* __NAME %s */
	     ct = ContainerFind(s2);
	     if (ct)
		ContainerDestroy(ct, 0);
	     ct = ContainerCreate(s2);
	     break;
	  case TEXT_ORIENTATION:	/* __ORIENTATION [ __HORIZONTAL | __VERTICAL ] */
	     if (ct)
		ct->orientation = (char)atoi(s2);
	     break;
	  case CONFIG_TRANSPARENCY:	/* __TRANSPARENCY [ __ON | __OFF ] */
	     if (ct)
		ct->nobg = (char)atoi(s2);
	     break;
	  case CONFIG_SHOW_NAMES:	/* __SHOW_NAMES [ __ON | __OFF ] */
	     if (ct)
		ct->shownames = (char)atoi(s2);
	     break;
	  case CONFIG_ICON_SIZE:	/* __ICON_SIZE %i */
	     if (ct)
		ct->iconsize = (int)atoi(s2);
	     break;
	  case CONFIG_ICON_MODE:	/* __ICON_MODE [ 0 | 1 | 2 | 3 | 4 ] */
	     if (ct)
		ct->icon_mode = (int)atoi(s2);
	     break;
	  case CONFIG_SCROLLBAR_SIDE:	/* __SCROLLBAR_SIDE [ __BAR_LEFT/__BAR_TOP | __BAR_RIGHT/__BAR_BOTTOM ] */
	     if (ct)
		ct->scrollbar_side = (char)atoi(s2);
	     break;
	  case CONFIG_SCROLLBAR_ARROWS:	/* __SCROLLBAR_ARROWS [ __START | __BOTH | __FINISH | __NEITHER ] */
	     if (ct)
		ct->arrow_side = (char)atoi(s2);
	     break;
	  case CONFIG_AUTOMATIC_RESIZE:	/* __AUTOMATIC_RESIZE [ __ON | __OFF ] */
	     if (ct)
		ct->auto_resize = (char)atoi(s2);
	     break;
	  case CONFIG_SHOW_ICON_BASE:	/* __SHOW_ICON_BASE [ __ON | __OFF ] */
	     if (ct)
		ct->draw_icon_base = (char)atoi(s2);
	     break;
	  case CONFIG_SCROLLBAR_AUTOHIDE:	/* __SCROLLBAR_AUTOHIDE [ __ON | __OFF ] */
	     if (ct)
		ct->scrollbar_hide = (char)atoi(s2);
	     break;
	  case CONFIG_COVER_HIDE:	/* __COVER_HIDE [ __ON | __OFF ] */
	     if (ct)
		ct->cover_hide = (char)atoi(s2);
	     break;
	  case CONFIG_RESIZE_ANCHOR:	/* __RESIZE_ANCHOR 0-1024 */
	     if (ct)
		ct->auto_resize_anchor = atoi(s2);
	     break;
	  case CONFIG_IB_ANIMATE:	/* __ICONBOX_ANIMATE [ 0 | 1 | 2 ] */
	     if (ct)
		ct->anim_mode = atoi(s2);
	     break;
	  default:
	     Eprintf("Warning: Iconbox configuration, ignoring: %s\n", s);
	     break;
	  }
     }
   if (err)
      Eprintf("Error: Iconbox configuration file load problem.\n");

 done:
   fclose(fs);
}

static void
ContainersConfigSave(void)
{
   char                s[FILEPATH_LEN_MAX];
   FILE               *fs;
   Container          *ct;

   Esnprintf(s, sizeof(s), "%s.ibox", EGetSavePrefix());
   fs = fopen(s, "w");
   if (!fs)
      return;

   /* We should check for errors... */
   ECORE_LIST_FOR_EACH(container_list, ct)
   {
      fprintf(fs, "19 999\n");
      fprintf(fs, "100 %s\n", ct->name);
      fprintf(fs, "200 %i\n", ct->orientation);
      fprintf(fs, "2001 %i\n", ct->nobg);
      fprintf(fs, "2002 %i\n", ct->shownames);
      fprintf(fs, "2003 %i\n", ct->iconsize);
      fprintf(fs, "2004 %i\n", ct->icon_mode);
      fprintf(fs, "2005 %i\n", ct->scrollbar_side);
      fprintf(fs, "2006 %i\n", ct->arrow_side);
      fprintf(fs, "2007 %i\n", ct->auto_resize);
      fprintf(fs, "2008 %i\n", ct->draw_icon_base);
      fprintf(fs, "2009 %i\n", ct->scrollbar_hide);
      fprintf(fs, "2010 %i\n", ct->cover_hide);
      fprintf(fs, "2011 %i\n", ct->auto_resize_anchor);
      fprintf(fs, "2012 %i\n", ct->anim_mode);
      fprintf(fs, "1000\n");
   }

   fclose(fs);
}

/*
 * Containers Module
 */

static void
ContainersSighan(int sig, void *prm)
{
   switch (sig)
     {
     case ESIGNAL_CONFIGURE:
	break;
     case ESIGNAL_START:
	ContainersConfigLoad();
	ContainersShow();
	break;
     case ESIGNAL_EXIT:
	ContainersDestroy();
	break;
     }

#if 0				/* FIXME */
   ECORE_LIST_FOR_EACH(container_list, ct)
   {
      if (ct->ops)
	 ct->ops->Signal(ct, sig, prm);
   }
#else
   IconboxOps.Signal(NULL, sig, prm);
#endif
}

static void
ContainersConfigure(const char *params)
{
   Container          *ct;

   if (!params || !params[0])
      params = "DEFAULT";

   ct = ContainerFind(params);
   if (ct)
      DialogShowSimple(&DlgContainer, ct);
}

Container          *
ContainersIterate(ContainerIterator * cti, int type, void *data)
{
   Container          *ct;

   ECORE_LIST_FOR_EACH(container_list, ct)
   {
      if (ct->type != type)
	 continue;
      if (cti(ct, data))
	 return ct;
   }

   return NULL;
}

Container         **
ContainersGetList(int *pnum)
{
   return (Container **) ecore_list_items_get(container_list, pnum);
}

/*
 * IPC functions
 */
static void
ContainerIpc(const char *params, Client * c __UNUSED__)
{
   const char         *p;
   char                cmd[128], prm[128];
   int                 len, num;

   cmd[0] = prm[0] = '\0';
   p = params;
   if (p)
     {
	len = 0;
	sscanf(p, "%100s %100s %n", cmd, prm, &len);
	p += len;
     }

   if (!p || cmd[0] == '?')
     {
	/* List iconboxes */
     }
   else if (!strncmp(cmd, "cfg", 3))
     {
	ContainersConfigure(prm);
     }
   else if (!strncmp(cmd, "new", 3))
     {
	Container          *ct;

	if (!prm[0])
	  {
	     num = ecore_list_nodes(container_list);
	     Esnprintf(prm, sizeof(prm), "_IB_%i", num);
	  }
	ct = ContainerCreate(prm);
	ContainerShow(ct);
	ContainersConfigSave();
     }
}

static const IpcItem ContainersIpcArray[] = {
   {
    ContainerIpc,
    "iconbox", "ibox",
    "Iconbox functions",
    "  iconbox new <name>   Create new iconbox\n"
    "  iconbox cfg          Configure iconboxes\n"}
};
#define N_IPC_FUNCS (sizeof(ContainersIpcArray)/sizeof(IpcItem))

/*
 * Configuration items
 */
static const CfgItem ContainersCfgItems[] = {
   CFG_ITEM_INT(Conf_containers, anim_time, 250),
   CFG_ITEM_INT(Conf_containers, anim_step, 10),
};
#define N_CFG_ITEMS (sizeof(ContainersCfgItems)/sizeof(CfgItem))

/*
 * Module descriptor
 */
const EModule       ModIconboxes = {
   "iconboxes", "ibox",
   ContainersSighan,
   {N_IPC_FUNCS, ContainersIpcArray},
   {N_CFG_ITEMS, ContainersCfgItems}
};