/**************************************************************************
*
* Tint2 : area
*
* Copyright (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr) from Omega distribution
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
**************************************************************************/

#include <assert.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xrender.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pango/pangocairo.h>

#include "area.h"
#include "server.h"
#include "panel.h"
#include "common.h"

Area *mouse_over_area = NULL;

void init_background(Background *bg)
{
	memset(bg, 0, sizeof(Background));
	bg->border.mask = BORDER_TOP | BORDER_BOTTOM | BORDER_LEFT | BORDER_RIGHT;
}

void initialize_positions(void *obj, int offset)
{
	Area *a = (Area *)obj;
	for (GList *l = a->children; l; l = l->next) {
		Area *child = ((Area *)l->data);
		if (panel_horizontal) {
			child->posy = offset + top_border_width(a) + a->paddingy;
			child->height = a->height - 2 * a->paddingy - top_bottom_border_width(a);
			if (child->_on_change_layout)
				child->_on_change_layout(child);
			initialize_positions(child, child->posy);
		} else {
			child->posx = offset + left_border_width(a) + a->paddingy;
			child->width = a->width - 2 * a->paddingy - left_right_border_width(a);
			if (child->_on_change_layout)
				child->_on_change_layout(child);
			initialize_positions(child, child->posx);
		}
	}
}

void relayout_fixed(Area *a)
{
	if (!a->on_screen)
		return;

	// Children are resized before the parent
	GList *l;
	for (l = a->children; l; l = l->next)
		relayout_fixed(l->data);

	// Recalculate size
	a->_changed = FALSE;
	if (a->resize_needed && a->size_mode == LAYOUT_FIXED) {
		a->resize_needed = FALSE;

		if (a->_resize && a->_resize(a)) {
			// The size has changed => resize needed for the parent
			if (a->parent)
				((Area *)a->parent)->resize_needed = TRUE;
			a->_changed = TRUE;
		}
	}
}

void relayout_dynamic(Area *a, int level)
{
	if (!a->on_screen)
		return;

	// Area is resized before its children
	if (a->resize_needed && a->size_mode == LAYOUT_DYNAMIC) {
		a->resize_needed = FALSE;

		if (a->_resize) {
			if (a->_resize(a))
				a->_changed = TRUE;
			// resize children with LAYOUT_DYNAMIC
			for (GList *l = a->children; l; l = l->next) {
				Area *child = ((Area *)l->data);
				if (child->size_mode == LAYOUT_DYNAMIC && child->children)
					child->resize_needed = 1;
			}
		}
	}

	// Layout children
	if (a->children) {
		if (a->alignment == ALIGN_LEFT) {
			int pos =
			    (panel_horizontal ? a->posx + left_border_width(a) : a->posy + top_border_width(a)) + a->paddingxlr;

			for (GList *l = a->children; l; l = l->next) {
				Area *child = ((Area *)l->data);
				if (!child->on_screen)
					continue;

				if (panel_horizontal) {
					if (pos != child->posx) {
						// pos changed => redraw
						child->posx = pos;
						child->_changed = TRUE;
					}
				} else {
					if (pos != child->posy) {
						// pos changed => redraw
						child->posy = pos;
						child->_changed = TRUE;
					}
				}

				relayout_dynamic(child, level + 1);

				pos += panel_horizontal ? child->width + a->paddingx : child->height + a->paddingx;
			}
		} else if (a->alignment == ALIGN_RIGHT) {
			int pos = (panel_horizontal ? a->posx + a->width - right_border_width(a)
			                            : a->posy + a->height - bottom_border_width(a)) -
			          a->paddingxlr;

			for (GList *l = g_list_last(a->children); l; l = l->prev) {
				Area *child = ((Area *)l->data);
				if (!child->on_screen)
					continue;

				pos -= panel_horizontal ? child->width : child->height;

				if (panel_horizontal) {
					if (pos != child->posx) {
						// pos changed => redraw
						child->posx = pos;
						child->_changed = TRUE;
					}
				} else {
					if (pos != child->posy) {
						// pos changed => redraw
						child->posy = pos;
						child->_changed = TRUE;
					}
				}

				relayout_dynamic(child, level + 1);

				pos -= a->paddingx;
			}
		} else if (a->alignment == ALIGN_CENTER) {

			int children_size = 0;

			for (GList *l = a->children; l; l = l->next) {
				Area *child = ((Area *)l->data);
				if (!child->on_screen)
					continue;

				children_size += panel_horizontal ? child->width : child->height;
				children_size += (l == a->children) ? 0 : a->paddingx;
			}

			int pos =
			    (panel_horizontal ? a->posx + left_border_width(a) : a->posy + top_border_width(a)) + a->paddingxlr;
			pos += ((panel_horizontal ? a->width : a->height) - children_size) / 2;

			for (GList *l = a->children; l; l = l->next) {
				Area *child = ((Area *)l->data);
				if (!child->on_screen)
					continue;

				if (panel_horizontal) {
					if (pos != child->posx) {
						// pos changed => redraw
						child->posx = pos;
						child->_changed = TRUE;
					}
				} else {
					if (pos != child->posy) {
						// pos changed => redraw
						child->posy = pos;
						child->_changed = TRUE;
					}
				}

				relayout_dynamic(child, level + 1);

				pos += panel_horizontal ? child->width + a->paddingx : child->height + a->paddingx;
			}
		}
	}

	if (a->_changed) {
		// pos/size changed
		a->_redraw_needed = TRUE;
		if (a->_on_change_layout)
			a->_on_change_layout(a);
	}
}

