/*
 * Copyright (C) 2000 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"
#include <X11/Xutil.h>
#include <X11/Xresource.h>

Pixmap
ECreatePixmap(Display * display, Drawable d, unsigned int width,
	      unsigned int height, unsigned depth)
{
   Pixmap              pm;

   pm = XCreatePixmap(display, d, width, height, depth);
   return pm;
}

void
EFreePixmap(Display * display, Pixmap pixmap)
{
   XFreePixmap(display, pixmap);
}

Window ECreateWindow(Window parent, int x, int y, int w, int h, int saveunder)
{
   EXID               *xid;
   Window              win;
   XSetWindowAttributes attr;

   EDBUG(6, "ECreateWindow");
   attr.backing_store = NotUseful;
   attr.override_redirect = True;
   attr.colormap = root.cmap;
   attr.border_pixel = 0;
/*   attr.background_pixel = 0; */
   attr.background_pixmap = None;
   if ((saveunder == 1) && (mode.save_under))
      attr.save_under = True;
   else if (saveunder == 2)
      attr.save_under = True;
   else
      attr.save_under = False;
   win =
      XCreateWindow(disp, parent, x, y, w, h, 0, root.depth, InputOutput,
		    root.vis,
		    CWOverrideRedirect | CWSaveUnder | CWBackingStore |
		    CWColormap | CWBackPixmap | CWBorderPixel, &attr);
   xid = NewXID();
   xid->parent = parent;
   xid->win = win;
   xid->x = x;
   xid->y = y;
   xid->w = w;
   xid->h = h;
   xid->depth = root.depth;
   AddXID(xid);
   EDBUG_RETURN(win);
}

void
EMoveWindow(Display * d, Window win, int x, int y)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if ((x != xid->x) || (y != xid->y))
	  {
	     xid->x = x;
	     xid->y = y;
	     XMoveWindow(d, win, x, y);
	  }
     }
   else
      XMoveWindow(d, win, x, y);
}

void
EResizeWindow(Display * d, Window win, int w, int h)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if ((w != xid->w) || (h != xid->h))
	  {
	     xid->w = w;
	     xid->h = h;
	     XResizeWindow(d, win, w, h);
	  }
     }
   else
      XResizeWindow(d, win, w, h);
}

void
EMoveResizeWindow(Display * d, Window win, int x, int y, int w, int h)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if ((w != xid->w) || (h != xid->h) || (x != xid->x) || (y != xid->y))
	  {
	     xid->x = x;
	     xid->y = y;
	     xid->w = w;
	     xid->h = h;
	     XMoveResizeWindow(d, win, x, y, w, h);
	  }
     }
   else
      XMoveResizeWindow(d, win, x, y, w, h);
}

void
EDestroyWindow(Display * d, Window win)
{
   EXID               *xid;

   if ((mode.slideout) && (mode.slideout->from_win == win))
      HideSlideout(mode.slideout, 0);
   xid = FindXID(win);
   if (xid)
     {
	EXID              **lst;
	int                 i, num;

	DelXID(win);
	XDestroyWindow(d, win);
	lst = (EXID **) ListItemType(&num, LIST_TYPE_XID);
	if (lst)
	  {
	     for (i = 0; i < num; i++)
	       {
		  if (lst[i]->parent == win)
		     EDestroyWindow(d, lst[i]->win);
	       }
	     Efree(lst);
	  }
     }
   else
      XDestroyWindow(d, win);
}

void
EMapWindow(Display * d, Window win)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (!xid->mapped)
	  {
	     xid->mapped = 1;
	     XMapWindow(d, win);
	  }
     }
   else
      XMapWindow(d, win);
}

void
EUnmapWindow(Display * d, Window win)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (xid->mapped)
	  {
	     xid->mapped = 0;
	     XUnmapWindow(d, win);
	  }
     }
   else
      XUnmapWindow(d, win);
}

