screen.c

/* evilwm - Minimalist Window Manager for X
 * Copyright (C) 1999-2000 Ciaran Anscomb <ciarana@rd.bbc.co.uk>
 * see README for license and other details. */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>

#include "evilwm.h"
#include "events.h"

int driveEnterNotify;

static void draw_outline(Client *c)
{
	char buf[50];
	int width_inc = 1, height_inc = 1;

	XDrawRectangle(dpy, root, invert_gc,
		       c->x - c->border, c->y - c->border,
		       c->width + c->border, c->height + c->border);

	if (c->size->flags & PResizeInc) {
		width_inc = c->size->width_inc;
		height_inc = c->size->height_inc;
	}

	snprintf(buf, sizeof(buf), "%s: %dx%d+%d+%d",
		 c->name, c->width/width_inc, c->height/height_inc, c->x, c->y);
	XDrawString(dpy, root, invert_gc,
		    c->x + c->width - XTextWidth(font, buf, strlen(buf)) - SPACE,
		    c->y + c->height - SPACE,
		    buf, strlen(buf));
}

void get_mouse_position(int *x, int *y)
{
	Window dw1, dw2;
	int t1, t2;
	unsigned int t3;

	XQueryPointer(dpy, root, &dw1, &dw2, x, y, &t1, &t2, &t3);
}

static void recalculate_sweep(Client *c, int x1, int y1, int x2, int y2)
{
	int basex, basey;

	c->width = abs(x1 - x2);
	c->height = abs(y1 - y2);

	if (c->size->flags & PResizeInc) {
		basex = (c->size->flags & PBaseSize) ? c->size->base_width :
			(c->size->flags & PMinSize) ? c->size->min_width : 0;
		basey = (c->size->flags & PBaseSize) ? c->size->base_height :
			(c->size->flags & PMinSize) ? c->size->min_height : 0;
		c->width -= (c->width - basex) % c->size->width_inc;
		c->height -= (c->height - basey) % c->size->height_inc;
	}

	if (c->size->flags & PMinSize) {
		if (c->width < c->size->min_width)
			c->width = c->size->min_width;
		if (c->height < c->size->min_height)
			c->height = c->size->min_height;
	}

	if (c->size->flags & PMaxSize) {
		if (c->width > c->size->max_width)
			c->width = c->size->max_width;
		if (c->height > c->size->max_height)
			c->height = c->size->max_height;
	}

	c->x = (x1 <= x2) ? x1 : x1 - c->width;
	c->y = (y1 <= y2) ? y1 : y1 - c->height;
}

#define GRAB(w, mask, curs) \
	(XGrabPointer(dpy, w, False, mask, GrabModeAsync, GrabModeAsync, \
	None, curs, CurrentTime) == GrabSuccess)

static void sweep(Client *c)
{
	XEvent ev;
	int old_cx = c->x;
	int old_cy = c->y;

	if (!GRAB(root, MouseMask, resize_curs))
		return;

	XGrabServer(dpy);
	draw_outline(c);
	warp_pointer(c->window, c->width, c->height);

	for ( ; ; ) {
		XMaskEvent(dpy, MouseMask, &ev);
		switch (ev.type) {
		case MotionNotify:
			draw_outline(c); /* clear */
			recalculate_sweep(c, old_cx, old_cy, ev.xmotion.x, ev.xmotion.y);
			draw_outline(c);
			break;
		case ButtonRelease:
			draw_outline(c); /* clear */
			XUngrabServer(dpy);
			XUngrabPointer(dpy, CurrentTime);
			return;
		}
	}
}

void show_info(Client *c)
{
	XEvent ev;

	XGrabServer(dpy);
	draw_outline(c);
	XMaskEvent(dpy, KeyReleaseMask, &ev);
	draw_outline(c);
	XUngrabServer(dpy);
}