int compute_desired_size(Area *a)
{
	if (!a->on_screen)
		return 0;
	if (a->_compute_desired_size)
		return a->_compute_desired_size(a);
	if (a->size_mode == LAYOUT_FIXED)
		fprintf(stderr, YELLOW "Area %s does not set desired size!" RESET "\n", a->name);
	return container_compute_desired_size(a);
}

int container_compute_desired_size(Area *a)
{
	if (!a->on_screen)
		return 0;
	int result = 2 * a->paddingxlr + (panel_horizontal ? left_right_border_width(a) : top_bottom_border_width(a));
	int children_count = 0;
	for (GList *l = a->children; l != NULL; l = l->next) {
		Area *child = (Area *)l->data;
		if (child->on_screen) {
			result += compute_desired_size(child);
			children_count++;
		}
	}
	if (children_count > 0)
		result += (children_count - 1) * a->paddingx;
	return result;
}

void relayout(Area *a)
{
	relayout_fixed(a);
	relayout_dynamic(a, 1);
}

int relayout_with_constraint(Area *a, int maximum_size)
{
	int fixed_children_count = 0;
	int dynamic_children_count = 0;

	if (panel_horizontal) {
		// detect free size for LAYOUT_DYNAMIC Areas
		int size = a->width - 2 * a->paddingxlr - left_right_border_width(a);
		for (GList *l = a->children; l; l = l->next) {
			Area *child = (Area *)l->data;
			if (child->on_screen && child->size_mode == LAYOUT_FIXED) {
				size -= child->width;
				fixed_children_count++;
			}
			if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC)
				dynamic_children_count++;
		}
		if (fixed_children_count + dynamic_children_count > 0)
			size -= (fixed_children_count + dynamic_children_count - 1) * a->paddingx;

		int width = 0;
		int modulo = 0;
		if (dynamic_children_count > 0) {
			width = size / dynamic_children_count;
			modulo = size % dynamic_children_count;
			if (width > maximum_size && maximum_size > 0) {
				width = maximum_size;
				modulo = 0;
			}
		}

		// Resize LAYOUT_DYNAMIC objects
		for (GList *l = a->children; l; l = l->next) {
			Area *child = (Area *)l->data;
			if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC) {
				int old_width = child->width;
				child->width = width;
				if (modulo) {
					child->width++;
					modulo--;
				}
				if (child->width != old_width)
					child->_changed = TRUE;
			}
		}
	} else {
		// detect free size for LAYOUT_DYNAMIC's Area
		int size = a->height - 2 * a->paddingxlr - top_bottom_border_width(a);
		for (GList *l = a->children; l; l = l->next) {
			Area *child = (Area *)l->data;
			if (child->on_screen && child->size_mode == LAYOUT_FIXED) {
				size -= child->height;
				fixed_children_count++;
			}
			if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC)
				dynamic_children_count++;
		}
		if (fixed_children_count + dynamic_children_count > 0)
			size -= (fixed_children_count + dynamic_children_count - 1) * a->paddingx;

		int height = 0;
		int modulo = 0;
		if (dynamic_children_count) {
			height = size / dynamic_children_count;
			modulo = size % dynamic_children_count;
			if (height > maximum_size && maximum_size != 0) {
				height = maximum_size;
				modulo = 0;
			}
		}

		// Resize LAYOUT_DYNAMIC objects
		for (GList *l = a->children; l; l = l->next) {
			Area *child = (Area *)l->data;
			if (child->on_screen && child->size_mode == LAYOUT_DYNAMIC) {
				int old_height = child->height;
				child->height = height;
				if (modulo) {
					child->height++;
					modulo--;
				}
				if (child->height != old_height)
					child->_changed = TRUE;
			}
		}
	}
	return 0;
}