void
EShapeCombineMask(Display * d, Window win, int dest, int x, int y, Pixmap pmap,
		  int op)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	char                wasshaped = 0;

	if (xid->rects)
	  {
	     xid->num_rect = 0;
	     XFree(xid->rects);
	     xid->rects = NULL;
	     wasshaped = 1;
	  }
	if (pmap)
	  {
	     XShapeCombineMask(d, win, dest, x, y, pmap, op);
	     xid->rects =
		XShapeGetRectangles(d, win, dest, &(xid->num_rect),
				    &(xid->ord));
	     if (xid->rects)
	       {
		  if (xid->num_rect == 1)
		    {
		       if ((xid->rects[0].x == 0) && (xid->rects[0].y == 0)
			   && (xid->rects[0].width == xid->w)
			   && (xid->rects[0].height == xid->h))
			 {
			    xid->num_rect = 0;
			    XFree(xid->rects);
			    xid->rects = NULL;
			 }
		    }
	       }
	  }
	else if ((!pmap) && (wasshaped))
	   XShapeCombineMask(d, win, dest, x, y, pmap, op);
     }
   else
      XShapeCombineMask(d, win, dest, x, y, pmap, op);
}

void
EShapeCombineRectangles(Display * d, Window win, int dest, int x, int y,
			XRectangle * rect, int n_rects, int op, int ordering)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (n_rects == 1)
	  {
	     if ((rect[0].x == 0) && (rect[0].y == 0)
		 && (rect[0].width == xid->w) && (rect[0].height == xid->h))
	       {
		  xid->num_rect = 0;
		  XFree(xid->rects);
		  xid->rects = NULL;
		  XShapeCombineMask(d, win, dest, x, y, None, op);
		  return;
	       }
	  }
	xid->num_rect = 0;
	if (xid->rects)
	   XFree(xid->rects);
	XShapeCombineRectangles(d, win, dest, x, y, rect, n_rects, op,
				ordering);
	xid->rects =
	   XShapeGetRectangles(d, win, dest, &(xid->num_rect), &(xid->ord));
	if (xid->rects)
	  {
	     if (xid->num_rect == 1)
	       {
		  if ((xid->rects[0].x == 0) && (xid->rects[0].y == 0)
		      && (xid->rects[0].width == xid->w)
		      && (xid->rects[0].height == xid->h))
		    {
		       xid->num_rect = 0;
		       XFree(xid->rects);
		       xid->rects = NULL;
		    }
	       }
	  }
     }
   else
      XShapeCombineRectangles(d, win, dest, x, y, rect, n_rects, op, ordering);
}

void
EShapeCombineShape(Display * d, Window win, int dest, int x, int y,
		   Window src_win, int src_kind, int op)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	xid->num_rect = 0;
	if (xid->rects)
	   XFree(xid->rects);
	XShapeCombineShape(d, win, dest, x, y, src_win, src_kind, op);
	xid->rects =
	   XShapeGetRectangles(d, win, dest, &(xid->num_rect), &(xid->ord));
	if (xid->rects)
	  {
	     if (xid->num_rect == 1)
	       {
		  if ((xid->rects[0].x == 0) && (xid->rects[0].y == 0)
		      && (xid->rects[0].width == xid->w)
		      && (xid->rects[0].height == xid->h))
		    {
		       xid->num_rect = 0;
		       XFree(xid->rects);
		       xid->rects = NULL;
		    }
	       }
	  }
     }
   else
      XShapeCombineShape(d, win, dest, x, y, src_win, src_kind, op);
}

XRectangle         *
EShapeGetRectangles(Display * d, Window win, int dest, int *rn, int *ord)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	XRectangle         *r;

	*rn = xid->num_rect;
	*ord = xid->ord;
	if (xid->num_rect > 0)
	  {
	     r = Emalloc(sizeof(XRectangle) * xid->num_rect);
	     memcpy(r, xid->rects, sizeof(XRectangle) * xid->num_rect);
	     return r;
	  }
	else
	   return NULL;
     }
   else
     {
	XRectangle         *r, *rr;

	r = XShapeGetRectangles(d, win, dest, rn, ord);
	if (r)
	  {
	     rr = Emalloc(sizeof(XRectangle) * *rn);
	     memcpy(rr, r, sizeof(XRectangle) * *rn);
	     XFree(r);
	     return rr;
	  }
     }
   return NULL;
}

void
EReparentWindow(Display * d, Window win, Window parent, int x, int y)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (parent == xid->parent)
	  {
	     if ((x != xid->x) || (y != xid->y))
	       {
		  xid->x = x;
		  xid->y = y;
		  XMoveWindow(d, win, x, y);
	       }
	  }
	else
	  {
	     xid->parent = parent;
	     xid->x = x;
	     xid->y = y;
	     XReparentWindow(d, win, parent, x, y);
	  }
     }
   else
      XReparentWindow(d, win, parent, x, y);
}

