/* © 2006-2007 Anselm R. Garbe <garbeam at gmail dot com>

 * © 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>

 * © 2007 Premysl Hruby <dfenze at gmail dot com>

 * See LICENSE file for license details. */

#include "dwm.h"

#include <stdlib.h>

#include <string.h>

#include <X11/Xatom.h>

#include <X11/Xutil.h>

/* static */

static void

attachstack(Client *c) {

	c->snext = stack;

	stack = c;

}

static void

detachstack(Client *c) {

	Client **tc;

	for(tc=&stack; *tc && *tc != c; tc=&(*tc)->snext);

	*tc = c->snext;

}

static void

grabbuttons(Client *c, Bool focused) {

	XUngrabButton(dpy, AnyButton, AnyModifier, c->win);

	if(focused) {

		XGrabButton(dpy, Button1, MODKEY, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button1, MODKEY | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button1, MODKEY | numlockmask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button1, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button2, MODKEY, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button2, MODKEY | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button2, MODKEY | numlockmask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button2, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button3, MODKEY, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button3, MODKEY | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button3, MODKEY | numlockmask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

		XGrabButton(dpy, Button3, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

	}

	else

		XGrabButton(dpy, AnyButton, AnyModifier, c->win, False, BUTTONMASK,

				GrabModeAsync, GrabModeSync, None, None);

}

static Bool

isprotodel(Client *c) {

	int i, n;

	Atom *protocols;

	Bool ret = False;

	if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {

		for(i = 0; !ret && i < n; i++)

			if(protocols[i] == wmatom[WMDelete])

				ret = True;

		XFree(protocols);

	}

	return ret;

}

static void

setclientstate(Client *c, long state) {

	long data[] = {state, None};

	XChangeProperty(dpy, c->win, wmatom[WMState], wmatom[WMState], 32,

			PropModeReplace, (unsigned char *)data, 2);

}

static int

xerrordummy(Display *dsply, XErrorEvent *ee) {

	return 0;

}

/* extern */

void

attach(Client *c) {

	if(clients)

		clients->prev = c;

	c->next = clients;

	clients = c;

}

void

configure(Client *c) {

	XConfigureEvent ce;

	ce.type = ConfigureNotify;

	ce.display = dpy;

	ce.event = c->win;

	ce.window = c->win;

	ce.x = c->x;

	ce.y = c->y;

	ce.width = c->w;

	ce.height = c->h;

	ce.border_width = c->border;

	ce.above = None;

	ce.override_redirect = False;

	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce);

}

void

detach(Client *c) {

	if(c->prev)

		c->prev->next = c->next;

	if(c->next)

		c->next->prev = c->prev;

	if(c == clients)

		clients = c->next;

	c->next = c->prev = NULL;

}

void

focus(Client *c) {

	if( !c && selscreen || c && !isvisible(c))

		for(c = stack; c && !isvisible(c); c = c->snext);

	if(sel && sel != c) {

		grabbuttons(sel, False);

		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);

	}

	if(c) {

		detachstack(c);

		attachstack(c);

		grabbuttons(c, True);

	}

	sel = c;

	drawstatus();

	if(!selscreen)

		return;

	if(c) {

		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);

		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);

	}

	else

		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

}

void

killclient(const char *arg) {

	XEvent ev;

	if(!sel)

		return;

	if(isprotodel(sel)) {

		ev.type = ClientMessage;

		ev.xclient.window = sel->win;

		ev.xclient.message_type = wmatom[WMProtocols];

		ev.xclient.format = 32;

		ev.xclient.data.l[0] = wmatom[WMDelete];

		ev.xclient.data.l[1] = CurrentTime;

		XSendEvent(dpy, sel->win, False, NoEventMask, &ev);

	}

	else

		XKillClient(dpy, sel->win);

}

void