void schedule_redraw(Area *a)
{
	a->_redraw_needed = TRUE;

	if (a->has_mouse_over_effect) {
		for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
			XFreePixmap(server.display, a->pix_by_state[i]);
			if (a->pix == a->pix_by_state[i])
				a->pix = None;
			a->pix_by_state[i] = None;
		}
		if (a->pix) {
			XFreePixmap(server.display, a->pix);
			a->pix = None;
		}
	}

	for (GList *l = a->children; l; l = l->next)
		schedule_redraw((Area *)l->data);
	schedule_panel_redraw();
}

void draw_tree(Area *a)
{
	if (!a->on_screen)
		return;

	if (a->_redraw_needed) {
		a->_redraw_needed = FALSE;
		draw(a);
	}

	if (a->pix)
		XCopyArea(server.display,
				  a->pix,
				  ((Panel *)a->panel)->temp_pmap,
				  server.gc,
				  0,
				  0,
				  a->width,
				  a->height,
				  a->posx,
				  a->posy);
	else
		fprintf(stderr, RED "%s %d: area %s has no pixmap!!!" RESET "\n", __FILE__, __LINE__, a->name);

	for (GList *l = a->children; l; l = l->next)
		draw_tree((Area *)l->data);
}

void hide(Area *a)
{
	Area *parent = (Area *)a->parent;

	if (!a->on_screen)
		return;
	a->on_screen = FALSE;
	if (parent)
		parent->resize_needed = TRUE;
	if (panel_horizontal)
		a->width = 0;
	else
		a->height = 0;
}

void show(Area *a)
{
	Area *parent = (Area *)a->parent;

	if (a->on_screen)
		return;
	a->on_screen = TRUE;
	if (parent)
		parent->resize_needed = TRUE;
	a->resize_needed = TRUE;
	schedule_panel_redraw();
}

void update_dependent_gradients(Area *a)
{
	if (!a->on_screen)
		return;
	if (a->_changed) {
		for (GList *l = a->dependent_gradients; l; l = l->next) {
			GradientInstance *gi = (GradientInstance *)l->data;
			update_gradient(gi);
			if (gi->area != a)
				schedule_redraw(gi->area);
		}
	}
	for (GList *l = a->children; l; l = l->next)
		update_dependent_gradients((Area *)l->data);
}

void draw(Area *a)
{
	if (a->_changed) {
		// On resize/move, invalidate cached pixmaps
		for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
			XFreePixmap(server.display, a->pix_by_state[i]);
			if (a->pix == a->pix_by_state[i]) {
				a->pix = None;
			}
			a->pix_by_state[i] = None;
		}
		if (a->pix) {
			XFreePixmap(server.display, a->pix);
			a->pix = None;
		}
	}

	if (a->pix) {
		XFreePixmap(server.display, a->pix);
		if (a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] != a->pix)
			XFreePixmap(server.display, a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0]);
	}
	a->pix = XCreatePixmap(server.display, server.root_win, a->width, a->height, server.depth);
	a->pix_by_state[a->has_mouse_over_effect ? a->mouse_state : 0] = a->pix;

	if (!a->_clear) {
		// Add layer of root pixmap (or clear pixmap if real_transparency==true)
		if (server.real_transparency)
			clear_pixmap(a->pix, 0, 0, a->width, a->height);
		XCopyArea(server.display,
		          ((Panel *)a->panel)->temp_pmap,
		          a->pix,
		          server.gc,
		          a->posx,
		          a->posy,
		          a->width,
		          a->height,
		          0,
		          0);
	} else {
		a->_clear(a);
	}

	cairo_surface_t *cs = cairo_xlib_surface_create(server.display, a->pix, server.visual, a->width, a->height);
	cairo_t *c = cairo_create(cs);

	draw_background(a, c);

	if (a->_draw_foreground)
		a->_draw_foreground(a, c);

	cairo_destroy(c);
	cairo_surface_destroy(cs);
}