void
EMapRaised(Display * d, Window win)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (xid->mapped)
	   XRaiseWindow(d, win);
	else
	  {
	     xid->mapped = 1;
	     XMapRaised(d, win);
	  }
     }
   else
      XMapRaised(d, win);
}

int
EGetGeometry(Display * d, Window win, Window * root_return, int *x, int *y,
	     unsigned int *w, unsigned int *h, unsigned int *bw,
	     unsigned int *depth)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (x)
	   *x = xid->x;
	if (y)
	   *y = xid->y;
	if (w)
	   *w = xid->w;
	if (h)
	   *h = xid->h;
	if (bw)
	   *bw = 0;
	if (depth)
	   *depth = xid->depth;
	if (root_return)
	   *root_return = root.win;
	return 1;
     }
   return XGetGeometry(d, win, root_return, x, y, w, h, bw, depth);
}

void
EConfigureWindow(Display * d, Window win, unsigned int mask,
		 XWindowChanges * wc)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	char                doit = 0;

	if ((mask & CWX) && (wc->x != xid->x))
	  {
	     xid->x = wc->x;
	     doit = 1;
	  }
	if ((mask & CWY) && (wc->y != xid->y))
	  {
	     xid->y = wc->y;
	     doit = 1;
	  }
	if ((mask & CWWidth) && (wc->width != xid->w))
	  {
	     xid->w = wc->width;
	     doit = 1;
	  }
	if ((mask & CWHeight) && (wc->height != xid->h))
	  {
	     xid->h = wc->height;
	     doit = 1;
	  }
	if ((doit) || (mask & (CWBorderWidth | CWSibling | CWStackMode)))
	   XConfigureWindow(d, win, mask, wc);
     }
   else
     {
	XConfigureWindow(d, win, mask, wc);
     }
}

void
ESetWindowBackgroundPixmap(Display * d, Window win, Pixmap pmap)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	xid->bgpmap = pmap;
	XSetWindowBackgroundPixmap(d, win, pmap);
     }
   else
      XSetWindowBackgroundPixmap(d, win, pmap);
}

void
ESetWindowBackground(Display * d, Window win, int col)
{
   EXID               *xid;

   xid = FindXID(win);
   if (xid)
     {
	if (xid->bgpmap)
	  {
	     xid->bgpmap = 0;
	     xid->bgcol = col;
	     XSetWindowBackground(d, win, col);
	  }
	else if (xid->bgcol != col)
	  {
	     xid->bgcol = col;
	     XSetWindowBackground(d, win, col);
	  }
     }
   else
      XSetWindowBackground(d, win, col);
}

EXID               *
NewXID(void)
{
   EXID               *xid;

   xid = Emalloc(sizeof(EXID));
   xid->parent = 0;
   xid->win = 0;
   xid->x = 0;
   xid->y = 0;
   xid->w = 0;
   xid->h = 0;
   xid->num_rect = 0;
   xid->ord = 0;
   xid->rects = NULL;
   xid->depth = 0;
   xid->mapped = 0;
   xid->bgpmap = 0;
   xid->bgcol = 0;
   return xid;
}

static XContext     xid_context = 0;

void
AddXID(EXID * xid)
{
   if (!xid_context)
      xid_context = XUniqueContext();
   XSaveContext(disp, xid->win, xid_context, (XPointer) xid);
   AddItem(xid, "", xid->win, LIST_TYPE_XID);
}

EXID               *
FindXID(Window win)
{
   EXID               *xid = NULL;

   if (xid_context == 0)
      xid_context = XUniqueContext();
   if (XFindContext(disp, win, xid_context, (XPointer *) & xid) == XCNOENT)
      xid = NULL;
   return xid;
}

void
DelXID(Window win)
{
   EXID               *xid;

   if (xid_context == 0)
      xid_context = XUniqueContext();
   xid = RemoveItem("", win, LIST_FINDBY_ID, LIST_TYPE_XID);
   if (xid)
     {
	XDeleteContext(disp, win, xid_context);
	if (xid->rects)
	   XFree(xid->rects);
	Efree(xid);
     }
}

