/*
 * Copyright (C) 2000-2004 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.
 */
#define DECLARE_STRUCT_BUTTON
#include "E.h"

Button             *
ButtonCreate(const char *name, ImageClass * iclass, ActionClass * aclass,
	     TextClass * tclass, char *label, char ontop, int flags,
	     int minw, int maxw, int minh, int maxh, int xo, int yo,
	     int xa, int xr, int ya, int yr, int xsr, int xsa, int ysr,
	     int ysa, char simg, int desk, char sticky)
{
   Button             *b;

   EDBUG(5, "ButtonCreate");

   b = Emalloc(sizeof(Button));

   b->name = Estrdup(name);
   b->label = Estrdup(label);

   b->iclass = iclass;
   if (!b->iclass)
      b->iclass =
	 FindItem("__FALLBACK_ICLASS", 0, LIST_FINDBY_NAME, LIST_TYPE_ICLASS);
   if (b->iclass)
      b->iclass->ref_count++;

   b->aclass = aclass;
   if (b->aclass)
      b->aclass->ref_count++;

   b->tclass = tclass;

   if ((!b->tclass) && (b->label))
     {
	b->tclass =
	   FindItem("__FALLBACK_TCLASS", 0, LIST_FINDBY_NAME, LIST_TYPE_TCLASS);
     }
   if (b->tclass)
      b->tclass->ref_count++;

   b->label = label;

   b->ontop = ontop;
   b->flags = flags;
   b->sticky = sticky;
   b->desktop = desk;
   b->visible = 0;
   b->geom.width.min = minw;
   b->geom.width.max = maxw;
   b->geom.height.min = minh;
   b->geom.height.max = maxh;
   b->geom.xorigin = xo;
   b->geom.yorigin = yo;
   b->geom.xabs = xa;
   b->geom.xrel = xr;
   b->geom.yabs = ya;
   b->geom.yrel = yr;
   b->geom.xsizeabs = xsa;
   b->geom.xsizerel = xsr;
   b->geom.ysizeabs = ysa;
   b->geom.ysizerel = ysr;
   b->geom.size_from_image = simg;
   b->inside_win = 0;
   b->event_win = 0;
   b->destroy_inside_win = 0;
   b->internal = 0;
   b->default_show = 1;
   b->used = 0;
   b->left = 0;
   b->win =
      ECreateWindow(desks.desk[desk % ENLIGHTENMENT_CONF_NUM_DESKTOPS].win,
		    -100, -100, 50, 50, 0);
   XSelectInput(disp, b->win,
		ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask
		| ButtonReleaseMask | EnterWindowMask | LeaveWindowMask |
		PointerMotionMask);
   b->x = -1;
   b->y = -1;
   b->w = -1;
   b->h = -1;
   b->cx = -10;
   b->cy = -10;
   b->cw = -10;
   b->ch = -10;
   b->state = 0;
   b->expose = 0;
   b->ref_count = 0;

   EDBUG_RETURN(b);
}

void
ButtonDestroy(Button * b)
{
   EDBUG(5, "ButtonDestroy");

   if (!b)
      EDBUG_RETURN_;

   if (b->ref_count > 0)
     {
	DialogOK(_("Button Error!"), _("%u references remain\n"), b->ref_count);
	EDBUG_RETURN_;
     }

   while (RemoveItemByPtr(b, LIST_TYPE_BUTTON));

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

   if (b->win)
      EDestroyWindow(disp, b->win);

   if (b->iclass)
      b->iclass->ref_count--;

   if (b->aclass)
      b->aclass->ref_count--;

   if (b->tclass)
      b->tclass->ref_count--;

   if (b->label)
      Efree(b->label);

   Efree(b);

   EDBUG_RETURN_;
}

static void
ButtonCalc(Button * b)
{
   int                 w, h, x, y, xo, yo;
   Imlib_Image        *im;

   EDBUG(4, "ButtonCalc");
   x = 0;
   y = 0;
   w = 32;
   h = 32;
   if (b->geom.size_from_image)
     {
	if ((b->iclass) && (b->iclass->norm.normal->im_file))
	  {
	     im = ELoadImage(b->iclass->norm.normal->im_file);
	     if (im)
	       {
		  imlib_context_set_image(im);
		  w = imlib_image_get_width();
		  h = imlib_image_get_height();
		  imlib_free_image();
	       }
	     else
	       {
		  w = 32;
		  h = 32;
	       }
	  }
	else
	  {
	     if (!b->iclass)
		b->iclass =
		   FindItem("__FALLBACK_ICLASS", 0, LIST_FINDBY_NAME,
			    LIST_TYPE_ICLASS);
	     w = 32;
	     h = 32;
	  }
     }
   else
     {
	w = ((b->geom.xsizerel * root.w) >> 10) + b->geom.xsizeabs;
	h = ((b->geom.ysizerel * root.h) >> 10) + b->geom.ysizeabs;
     }
   if (w > b->geom.width.max)
      w = b->geom.width.max;
   else if (w < b->geom.width.min)
      w = b->geom.width.min;
   if (h > b->geom.height.max)
      h = b->geom.height.max;
   else if (h < b->geom.height.min)
      h = b->geom.height.min;
   xo = (w * b->geom.xorigin) >> 10;
   yo = (h * b->geom.yorigin) >> 10;
   x = ((b->geom.xrel * root.w) >> 10) + b->geom.xabs - xo;
   y = ((b->geom.yrel * root.h) >> 10) + b->geom.yabs - yo;
   b->x = x;
   b->y = y;
   b->w = w;
   b->h = h;

   EDBUG_RETURN_;
}