void draw_background(Area *a, cairo_t *c)
{
	if ((a->bg->fill_color.alpha > 0.0) ||
	    (panel_config.mouse_effects && (a->has_mouse_over_effect || a->has_mouse_press_effect))) {
		if (a->mouse_state == MOUSE_OVER)
			cairo_set_source_rgba(c,
			                      a->bg->fill_color_hover.rgb[0],
			                      a->bg->fill_color_hover.rgb[1],
			                      a->bg->fill_color_hover.rgb[2],
			                      a->bg->fill_color_hover.alpha);
		else if (a->mouse_state == MOUSE_DOWN)
			cairo_set_source_rgba(c,
			                      a->bg->fill_color_pressed.rgb[0],
			                      a->bg->fill_color_pressed.rgb[1],
			                      a->bg->fill_color_pressed.rgb[2],
			                      a->bg->fill_color_pressed.alpha);
		else
			cairo_set_source_rgba(c,
			                      a->bg->fill_color.rgb[0],
			                      a->bg->fill_color.rgb[1],
			                      a->bg->fill_color.rgb[2],
			                      a->bg->fill_color.alpha);
		// Not sure about this
		draw_rect(c,
		          left_border_width(a),
		          top_border_width(a),
		          a->width - left_right_border_width(a),
		          a->height - top_bottom_border_width(a),
		          a->bg->border.radius - a->bg->border.width / 1.571);

		cairo_fill(c);
	}
	for (GList *l = a->gradient_instances_by_state[a->mouse_state]; l; l = l->next) {
		GradientInstance *gi = (GradientInstance *)l->data;
		if (!gi->pattern)
			update_gradient(gi);
		cairo_set_source(c, gi->pattern);
		draw_rect(c,
		          left_border_width(a),
		          top_border_width(a),
		          a->width - left_right_border_width(a),
		          a->height - top_bottom_border_width(a),
		          a->bg->border.radius - a->bg->border.width / 1.571);
		cairo_fill(c);
	}

	if (a->bg->border.width > 0) {
		cairo_set_line_width(c, a->bg->border.width);

		// draw border inside (x, y, width, height)
		if (a->mouse_state == MOUSE_OVER)
			cairo_set_source_rgba(c,
			                      a->bg->border_color_hover.rgb[0],
			                      a->bg->border_color_hover.rgb[1],
			                      a->bg->border_color_hover.rgb[2],
			                      a->bg->border_color_hover.alpha);
		else if (a->mouse_state == MOUSE_DOWN)
			cairo_set_source_rgba(c,
			                      a->bg->border_color_pressed.rgb[0],
			                      a->bg->border_color_pressed.rgb[1],
			                      a->bg->border_color_pressed.rgb[2],
			                      a->bg->border_color_pressed.alpha);
		else
			cairo_set_source_rgba(c,
			                      a->bg->border.color.rgb[0],
			                      a->bg->border.color.rgb[1],
			                      a->bg->border.color.rgb[2],
			                      a->bg->border.color.alpha);
		draw_rect_on_sides(c,
		                   left_border_width(a) / 2.,
		                   top_border_width(a) / 2.,
		                   a->width - left_right_border_width(a) / 2.,
		                   a->height - top_bottom_border_width(a) / 2.,
		                   a->bg->border.radius,
		                   a->bg->border.mask);

		cairo_stroke(c);
	}
}

void remove_area(Area *a)
{
	Area *area = (Area *)a;
	Area *parent = (Area *)area->parent;

	free_area_gradient_instances(a);

	if (parent) {
		parent->children = g_list_remove(parent->children, area);
		parent->resize_needed = TRUE;
		schedule_panel_redraw();
		schedule_redraw(parent);
	}

	if (mouse_over_area == a) {
		mouse_out();
	}
}