Window ECreateEventWindow(Window parent, int x, int y, int w, int h)
{
   Window              win;
   XSetWindowAttributes attr;

   EDBUG(6, "ECreateEventWindow");
   attr.override_redirect = False;
   win =
      XCreateWindow(disp, parent, x, y, w, h, 0, 0, InputOnly, root.vis,
		    CWOverrideRedirect, &attr);
   EDBUG_RETURN(win);
}

/*
 * create a window which will accept the keyboard focus when no other 
 * windows have it
 */
Window ECreateFocusWindow(Window parent, int x, int y, int w, int h)
{
   Window              win;
   XSetWindowAttributes attr;

   EDBUG(6, "ECreateFocusWindow");

   attr.backing_store = NotUseful;
   attr.override_redirect = True;
   attr.colormap = root.cmap;
   attr.border_pixel = 0;
   attr.background_pixel = 0;
   attr.save_under = False;
   attr.event_mask = KeyPressMask | FocusChangeMask;

   win =
      XCreateWindow(disp, parent, x, y, w, h, 0, 0, InputOnly, CopyFromParent,
		    CWOverrideRedirect | CWSaveUnder | CWBackingStore |
		    CWColormap | CWBackPixel | CWBorderPixel | CWEventMask,
		    &attr);

   XSetWindowBackground(disp, win, 0);
   XMapWindow(disp, win);
   XSetInputFocus(disp, win, RevertToParent, CurrentTime);

   EDBUG_RETURN(win);
}

void
GrabX()
{
   EDBUG(6, "GrabX");
   if (mode.server_grabbed <= 0)
      XGrabServer(disp);
   mode.server_grabbed++;
   EDBUG_RETURN_;
}

void
UngrabX()
{
   EDBUG(6, "UngrabX");
   if (mode.server_grabbed == 1)
     {
	XUngrabServer(disp);
	XFlush(disp);
     }
   mode.server_grabbed--;
   if (mode.server_grabbed < 0)
      mode.server_grabbed = 0;
   EDBUG_RETURN_;
}

void
SetBG(Window win, Pixmap pmap, int color)
{
   static Atom         a = 0, aa = 0, aaa = 0;
   static Window       alive_win = 0;

   EDBUG(6, "SetBG");
   if (!a)
     {
	a = XInternAtom(disp, "_XROOTPMAP_ID", False);
	aa = XInternAtom(disp, "_XROOTCOLOR_PIXEL", False);
	aaa = XInternAtom(disp, "_XROOTWINDOW", False);
     }
   if (!alive_win)
     {
	alive_win = ECreateWindow(root.win, -100, -100, 1, 1, 0);
	XChangeProperty(disp, alive_win, aaa, XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)&alive_win, 1);
	XChangeProperty(disp, root.win, aaa, XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)&alive_win, 1);
     }
   XChangeProperty(disp, win, a, XA_PIXMAP, 32, PropModeReplace,
		   (unsigned char *)&pmap, 1);
   XChangeProperty(disp, win, aa, XA_CARDINAL, 32, PropModeReplace,
		   (unsigned char *)&color, 1);
   if (pmap)
      XSetWindowBackgroundPixmap(disp, win, pmap);
   else
      XSetWindowBackground(disp, win, color);
   XClearWindow(disp, win);
   EDBUG_RETURN_;
}

void
GetWinXY(Window win, int *x, int *y)
{
   Window              w1;
   unsigned int        w, h, b, d;

   EDBUG(7, "GetWinXY");
   EGetGeometry(disp, win, &w1, x, y, &w, &h, &b, &d);
   EDBUG_RETURN_;
}

void
GetWinWH(Window win, unsigned int *w, unsigned int *h)
{
   Window              w1;
   int                 x, y;
   unsigned int        b, d;

   EDBUG(7, "GetWinWH");
   EGetGeometry(disp, win, &w1, &x, &y, w, h, &b, &d);
   EDBUG_RETURN_;
}

int
GetWinDepth(Window win)
{
   Window              w1;
   unsigned int        w, h, b, d;
   int                 x, y;

   EDBUG(7, "GetWinDepth");
   EGetGeometry(disp, win, &w1, &x, &y, &w, &h, &b, &d);
   EDBUG_RETURN(d);
}