manage(Window w, XWindowAttributes *wa) {

	Client *c, *t = NULL;

	Window trans;

	Status rettrans;

	XWindowChanges wc;

	c = emallocz(sizeof(Client));

	c->tags = emallocz(ntags * sizeof(Bool));

	c->win = w;

	c->x = wa->x;

	c->y = wa->y;

	c->w = wa->width;

	c->h = wa->height;

	c->oldborder = wa->border_width;

	if(c->w == sw && c->h == sh) {

		c->x = sx;

		c->y = sy;

		c->border = wa->border_width;

	}

	else {

		if(c->x + c->w + 2 * c->border > wax + waw)

			c->x = wax + waw - c->w - 2 * c->border;

		if(c->y + c->h + 2 * c->border > way + wah)

			c->y = way + wah - c->h - 2 * c->border;

		if(c->x < wax)

			c->x = wax;

		if(c->y < way)

			c->y = way;

		c->border = BORDERPX;

	}

	wc.border_width = c->border;

	XConfigureWindow(dpy, w, CWBorderWidth, &wc);

	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);

	configure(c); /* propagates border_width, if size doesn't change */

	updatesizehints(c);

	XSelectInput(dpy, w,

		StructureNotifyMask | PropertyChangeMask | EnterWindowMask);

	grabbuttons(c, False);

	updatetitle(c);

	if((rettrans = XGetTransientForHint(dpy, w, &trans) == Success))

		for(t = clients; t && t->win != trans; t = t->next);

	settags(c, t);

	if(!c->isfloating)

		c->isfloating = (rettrans == Success) || c->isfixed;

	attach(c);

	attachstack(c);

	c->isbanned = True;

	XMoveWindow(dpy, w, c->x + 2 * sw, c->y);

	XMapWindow(dpy, w);

	setclientstate(c, NormalState);

	focus(c);

	lt->arrange();

}

void

resize(Client *c, int x, int y, int w, int h, Bool sizehints) {

	float dx, dy, max, min, ratio;

	XWindowChanges wc;

	if(w <= 0 || h <= 0)

		return;

	if(sizehints) {

		if(c->minay > 0 && c->maxay > 0 && (h - c->baseh) > 0) {

			dx = (float)(w - c->basew);

			dy = (float)(h - c->baseh);

			min = (float)(c->minax) / (float)(c->minay);

			max = (float)(c->maxax) / (float)(c->maxay);

			ratio = dx / dy;

			if(max > 0 && min > 0 && ratio > 0) {

				if(ratio < min) {

					dy = (dx * min + dy) / (min * min + 1);

					dx = dy * min;

					w = (int)dx + c->basew;

					h = (int)dy + c->baseh;

				}

				else if(ratio > max) {

					dy = (dx * min + dy) / (max * max + 1);

					dx = dy * min;

					w = (int)dx + c->basew;

					h = (int)dy + c->baseh;

				}

			}

		}

		if(c->minw && w < c->minw)

			w = c->minw;

		if(c->minh && h < c->minh)

			h = c->minh;

		if(c->maxw && w > c->maxw)

			w = c->maxw;

		if(c->maxh && h > c->maxh)

			h = c->maxh;

		if(c->incw)

			w -= (w - c->basew) % c->incw;

		if(c->inch)

			h -= (h - c->baseh) % c->inch;

	}

	if(w <= 0 || h <= 0)

		return;

	/* offscreen appearance fixes */

	if(x > sw)

		x = sw - w - 2 * c->border;

	if(y > sh)

		y = sh - h - 2 * c->border;

	if(x + w + 2 * c->border < sx)

		x = sx;

	if(y + h + 2 * c->border < sy)

		y = sy;

	if(c->x != x || c->y != y || c->w != w || c->h != h) {

		c->x = wc.x = x;

		c->y = wc.y = y;

		c->w = wc.width = w;

		c->h = wc.height = h;

		wc.border_width = c->border;

		XConfigureWindow(dpy, c->win, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &wc);

		configure(c);

		XSync(dpy, False);

	}

}

void

togglefloating(const char *arg) {

	if(!sel || lt->arrange == floating)

		return;

	sel->isfloating = !sel->isfloating;