void add_area(Area *a, Area *parent)
{
	g_assert_null(a->parent);

	a->parent = parent;
	if (parent) {
		parent->children = g_list_append(parent->children, a);
		parent->resize_needed = TRUE;
		schedule_redraw(parent);
	}
}

void free_area(Area *a)
{
	if (!a)
		return;

	for (GList *l = a->children; l; l = l->next)
		free_area(l->data);

	if (a->children) {
		g_list_free(a->children);
		a->children = NULL;
	}
	for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
		XFreePixmap(server.display, a->pix_by_state[i]);
		if (a->pix == a->pix_by_state[i]) {
			a->pix = None;
		}
		a->pix_by_state[i] = None;
	}
	if (a->pix) {
		XFreePixmap(server.display, a->pix);
		a->pix = None;
	}
	if (mouse_over_area == a) {
		mouse_over_area = NULL;
	}
	free_area_gradient_instances(a);
}

void mouse_over(Area *area, int pressed)
{
	if (mouse_over_area == area && !area)
		return;

	MouseState new_state = MOUSE_NORMAL;
	if (area) {
		if (!pressed) {
			new_state = area->has_mouse_over_effect ? MOUSE_OVER : MOUSE_NORMAL;
		} else {
			new_state =
			    area->has_mouse_press_effect ? MOUSE_DOWN : area->has_mouse_over_effect ? MOUSE_OVER : MOUSE_NORMAL;
		}
	}

	if (mouse_over_area == area && mouse_over_area->mouse_state == new_state)
		return;
	mouse_out();
	if (new_state == MOUSE_NORMAL)
		return;
	mouse_over_area = area;

	mouse_over_area->mouse_state = new_state;
	mouse_over_area->pix = mouse_over_area->pix_by_state[mouse_over_area->mouse_state];
	if (!mouse_over_area->pix)
		mouse_over_area->_redraw_needed = TRUE;
	schedule_panel_redraw();
}

void mouse_out()
{
	if (!mouse_over_area)
		return;
	mouse_over_area->mouse_state = MOUSE_NORMAL;
	mouse_over_area->pix = mouse_over_area->pix_by_state[mouse_over_area->mouse_state];
	if (!mouse_over_area->pix)
		mouse_over_area->_redraw_needed = TRUE;
	schedule_panel_redraw();
	mouse_over_area = NULL;
}

gboolean area_is_first(void *obj)
{
	Area *a = obj;
	if (!a->on_screen)
		return FALSE;

	Panel *panel = a->panel;

	Area *node = &panel->area;

	while (node) {
		if (!node->on_screen || node->width == 0 || node->height == 0)
			return FALSE;
		if (node == a)
			return TRUE;

		GList *l = node->children;
		node = NULL;
		for (; l; l = l->next) {
			Area *child = l->data;
			if (!child->on_screen || child->width == 0 || child->height == 0)
				continue;
			node = child;
			break;
		}
	}

	return FALSE;
}

gboolean area_is_last(void *obj)
{
	Area *a = obj;
	if (!a->on_screen)
		return FALSE;

	Panel *panel = a->panel;

	Area *node = &panel->area;

	while (node) {
		if (!node->on_screen || node->width == 0 || node->height == 0)
			return FALSE;
		if (node == a)
			return TRUE;

		GList *l = node->children;
		node = NULL;
		for (; l; l = l->next) {
			Area *child = l->data;
			if (!child->on_screen || child->width == 0 || child->height == 0)
				continue;
			node = child;
		}
	}

	return FALSE;
}

gboolean area_is_under_mouse(void *obj, int x, int y)
{
	Area *a = obj;
	if (!a->on_screen || a->width == 0 || a->height == 0)
		return FALSE;

	if (a->_is_under_mouse)
		return a->_is_under_mouse(a, x, y);

	return x >= a->posx && x <= (a->posx + a->width) && y >= a->posy && y <= (a->posy + a->height);
}

gboolean full_width_area_is_under_mouse(void *obj, int x, int y)
{
	Area *a = obj;
	if (!a->on_screen)
		return FALSE;

	if (a->_is_under_mouse && a->_is_under_mouse != full_width_area_is_under_mouse)
		return a->_is_under_mouse(a, x, y);

	if (panel_horizontal)
		return (x >= a->posx) && (x <= a->posx + a->width);
	else
		return (y >= a->posy) && (y <= a->posy + a->height);
}