void
ButtonShow(Button * b)
{
   char                move, resize;

   EDBUG(4, "ButtonShow");

   ButtonCalc(b);

   move = 0;
   resize = 0;
   if ((b->x != b->cx) || (b->y != b->cy))
      move = 1;
   if ((b->w != b->cw) || (b->h != b->ch))
      resize = 1;

   if ((move) && (resize))
      EMoveResizeWindow(disp, b->win, b->x, b->y, b->w, b->h);
   else if (move)
      EMoveWindow(disp, b->win, b->x, b->y);
   else if (resize)
      EResizeWindow(disp, b->win, b->w, b->h);
   if (b->sticky)
      XRaiseWindow(disp, b->win);

   ButtonDraw(b);
   b->visible = 1;
   EMapWindow(disp, b->win);
   b->cx = b->x;
   b->cy = b->y;
   b->cw = b->w;
   b->ch = b->h;

   EDBUG_RETURN_;
}

void
ButtonMoveToDesktop(Button * b, int num)
{
   EDBUG(3, "ButtonMoveToDesktop");

   if (b->sticky)
     {
	b->desktop = 0;
	EReparentWindow(disp, b->win, desks.desk[0].win, b->x, b->y);
	XRaiseWindow(disp, b->win);
     }
   else
     {
	b->desktop = num;
	EReparentWindow(disp, b->win, desks.desk[DESKTOPS_WRAP_NUM(num)].win,
			b->x, b->y);
     }

   EDBUG_RETURN_;
}

void
ButtonHide(Button * b)
{
   EDBUG(3, "ButtonHide");

   EUnmapWindow(disp, b->win);
   b->visible = 0;

   EDBUG_RETURN_;
}

void
ButtonToggle(Button * b)
{
   EDBUG(3, "ButtonToggle");

   if (b->used)
      EDBUG_RETURN_;

   if (b->visible)
      ButtonHide(b);
   else
      ButtonShow(b);

   EDBUG_RETURN_;
}

void
ButtonDraw(Button * b)
{
   EDBUG(3, "ButtonDraw");

   IclassApply(b->iclass, b->win, b->w, b->h, 0, 0, b->state, 0);

   if (b->label)
      TclassApply(b->iclass, b->win, b->w, b->h, 0, 0, b->state, 0, b->tclass,
		  b->label);
   EDBUG_RETURN_;
}

void
ButtonDrawWithState(Button * b, int state)
{
   b->state = state;
   ButtonDraw(b);
}

void
ButtonMoveToCoord(Button * b, int x, int y)
{
   int                 rx, ry, relx, rely, absx, absy;
   char                move, resize;

   EDBUG(3, "ButtonMoveToCoord");
   if (b->flags & FLAG_FIXED)
      EDBUG_RETURN_;

   if ((x + (b->w >> 1)) < (root.w / 3))
      relx = 0;
   else if ((x + (b->w >> 1)) > ((root.w * 2) / 3))
      relx = 1024;
   else
      relx = 512;
   rx = (relx * root.w) >> 10;
   absx = x - rx;
   if ((y + (b->h >> 1)) < (root.h / 3))
      rely = 0;
   else if ((y + (b->h >> 1)) > ((root.h * 2) / 3))
      rely = 1024;
   else
      rely = 512;
   ry = (rely * root.h) >> 10;
   absy = y - ry;
   if (!(b->flags & FLAG_FIXED_HORIZ))
     {
	b->geom.xorigin = 0;
	b->geom.xabs = absx;
	b->geom.xrel = relx;
     }
   if (!(b->flags & FLAG_FIXED_VERT))
     {
	b->geom.yorigin = 0;
	b->geom.yabs = absy;
	b->geom.yrel = rely;
     }
   ButtonCalc(b);
   move = 0;
   resize = 0;
   if ((b->x != b->cx) || (b->y != b->cy))
      move = 1;
   if ((b->w != b->cw) || (b->h != b->ch))
      resize = 1;
   if ((move) && (resize))
      EMoveResizeWindow(disp, b->win, b->x, b->y, b->w, b->h);
   else if (move)
      EMoveWindow(disp, b->win, b->x, b->y);
   else if (resize)
      EResizeWindow(disp, b->win, b->w, b->h);
   if (b->sticky)
      XRaiseWindow(disp, b->win);
   b->cx = b->x;
   b->cy = b->y;
   b->cw = b->w;
   b->ch = b->h;

   EDBUG_RETURN_;
}