static void drag(Client *c)
{
	XEvent ev;
	int x1, y1;
	int old_cx = c->x;
	int old_cy = c->y;

	if (!GRAB(root, MouseMask, move_curs))
		return;

	get_mouse_position(&x1, &y1);

	for (;;) {
		XMaskEvent(dpy, MouseMask, &ev);
		switch (ev.type) {
		case MotionNotify:
			c->x = old_cx + (ev.xmotion.x - x1);
			c->y = old_cy + (ev.xmotion.y - y1);
			XMoveWindow(dpy, c->parent, c->x - c->border,
				    c->y - c->border);
			send_config(c);
			break;
		case ButtonRelease:
			XUngrabPointer(dpy, CurrentTime);
			return;
		default:
			break;
		}
	}

	XUngrabServer(dpy);
}

void move(Client *c, int set)
{
	if (!c)
		return;

	if (!set)
		drag(c);

	XMoveWindow(dpy, c->parent, c->x - c->border, c->y - c->border);
	send_config(c);
	XRaiseWindow(dpy, c->parent);
}

void resize(Client *c, int set)
{
	if (!c)
		return;

	if (!set)
		sweep(c);

	XMoveResizeWindow(dpy, c->parent, c->x - c->border,
			  c->y - c->border, c->width + (c->border*2),
			  c->height + (c->border*2));
	XMoveResizeWindow(dpy, c->window, c->border, c->border,
			  c->width, c->height);
	send_config(c);
	XRaiseWindow(dpy, c->parent);
	driveEnterNotify = 0;
}

void maximise_horiz(Client *c)
{
	if (c->oldw) {
		c->x = c->oldx;
		c->width = c->oldw;
		c->oldw = 0;
	} else {
		c->oldx = c->x;
		c->oldw = c->width;
		recalculate_sweep(c, 0, c->y, DisplayWidth(dpy, screen),
				  c->y + c->height);
	}
}

void maximise_vert(Client *c)
{
	if (c->oldh) {
		c->y = c->oldy;
		c->height = c->oldh;
		c->oldh = 0;
	} else {
		c->oldy = c->y;
		c->oldh = c->height;
		recalculate_sweep(c, c->x, 0, c->x + c->width,
				  DisplayHeight(dpy, screen));
	}
}

void hide(Client *c)
{
	if (!c)
		return;

	XUnmapWindow(dpy, c->parent);
	XUnmapWindow(dpy, c->window);
	set_wm_state(c, IconicState);
}

void unhide(Client *c, int raise)
{
	XMapWindow(dpy, c->window);
	raise ? XMapRaised(dpy, c->parent) : XMapWindow(dpy, c->parent);
	set_wm_state(c, NormalState);
}

static void focus(Client* c)
{
	if (c && (c->vdesk == vdesk || c->vdesk == -1)) {
		unhide(c, RAISE);
		/* adhoc, enforcing focus out event */
		warp_pointer(c->window, c->width + c->border - 1,
			     c->height + c->border - 1);
		XSetInputFocus(dpy, c->window, RevertToParent, CurrentTime);
	}
}

static int calc_clients_diff(int srcX, int srcY, Client* dst, int x, int y)
{
	int dstX, dstY;
	dstX = dst->x + dst->width / 2;
	dstY = dst->y + dst->height / 2;

	if (x == 0) {
		int p = (dstY - srcY) * y;
		if (p > 0)
			return 3000 - p - abs(dstX - srcX) * 3;
		else
			return p - abs(dstX - srcX) * 3;
	} else if (y == 0) {
		int p = (dstX - srcX) * x;
		if (p > 0)
			return 3000 - p - abs(dstY - srcY) * 3;
		else
			return p * x - abs(dstY - srcY) * 3;
	} else {
		int px = (dstX - srcX) * x;
		int py = (dstY - srcY) * y;
		int ret = 0;

		if (px > 0)
			ret += 3000 - px;
		else
			ret += px;

		if (py > 0)
			ret += 3000 - py;
		else
			ret += py;

		ret -= abs(px - py) * 3;
		return ret;
	}
}