Area *find_area_under_mouse(void *root, int x, int y)
{
	Area *result = root;
	Area *new_result = result;
	do {
		result = new_result;
		GList *it = result->children;
		while (it) {
			Area *a = (Area *)it->data;
			if (area_is_under_mouse(a, x, y)) {
				new_result = a;
				break;
			}
			it = it->next;
		}
	} while (new_result != result);
	return result;
}

int left_border_width(Area *a)
{
	return left_bg_border_width(a->bg);
}

int right_border_width(Area *a)
{
	return right_bg_border_width(a->bg);
}

int top_border_width(Area *a)
{
	return top_bg_border_width(a->bg);
}

int bottom_border_width(Area *a)
{
	return bottom_bg_border_width(a->bg);
}

int left_right_border_width(Area *a)
{
	return left_right_bg_border_width(a->bg);
}

int top_bottom_border_width(Area *a)
{
	return top_bottom_bg_border_width(a->bg);
}

int bg_border_width(Background *bg, int mask)
{
	return bg->border.mask & mask ? bg->border.width : 0;
}

int left_bg_border_width(Background *bg)
{
	return bg_border_width(bg, BORDER_LEFT);
}

int top_bg_border_width(Background *bg)
{
	return bg_border_width(bg, BORDER_TOP);
}

int right_bg_border_width(Background *bg)
{
	return bg_border_width(bg, BORDER_RIGHT);
}

int bottom_bg_border_width(Background *bg)
{
	return bg_border_width(bg, BORDER_BOTTOM);
}

int left_right_bg_border_width(Background *bg)
{
	return left_bg_border_width(bg) + right_bg_border_width(bg);
}

int top_bottom_bg_border_width(Background *bg)
{
	return top_bg_border_width(bg) + bottom_bg_border_width(bg);
}

void area_dump_geometry(Area *area, int indent)
{
	fprintf(stderr, "%*s%s:\n", indent, "", area->name);
	indent += 2;
	if (!area->on_screen) {
		fprintf(stderr, "%*shidden\n", indent, "");
		return;
	}
	fprintf(stderr,
			"%*sBox: x = %d, y = %d, w = %d, h = %d, desired size = %d\n",
	        indent,
	        "",
	        area->posx,
	        area->posy,
	        area->width,
			area->height,
			compute_desired_size(area));
	fprintf(stderr,
	        "%*sBorder: left = %d, right = %d, top = %d, bottom = %d\n",
	        indent,
	        "",
	        left_border_width(area),
	        right_border_width(area),
	        top_border_width(area),
	        bottom_border_width(area));
	fprintf(stderr,
	        "%*sPadding: left = right = %d, top = bottom = %d, spacing = %d\n",
	        indent,
	        "",
	        area->paddingxlr,
	        area->paddingy,
	        area->paddingx);
	if (area->_dump_geometry)
		area->_dump_geometry(area, indent);
	if (area->children) {
		fprintf(stderr, "%*sChildren:\n", indent, "");
		indent += 2;
		for (GList *l = area->children; l; l = l->next)
			area_dump_geometry((Area *)l->data, indent);
	}
}

Area *compute_element_area(Area *area, Element element)
{
	if (element == ELEMENT_SELF)
		return area;
	if (element == ELEMENT_PARENT)
		return (Area *)area->parent;
	if (element == ELEMENT_PANEL)
		return (Area *)area->panel;
	g_assert_not_reached();
	return area;
}

void instantiate_gradient_offsets(GradientInstance *gi, GList *offsets)
{
	for (GList *l = offsets; l; l = l->next) {
		Offset *offset = (Offset *)l->data;
		if (!offset->constant) {
			Area *element_area = compute_element_area(gi->area, offset->element);
			element_area->dependent_gradients = g_list_append(element_area->dependent_gradients, gi);
		}
	}
}

void free_gradient_offsets(GradientInstance *gi, GList **offsets)
{
	for (GList *l = *offsets; l; l = l->next) {
		Offset *offset = (Offset *)l->data;
		if (!offset->constant) {
			Area *element_area = compute_element_area(gi->area, offset->element);
			element_area->dependent_gradients = g_list_remove_all(element_area->dependent_gradients, gi);
		}
	}
}