void
ButtonMoveRelative(Button * b, int dx, int dy)
{
   ButtonMoveToCoord(b, b->x + dx, b->y + dy);
}

void
ButtonIncRefcount(Button * b)
{
   b->ref_count++;
}

void
ButtonDecRefcount(Button * b)
{
   b->ref_count--;
}

const char         *
ButtonGetName(Button * b)
{
   return b->name;
}

int
ButtonGetRefcount(Button * b)
{
   return b->ref_count;
}

int
ButtonGetDesktop(Button * b)
{
   return b->desktop;
}

void
ButtonGetGeometry(Button * b, int *x, int *y, unsigned int *w, unsigned int *h)
{
   if (x)
      *x = b->x;
   if (y)
      *y = b->y;
   if (w)
      *w = b->w;
   if (h)
      *h = b->h;
}

int
ButtonGetInfo(Button * b, RectBox * r, int desk)
{
   if (!b->visible || b->internal)
      return -1;
   if (!b->sticky && (b->desktop != desk))
      return -1;

   r->data = NULL;
   r->x = b->x;
   r->y = b->y;
   r->w = b->w;
   r->h = b->h;
   r->p = b->sticky;

   return 0;
}

ActionClass        *
ButtonGetAClass(Button * b)
{
   return b->aclass;
}

int
ButtonIsFixed(Button * b)
{
   return b->flags & FLAG_FIXED;
}

int
ButtonEmbedWindow(Button * ButtonToUse, Window WindowToEmbed)
{

   unsigned int        w, h;

   EDBUG(4, "ButtonEmbedWindow");
   EReparentWindow(disp, WindowToEmbed, ButtonToUse->win, 0, 0);
   ButtonToUse->inside_win = WindowToEmbed;
   GetWinWH(WindowToEmbed, &w, &h);
   EMoveWindow(disp, ButtonToUse->inside_win, (ButtonToUse->w - w) >> 1,
	       (ButtonToUse->h - h) >> 1);
   ButtonToUse->event_win = ECreateEventWindow(ButtonToUse->win, 0, 0, w, h);

   XSelectInput(disp, ButtonToUse->event_win,
		ButtonPressMask | ButtonReleaseMask | EnterWindowMask |
		LeaveWindowMask | ButtonMotionMask);

   EMoveWindow(disp, ButtonToUse->event_win, (ButtonToUse->w - w) >> 1,
	       (ButtonToUse->h - h) >> 1);
   EMapRaised(disp, ButtonToUse->event_win);

   EDBUG_RETURN(0);
}

void
ButtonFindEmptySpotFor(Button * bt, const char *listname, char dirtomove)
{

   Button            **blst;
   int                 num = 0, i = 0, j = 0, done = 0;

   blst = (Button **) ListItemTypeName(&num, LIST_TYPE_BUTTON, listname);
   if (blst)
     {
	for (i = 0; i < num; i++)
	  {
	     for (j = 0; j < num; j++)
	       {
		  if ((bt->x + bt->w) <= blst[j]->x
		      || bt->x >= (blst[j]->x + blst[j]->w))
		    {
		       done = 1;
		    }
		  else
		    {
		       if ((bt->y + bt->h) <= blst[j]->y
			   || bt->y > (blst[j]->y + blst[j]->h))
			  done = 1;
		       else
			  done = 0;
		    }
		  if (!done)
		    {
		       if (dirtomove == ICON_RIGHT)
			  bt->x += bt->w;
		       else if (dirtomove == ICON_LEFT)
			  bt->x -= bt->w;
		       else if (dirtomove == ICON_DOWN)
			  bt->y += bt->h;
		       else if (dirtomove == ICON_UP)
			  bt->y -= bt->h;
		    }
	       }
	  }
	Efree(blst);
     }
   ButtonMoveToCoord(bt, bt->x, bt->y);

   EDBUG_RETURN_;
}

/*
 * Functions operating on all buttons
 */

Button             *
FindButton(Window win)
{
   Button             *b;
   Button            **buttons;
   int                 i, num;

   EDBUG(6, "FindButton");

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   for (i = 0; i < num; i++)
     {
	if ((win == buttons[i]->win) || (win == buttons[i]->inside_win)
	    || (win == buttons[i]->event_win))
	  {
	     b = buttons[i];
	     Efree(buttons);
	     EDBUG_RETURN(b);
	  }
     }
   if (buttons)
      Efree(buttons);
   EDBUG_RETURN(NULL);
}