int
WinExists(Window win)
{
   Window              w1;
   int                 x, y;
   unsigned int        w, h;
   unsigned int        b, d;

   EDBUG(7, "WinExists");
   if (EGetGeometry(disp, win, &w1, &x, &y, &w, &h, &b, &d))
      EDBUG_RETURN(1);
   EDBUG_RETURN(0);
}

Window WindowAtXY_0(Window base, int bx, int by, int x, int y)
{
   Window             *list = NULL;
   XWindowAttributes   att;
   Window              child = 0, parent_win = 0, root_win = 0;
   int                 i;
   unsigned int        ww, wh, num;
   int                 wx, wy;

   EDBUG(7, "WindowAtXY_0");
   if (!XGetWindowAttributes(disp, base, &att))
      EDBUG_RETURN(0);
   if (att.class == InputOnly)
      EDBUG_RETURN(0);
   if (att.map_state != IsViewable)
      EDBUG_RETURN(0);
   wx = att.x;
   wy = att.y;
   ww = att.width;
   wh = att.height;

   wx += bx;
   wy += by;

   if (!((x >= wx) && (y >= wy) && (x < (int)(wx + ww))
	 && (y < (int)(wy + wh))))
      EDBUG_RETURN(0);

   if (!XQueryTree(disp, base, &root_win, &parent_win, &list, &num))
      EDBUG_RETURN(base);
   if (list)
     {
	for (i = num - 1;; i--)
	  {
	     if ((child = WindowAtXY_0(list[i], wx, wy, x, y)) != 0)
	       {
		  XFree(list);
		  EDBUG_RETURN(child);
	       }
	     if (!i)
		break;
	  }
	XFree(list);
     }
   EDBUG_RETURN(base);
}

Window WindowAtXY(int x, int y)
{
   Window             *list = NULL;
   Window              child = 0, parent_win = 0, root_win = 0;
   unsigned int        num;
   int                 i;

   EDBUG(7, "WindowAtXY");
   GrabX();
   if (!XQueryTree(disp, root.win, &root_win, &parent_win, &list, &num))
     {
	UngrabX();
	EDBUG_RETURN(root.win);
     }
   if (list)
     {
	i = num - 1;
	do
	  {
	     XWindowAttributes   xwa;

	     XGetWindowAttributes(disp, list[i], &xwa);
	     if (xwa.map_state != IsViewable)
		continue;

	     if ((child = WindowAtXY_0(list[i], 0, 0, x, y)) == 0)
		continue;

	     XFree(list);
	     UngrabX();
	     EDBUG_RETURN(child);
	  }
	while (--i > 0);
	XFree(list);
     }
   UngrabX();
   EDBUG_RETURN(root.win);
}

void
PointerAt(int *x, int *y)
{
   Window              dw;
   int                 dd;
   unsigned int        mm;

   XQueryPointer(disp, root.win, &dw, &dw, &dd, &dd, x, y, &mm);
}

void
PastePixmap(Display * d, Drawable w, Pixmap p, Mask m, int x, int y)
{
   static GC           gc = 0;
   XGCValues           gcv;
   int                 ww, hh;

   if (!gc)
      gc = XCreateGC(d, w, 0, &gcv);
   GetWinWH(p, (unsigned int *)&ww, (unsigned int *)&hh);
   XSetClipMask(disp, gc, m);
   XSetClipOrigin(disp, gc, x, y);
   XCopyArea(disp, p, w, gc, 0, 0, ww, hh, x, y);
}

void
PasteMask(Display * d, Drawable w, Pixmap p, int x, int y, int wd, int ht)
{
   static GC           gc = 0;
   XGCValues           gcv;
   int                 ww, hh;

   if (!gc)
      gc = XCreateGC(d, w, 0, &gcv);
   if (p)
     {
	GetWinWH(p, (unsigned int *)&ww, (unsigned int *)&hh);
	XSetClipMask(disp, gc, p);
	XSetClipOrigin(disp, gc, x, y);
	XCopyArea(disp, p, w, gc, 0, 0, ww, hh, x, y);
     }
   else
     {
	XSetForeground(disp, gc, 1);
	XFillRectangle(disp, w, gc, x, y, wd, ht);
     }
}