void instantiate_gradient_point(GradientInstance *gi, ControlPoint *control)
{
	instantiate_gradient_offsets(gi, control->offsets_x);
	instantiate_gradient_offsets(gi, control->offsets_y);
	instantiate_gradient_offsets(gi, control->offsets_r);
}

void free_gradient_instance_point(GradientInstance *gi, ControlPoint *control)
{
	free_gradient_offsets(gi, &control->offsets_x);
	free_gradient_offsets(gi, &control->offsets_y);
	free_gradient_offsets(gi, &control->offsets_r);
}

void instantiate_gradient(Area *area, GradientClass *g, GradientInstance *gi)
{
	g_assert_nonnull(area);
	g_assert_nonnull(g);
	gi->area = area;
	gi->gradient_class = g;
	instantiate_gradient_point(gi, &g->from);
	instantiate_gradient_point(gi, &g->to);
}

void free_gradient_instance(GradientInstance *gi)
{
	if (gi->pattern) {
		cairo_pattern_destroy(gi->pattern);
		gi->pattern = NULL;
	}
	free_gradient_instance_point(gi, &gi->gradient_class->from);
	free_gradient_instance_point(gi, &gi->gradient_class->to);
	gi->gradient_class = NULL;
}

void instantiate_area_gradients(Area *area)
{
	if (debug_gradients)
		fprintf(stderr, "Initializing gradients for area %s\n", area->name);
	for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
		g_assert_null(area->gradient_instances_by_state[i]);
		GradientClass *g = area->bg->gradients[i];
		if (!g)
			continue;
		GradientInstance *gi = (GradientInstance *)calloc(1, sizeof(GradientInstance));
		instantiate_gradient(area, g, gi);
		area->gradient_instances_by_state[i] = g_list_append(area->gradient_instances_by_state[i], gi);
	}
}

void free_area_gradient_instances(Area *area)
{
	if (debug_gradients)
		fprintf(stderr, "Freeing gradients for area %s\n", area->name);
	for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
		for (GList *l = area->gradient_instances_by_state[i]; l; l = l->next) {
			GradientInstance *gi = (GradientInstance *)l->data;
			free_gradient_instance(gi);
		}
		g_list_free_full(area->gradient_instances_by_state[i], free);
		area->gradient_instances_by_state[i] = NULL;
	}
	g_assert_null(area->dependent_gradients);
}

double compute_control_point_offset(Area *area, Offset *offset)
{
	if (offset->constant)
		return offset->constant_value;

	Area *element_area = compute_element_area(area, offset->element);
	Area *parent_area = ((Area *)area->parent);
	g_assert_nonnull(element_area);
	g_assert_nonnull(parent_area);

	double width = element_area->width;
	double height = element_area->height;
	double radius = sqrt(element_area->width * element_area->width + element_area->height * element_area->height) / 2.0;

	double left, top;
	if (offset->element == ELEMENT_SELF) {
		left = 0;
		top = 0;
	} else if (offset->element == ELEMENT_PARENT) {
		left = parent_area->posx - area->posx;
		top = parent_area->posy - area->posy;
	} else if (offset->element == ELEMENT_PANEL) {
		left = 0 - area->posx;
		top = 0 - area->posy;
	}

	double right = left + width;
	double bottom = top + height;
	double center_x = left + 0.5 * width;
	double center_y = top + 0.5 * height;

	if (offset->variable == SIZE_WIDTH)
		return width * offset->multiplier;
	if (offset->variable == SIZE_HEIGHT)
		return height * offset->multiplier;
	if (offset->variable == SIZE_RADIUS)
		return radius * offset->multiplier;
	if (offset->variable == SIZE_LEFT)
		return left * offset->multiplier;
	if (offset->variable == SIZE_RIGHT)
		return right * offset->multiplier;
	if (offset->variable == SIZE_TOP)
		return top * offset->multiplier;
	if (offset->variable == SIZE_BOTTOM)
		return bottom * offset->multiplier;
	if (offset->variable == SIZE_CENTERX)
		return center_x * offset->multiplier;
	if (offset->variable == SIZE_CENTERY)
		return center_y * offset->multiplier;

	g_assert_not_reached();
	return 0;
}