/*
 * Button event handlers
 */

int
ButtonsEventExpose(XEvent * ev)
{
   int                 used = 0;
   int                 i, num;
   Button            **buttons;
   Window              win = ev->xexpose.window;

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   if (buttons == NULL)
      return 0;

   for (i = 0; i < num; i++)
     {
	if (win != buttons[i]->win)
	   continue;

	ButtonDraw(buttons[i]);
	used = 1;
	break;
     }
   Efree(buttons);

   return used;
}

int
ButtonsEventMouseDown(XEvent * ev)
{
   int                 used = 0;
   int                 i, num;
   Button            **buttons;
   Window              win = ev->xbutton.window;
   ActionClass        *ac;

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   if (buttons == NULL)
      return 0;

   for (i = 0; i < num; i++)
     {
	if ((win != buttons[i]->win) && (win != buttons[i]->event_win))
	   continue;

	GrabThePointer(win);
	if (buttons[i]->inside_win)
	  {
	     Window              id = ev->xany.window;	/* ??? */

	     ev->xany.window = buttons[i]->inside_win;
	     XSendEvent(disp, buttons[i]->inside_win, False,
			ButtonPressMask, ev);
	     ev->xany.window = id;
	  }

	Mode.button = buttons[i];
	buttons[i]->state = STATE_CLICKED;
	ButtonDraw(buttons[i]);
	ac = FindItem("ACTION_BUTTON_DRAG", 0, LIST_FINDBY_NAME,
		      LIST_TYPE_ACLASS);
	if (ac)
	   EventAclass(ev, NULL, ac);
	if (buttons[i]->aclass)
	   EventAclass(ev, NULL, buttons[i]->aclass);
	used = 1;
	break;
     }
   Efree(buttons);

   return used;
}

int
ButtonsEventMouseUp(XEvent * ev)
{
   int                 used = 0;
   int                 i, num;
   Button            **buttons;
   Window              win = ev->xbutton.window;

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   if (buttons == NULL)
      return 0;

   for (i = 0; i < num; i++)
     {
	if ((win != buttons[i]->win) && (win != buttons[i]->event_win))
	   continue;

	if (buttons[i]->inside_win && !Mode.action_inhibit)
	  {
	     Window              id = ev->xany.window;	/* ??? */

	     ev->xany.window = buttons[i]->inside_win;
	     XSendEvent(disp, buttons[i]->inside_win, False,
			ButtonReleaseMask, ev);
	     ev->xany.window = id;
	  }
	Mode.button = buttons[i];
	if ((buttons[i]->state == STATE_CLICKED) && (!buttons[i]->left))
	   buttons[i]->state = STATE_HILITED;
	else
	   buttons[i]->state = STATE_NORMAL;
	buttons[i]->left = 0;
	ButtonDraw(buttons[i]);
	if (buttons[i]->aclass)
	   EventAclass(ev, NULL, buttons[i]->aclass);
	used = 1;
	break;
     }
   Efree(buttons);

   return used;
}

int
ButtonsEventMouseIn(XEvent * ev)
{
   int                 used = 0;
   int                 i, num;
   Button            **buttons;
   Window              win = ev->xcrossing.window;

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   if (buttons == NULL)
      return 0;

   for (i = 0; i < num; i++)
     {
	if ((win != buttons[i]->win) && (win != buttons[i]->event_win))
	   continue;

	Mode.button = buttons[i];
	if (buttons[i]->state == STATE_CLICKED)
	   buttons[i]->left = 0;
	else
	  {
	     buttons[i]->state = STATE_HILITED;
	     ButtonDraw(buttons[i]);
	     if (buttons[i]->aclass)
		EventAclass(ev, NULL, buttons[i]->aclass);
	  }
	used = 1;
	break;
     }
   Efree(buttons);

   return used;
}

int
ButtonsEventMouseOut(XEvent * ev)
{
   int                 used = 0;
   int                 i, num;
   Button            **buttons;
   Window              win = ev->xcrossing.window;

   buttons = (Button **) ListItemType(&num, LIST_TYPE_BUTTON);
   if (buttons == NULL)
      return 0;

   for (i = 0; i < num; i++)
     {
	if ((win != buttons[i]->win) && (win != buttons[i]->event_win))
	   continue;

	Mode.button = NULL;
	if (buttons[i]->state == STATE_CLICKED)
	   buttons[i]->left = 1;
	else
	  {
	     buttons[i]->state = STATE_NORMAL;
	     ButtonDraw(buttons[i]);
	     if (buttons[i]->aclass)
		EventAclass(ev, NULL, buttons[i]->aclass);
	  }
	used = 1;
	break;
     }
   Efree(buttons);

   return used;
}