void arrow_next(Client* c, int x, int y)
{
	Client *newc = c;
	Client* max = 0;
	int maxDiff = 0;
	int srcX, srcY;

	if (!newc) {
		c = head_client;
		while (c && c->vdesk != vdesk && c->vdesk == -1) {
			c = c->next;
		}
		if (c == 0)
			return;

		newc = c = head_client;
		get_mouse_position(&srcX, &srcY);

		if ((newc->vdesk == vdesk || newc->vdesk == -1)) {
			int diff = calc_clients_diff(srcX, srcY, newc, x, y);
			if (max == 0 || maxDiff < diff) {
				maxDiff = diff;
				max = newc;
			}
		}
	} else {
		srcX = c->x + c->width / 2;
		srcY = c->y + c->height / 2;
	}

	do {
		if (newc->next) {
			newc = newc->next;
		} else {
			newc = head_client;
		}

		if ((newc->vdesk == vdesk || newc->vdesk == -1))
		{
			int diff = calc_clients_diff(srcX, srcY, newc, x, y);
			if (max == 0 || maxDiff < diff) {
				maxDiff = diff;
				max = newc;
			}
		}
	} while (newc != c);

	focus(max);
}

void next(Client *c)
{
	Client *newc = c;

	if (!newc) {
		Client* c = head_client;
		while (c && c->vdesk != vdesk && c->vdesk == -1) {
			c = c->next;
		}
		newc = c;
		if (newc == 0)
			return;
	} else {
		do {
			if (newc->next) {
				newc = newc->next;
			} else {
				newc = head_client;
			}
		} while ((newc->vdesk != vdesk && newc->vdesk != -1) && newc != c);
	}

	focus(newc);
}

static int inside_level(Client *c, int x, int y)
{
	int mx = c->x + c->width + c->border;
	int my = c->y + c->height + c->border;

	if (c->x <= x && mx >= x && c->y <= y && my >= y)
		return (x-mx) * (x-mx) + (y-my) * (y-my);
	else
		return INT_MAX;
 }

void switch_vdesk(int v)
{
	Client *c;
	int x, y;
	int max_inside_level = -1;
	Client *max_inside = NULL;

	if (v == vdesk)
		return;

	if (current != NULL) {
		XSetWindowBackground(dpy, current->parent, bg.pixel);
		XClearWindow(dpy, current->parent);
	}

	get_mouse_position(&x, &y);
	current = NULL;

	for (c = head_client; c; c = c->next) {
		if (c->vdesk == vdesk)
			hide(c);
		else if (c->vdesk == v)
			unhide(c, NO_RAISE);

		if (c->vdesk == v || c->vdesk == -1) {
			int level = inside_level(c, x, y);
			if (max_inside == NULL || max_inside_level > level) {
				max_inside = c;
				max_inside_level = level;
			}
		}
	}

	vdesk = v;

	if (prev_focused[vdesk])
		c = prev_focused[vdesk];
	else if (max_inside)
		c = max_inside;

	if (!c)
		return;

	XRaiseWindow(dpy, c->parent);
	set_focus(c);
	warp_pointer(c->window, c->width + c->border - 1,
		     c->height + c->border - 1);
	XSetInputFocus(dpy, c->window, RevertToPointerRoot, CurrentTime);

	driveEnterNotify = 0;
	throwUnmaps = 1;
}

void change_vdesk(Client *c, int vd)
{
	if (vd == -1) {
		if (c->vdesk != -1 && c->vdesk != vdesk) {
			unhide(c, NO_RAISE);
		}
		XSetWindowBackground(dpy, c->parent, fg.pixel);
		XClearWindow(dpy, c->parent);
		c->vdesk = -1;
	} else {
		c->vdesk = vd;
		if (vdesk == c->vdesk)
			unhide(c, NO_RAISE);
		else
			hide(c);
	}
}

void force_set_focus(void)
{
	Client *c;

	if (current)
		return;

	for (c = head_client; c; c = c->next) {
		if (c->vdesk == vdesk) {
			set_focus(c);
			return;
		}
	}
}