double compute_control_point_offsets(GradientInstance *gi, GList *offsets)
{
	double result = 0;
	for (GList *l = offsets; l; l = l->next) {
		Offset *offset = (Offset *)l->data;
		result += compute_control_point_offset(gi->area, offset);
	}
	return result;
}

void compute_control_point(GradientInstance *gi, ControlPoint *control, double *x, double *y, double *r)
{
	*x = compute_control_point_offsets(gi, control->offsets_x);
	*y = compute_control_point_offsets(gi, control->offsets_y);
	*r = compute_control_point_offsets(gi, control->offsets_r);
}

void update_gradient(GradientInstance *gi)
{
	if (gi->pattern) {
		return;
		cairo_pattern_destroy(gi->pattern);
		gi->pattern = NULL;
	}
	double from_x, from_y, from_r;
	compute_control_point(gi, &gi->gradient_class->from, &from_x, &from_y, &from_r);
	double to_x, to_y, to_r;
	compute_control_point(gi, &gi->gradient_class->to, &to_x, &to_y, &to_r);
	if (gi->gradient_class->type == GRADIENT_VERTICAL || gi->gradient_class->type == GRADIENT_HORIZONTAL) {
		gi->pattern = cairo_pattern_create_linear(from_x, from_y, to_x, to_y);
		if (debug_gradients)
			fprintf(stderr,
			        "Creating linear gradient for area %s: %f %f, %f %f\n",
			        gi->area->name,
			        from_x,
			        from_y,
			        to_x,
			        to_y);
	} else if (gi->gradient_class->type == GRADIENT_CENTERED) {
		gi->pattern = cairo_pattern_create_radial(from_x, from_y, from_r, to_x, to_y, to_r);
		if (debug_gradients)
			fprintf(stderr,
			        "Creating radial gradient for area %s: %f %f %f, %f %f %f\n",
			        gi->area->name,
			        from_x,
			        from_y,
			        from_r,
			        to_x,
			        to_y,
			        to_r);
	} else {
		g_assert_not_reached();
	}
	if (debug_gradients)
		fprintf(stderr,
		        "Adding color stop at offset %f: %f %f %f %f\n",
		        0.0,
		        gi->gradient_class->start_color.rgb[0],
		        gi->gradient_class->start_color.rgb[1],
		        gi->gradient_class->start_color.rgb[2],
		        gi->gradient_class->start_color.alpha);
	cairo_pattern_add_color_stop_rgba(gi->pattern,
	                                  0,
	                                  gi->gradient_class->start_color.rgb[0],
	                                  gi->gradient_class->start_color.rgb[1],
	                                  gi->gradient_class->start_color.rgb[2],
	                                  gi->gradient_class->start_color.alpha);
	for (GList *l = gi->gradient_class->extra_color_stops; l; l = l->next) {
		ColorStop *color_stop = (ColorStop *)l->data;
		if (debug_gradients)
			fprintf(stderr,
			        "Adding color stop at offset %f: %f %f %f %f\n",
			        color_stop->offset,
			        color_stop->color.rgb[0],
			        color_stop->color.rgb[1],
			        color_stop->color.rgb[2],
			        color_stop->color.alpha);
		cairo_pattern_add_color_stop_rgba(gi->pattern,
		                                  color_stop->offset,
		                                  color_stop->color.rgb[0],
		                                  color_stop->color.rgb[1],
		                                  color_stop->color.rgb[2],
		                                  color_stop->color.alpha);
	}
	if (debug_gradients)
		fprintf(stderr,
		        "Adding color stop at offset %f: %f %f %f %f\n",
		        1.0,
		        gi->gradient_class->end_color.rgb[0],
		        gi->gradient_class->end_color.rgb[1],
		        gi->gradient_class->end_color.rgb[2],
		        gi->gradient_class->end_color.alpha);
	cairo_pattern_add_color_stop_rgba(gi->pattern,
	                                  1.0,
	                                  gi->gradient_class->end_color.rgb[0],
	                                  gi->gradient_class->end_color.rgb[1],
	                                  gi->gradient_class->end_color.rgb[2],
	                                  gi->gradient_class->end_color.alpha);
}
