/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * sheet-style.c: storage mechanism for styles and eventually cells.
 *
 * Copyright (C) 2000-2006 Jody Goldberg (jody@gnome.org)
 * Copyright 2013 Morten Welinder (terra@gnome.org)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) version 3.
 *
 * 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 St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#include <gnumeric-config.h>
#include "sheet-style.h"
#include "gnm-style-impl.h"
#include "ranges.h"
#include "sheet.h"
#include "expr.h"
#include "style.h"
#include "style-border.h"
#include "style-color.h"
#include "style-conditions.h"
#include "parse-util.h"
#include "cell.h"
#include "gutils.h"
#include <goffice/goffice.h>
#include <glib/gi18n-lib.h>
#include <string.h>
#include <math.h>

#define USE_TILE_POOLS 0

/* ------------------------------------------------------------------------- */

/*
 * This is, essentially, an std::multiset implementation for the style hash.
 * Note, however, that sh_lookup is based on gnm_style_equal, not gnm_style_eq.
 */
typedef GHashTable GnmStyleHash;

#if 0
/* This is a really crummy hash -- except for forcing collisions.  */
#define gnm_style_hash(st) 0
#endif

static void
sh_remove (GnmStyleHash *h, GnmStyle *st)
{
	guint32 hv = gnm_style_hash (st);
	GSList *l = g_hash_table_lookup (h, GUINT_TO_POINTER (hv));

	g_return_if_fail (l != NULL);

	if (l->data == st) {
		GSList *next = l->next;
		if (next) {
			/* We're removing the first of several elements.  */
			l->next = NULL;
			g_hash_table_replace (h, GUINT_TO_POINTER (hv), next);
		} else {
			/* We're removing the last element.  */
			g_hash_table_remove (h, GUINT_TO_POINTER (hv));
		}
	} else {
		/* We're removing an element that isn't first.  */
		l = g_slist_remove (l, st);
	}
}

static GnmStyle *
sh_lookup (GnmStyleHash *h, GnmStyle *st)
{
	guint32 hv = gnm_style_hash (st);
	GSList *l = g_hash_table_lookup (h, GUINT_TO_POINTER (hv));
	while (l) {
		GnmStyle *st2 = l->data;
		/* NOTE: This uses gnm_style_equal, not gnm_style_eq.  */
		if (gnm_style_equal (st, st2))
			return st2;
		l = l->next;
	}
	return NULL;
}

static void
sh_insert (GnmStyleHash *h, GnmStyle *st)
{
	GSList *s = g_slist_prepend (NULL, st);
	guint32 hv = gnm_style_hash (st);
	GSList *l = g_hash_table_lookup (h, GUINT_TO_POINTER (hv));
	if (l) {
		s->next = l->next;
		l->next = s;
	} else {
		g_hash_table_insert (h, GUINT_TO_POINTER (hv), s);
	}
}

static GSList *
sh_all_styles (GnmStyleHash *h)
{
	GHashTableIter iter;
	gpointer value;
	GSList *res = NULL;

	g_hash_table_iter_init (&iter, h);
	while (g_hash_table_iter_next (&iter, NULL, &value)) {
		GSList *l = value;
		for (; l; l = l->next)
			res = g_slist_prepend (res, l->data);
	}

	return res;
}

static GnmStyleHash *
sh_create (void)
{
	return g_hash_table_new_full (g_direct_hash, g_direct_equal,
				      NULL, (GDestroyNotify)g_slist_free);
}

static void
sh_destroy (GnmStyleHash *h)
{
	g_hash_table_destroy (h);
}

/* ------------------------------------------------------------------------- */

typedef union _CellTile CellTile;
struct _GnmSheetStyleData {
	/*
	 * style_hash is a set of all styles used by this sheet.  These
	 * styles are all linked.
	 *
	 * We always re-use styles from here when we can, but there can
	 * still be duplicates.  This happens when styles are changed
	 * while they are in the hash.  For example, this happens when
	 * an expression used by a validation style changes due to
	 * row/col insert/delete.
	 */
	GnmStyleHash *style_hash;

	CellTile   *styles;
	GnmStyle   *default_style;
	GnmColor   *auto_pattern_color;
};

static gboolean debug_style_optimize;

typedef struct {
	GnmSheetSize const *ss;
	gboolean recursion;
} CellTileOptimize;

static void
cell_tile_optimize (CellTile **tile, int level, CellTileOptimize *data,
		    int ccol, int crow);


/*
 * sheet_style_unlink
 * For internal use only
 */
void
sheet_style_unlink (Sheet *sheet, GnmStyle *st)
{
	if (sheet->style_data->style_hash)
		sh_remove (sheet->style_data->style_hash, st);
}

/**
 * sheet_style_find:
 * @sheet: (transfer full): the sheet
 * @st: a style
 *
 * Looks up a style from the sheets collection.  Linking if necessary.
 * ABSORBS the reference and adds a link.
 *
 * Returns: (transfer full): the new style.
 */
GnmStyle *
sheet_style_find (Sheet const *sheet, GnmStyle *s)
{
	GnmStyle *res;
	res = sh_lookup (sheet->style_data->style_hash, s);
	if (res != NULL) {
		gnm_style_link (res);
		gnm_style_unref (s);
		return res;
	}

	s = gnm_style_link_sheet (s, (Sheet *)sheet);

	/* Retry the lookup in case "s" changed.  See #585178.  */
	res = sh_lookup (sheet->style_data->style_hash, s);
	if (res != NULL) {
		gnm_style_link (res);
		/*
		 * We are abandoning the linking here.  We cannot use
		 * gnm_style_unlink as that would call sheet_style_unlink
		 * and thus remove "res" from the hash.
		 */
		s->link_count = 0;
		s->linked_sheet = NULL;
		gnm_style_unref (s);

		return res;
	}

	sh_insert (sheet->style_data->style_hash, s);
	return s;
}

/* Place holder until I merge in the new styles too */
static void
pstyle_set_border (GnmStyle *st, GnmBorder *border,
		   GnmStyleBorderLocation side)
{
	gnm_style_set_border (st,
			      GNM_STYLE_BORDER_LOCATION_TO_STYLE_ELEMENT (side),
			      gnm_style_border_ref (border));
}

/* Amortize the cost of applying a partial style over a large region
 * by caching and rereferencing the merged result for repeated styles.
 */
typedef struct {
	GnmStyle   *new_style;
	GnmStyle   *pstyle;
	GHashTable *cache;
	Sheet	   *sheet;
} ReplacementStyle;

static void
rstyle_ctor_style (ReplacementStyle *res, GnmStyle *new_style, Sheet *sheet)
{
	res->sheet = sheet;
	res->new_style = sheet_style_find (sheet, new_style);
	res->pstyle = NULL;
	res->cache = NULL;
}

static void
rstyle_ctor_pstyle (ReplacementStyle *res, GnmStyle *pstyle, Sheet *sheet)
{
	res->sheet = sheet;
	res->new_style = NULL;
	res->pstyle = pstyle;
	res->cache = g_hash_table_new (g_direct_hash, g_direct_equal);
}

static void
cb_style_unlink (gpointer key, gpointer value, G_GNUC_UNUSED gpointer user_data)
{
	gnm_style_unlink ((GnmStyle *)key);
	gnm_style_unlink ((GnmStyle *)value);
}

static void
rstyle_dtor (ReplacementStyle *rs)
{
	if (rs->cache != NULL) {
		g_hash_table_foreach (rs->cache, cb_style_unlink, NULL);
		g_hash_table_destroy (rs->cache);
		rs->cache = NULL;
	}
	if (rs->new_style != NULL) {
		gnm_style_unlink (rs->new_style);
		rs->new_style = NULL;
	}
	if (rs->pstyle != NULL) {
		gnm_style_unref (rs->pstyle);
		rs->pstyle = NULL;
	}
}

/*
 * rstyle_apply:  Utility routine that is at the core of applying partial
 * styles or storing complete styles.  It will eventually be smarter
 * and will maintain the cache of styles associated with each sheet
 */
static void
rstyle_apply (GnmStyle **old, ReplacementStyle *rs, GnmRange const *r)
{
	GnmStyle *s;
	g_return_if_fail (old != NULL);
	g_return_if_fail (rs != NULL);

	if (rs->pstyle != NULL) {
		/* Cache the merged styles keeping a reference to the originals
		 * just in case all instances change.
		 */
		s = g_hash_table_lookup (rs->cache, *old);
		if (s == NULL) {
			GnmStyle *tmp = gnm_style_new_merged (*old, rs->pstyle);
			s = sheet_style_find (rs->sheet, tmp);
			gnm_style_link (*old);
			g_hash_table_insert (rs->cache, *old, s);
		}
	} else
		s = rs->new_style;

	if (*old != s) {
		if (*old) {
			gnm_style_unlink_dependents (*old, r);
			gnm_style_unlink (*old);
		}

		gnm_style_link_dependents (s, r);
		gnm_style_link (s);

		*old = s;
	}
}

void
sheet_style_clear_style_dependents (Sheet *sheet, GnmRange const *r)
{
	GSList *styles = sh_all_styles (sheet->style_data->style_hash);
	g_slist_foreach (styles,
			 (GFunc)gnm_style_unlink_dependents,
			 (gpointer)r);
	g_slist_free (styles);
}


/****************************************************************************/

/* If you change this, change the tile_{widths,heights} here
 * and GNM_MAX_COLS and GNM_MAX_ROWS in gnumeric.h */
#define TILE_TOP_LEVEL 6

#define TILE_SIZE_COL 8
#define	TILE_SIZE_ROW 16

typedef enum {
	TILE_UNDEFINED	= -1,
	TILE_SIMPLE	=  0,
	TILE_COL	=  1,
	TILE_ROW	=  2,
	TILE_MATRIX	=  3,
	TILE_PTR_MATRIX	=  4
} CellTileType;
static int const tile_size[/*type*/] = {
	1,				/* TILE_SIMPLE */
	TILE_SIZE_COL,			/* TILE_COL */
	TILE_SIZE_ROW,			/* TILE_ROW */
	TILE_SIZE_COL * TILE_SIZE_ROW	/* TILE_MATRIX */
};
static int const tile_col_count[/*type*/] = {
	1,				/* TILE_SIMPLE */
	TILE_SIZE_COL,			/* TILE_COL */
	1,				/* TILE_ROW */
	TILE_SIZE_COL,			/* TILE_MATRIX */
	TILE_SIZE_COL			/* TILE_PTR_MATRIX */
};
static int const tile_row_count[/*type*/] = {
	1,				/* TILE_SIMPLE */
	1,				/* TILE_COL */
	TILE_SIZE_ROW,			/* TILE_ROW */
	TILE_SIZE_ROW,			/* TILE_MATRIX */
	TILE_SIZE_ROW			/* TILE_PTR_MATRIX */
};
static const char * const tile_type_str[/*type*/] = {
	"simple", "col", "row", "matrix", "ptr-matrix"
};
static int const tile_widths[/*level*/] = {
	1,
	TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL,
	TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL * TILE_SIZE_COL
};
static int const tile_heights[/*level*/] = {
	1,
	TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW,
	TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW * TILE_SIZE_ROW
};

typedef struct {
	CellTileType const type;
	GnmStyle *style[1];
} CellTileStyleSimple;
typedef struct {
	CellTileType const type;
	GnmStyle *style[TILE_SIZE_COL];
} CellTileStyleCol;
typedef struct {
	CellTileType const type;
	GnmStyle *style[TILE_SIZE_ROW];
} CellTileStyleRow;
typedef struct {
	CellTileType const type;
	GnmStyle *style[TILE_SIZE_COL * TILE_SIZE_ROW];
} CellTileStyleMatrix;
typedef struct {
	CellTileType const type;
	CellTile	*ptr[TILE_SIZE_COL * TILE_SIZE_ROW];
} CellTilePtrMatrix;

union _CellTile {
	CellTileType const type;
	CellTileStyleSimple	style_any;
	CellTileStyleSimple	style_simple;
	CellTileStyleCol	style_col;
	CellTileStyleRow	style_row;
	CellTileStyleMatrix	style_matrix;
	CellTilePtrMatrix	ptr_matrix;
};

static int active_sheet_count;
#if USE_TILE_POOLS
static GOMemChunk *tile_pools[5];
#define CHUNK_ALLOC(T,ctt) ((T*)go_mem_chunk_alloc (tile_pools[(ctt)]))
#define CHUNK_FREE(ctt,v) go_mem_chunk_free (tile_pools[(ctt)], (v))
#else
static const size_t tile_type_sizeof[5] = {
	sizeof (CellTileStyleSimple),
	sizeof (CellTileStyleCol),
	sizeof (CellTileStyleRow),
	sizeof (CellTileStyleMatrix),
	sizeof (CellTilePtrMatrix)
};
static int tile_allocations = 0;
#if 1
#define CHUNK_ALLOC(T,ctt) (tile_allocations++, (T*)g_slice_alloc (tile_type_sizeof[(ctt)]))
#define CHUNK_FREE(ctt,v) (tile_allocations--, g_slice_free1 (tile_type_sizeof[(ctt)], (v)))
#else
#define CHUNK_ALLOC(T,ctt) (tile_allocations++, (T*)g_malloc (tile_type_sizeof[(ctt)]))
#define CHUNK_FREE(ctt,v) (tile_allocations--, g_free ((v)))
#endif
#endif


/*
 * Destroy a CellTile (recursively if needed).  This will unlink all the
 * styles in it.  We do _not_ unlink style dependents here.  That is done
 * only in rstyle_apply.
 */
static void
cell_tile_dtor (CellTile *tile)
{
	CellTileType t;

	g_return_if_fail (tile != NULL);

	t = tile->type;
	if (t == TILE_PTR_MATRIX) {
		int i = TILE_SIZE_COL * TILE_SIZE_ROW;
		while (--i >= 0) {
			cell_tile_dtor (tile->ptr_matrix.ptr[i]);
			tile->ptr_matrix.ptr[i] = NULL;
		}
	} else if (TILE_SIMPLE <= t && t <= TILE_MATRIX) {
		int i = tile_size[t];
		while (--i >= 0) {
			gnm_style_unlink (tile->style_any.style[i]);
			tile->style_any.style[i] = NULL;
		}
	} else {
		g_return_if_fail (FALSE); /* don't free anything */
	}

	*((CellTileType *)&(tile->type)) = TILE_UNDEFINED; /* poison it */
	CHUNK_FREE (t, tile);
}

static CellTile *
cell_tile_style_new (GnmStyle *style, CellTileType t)
{
	CellTile *res = CHUNK_ALLOC (CellTile, t);
	*((CellTileType *)&(res->type)) = t;

	if (style != NULL) {
		int i = tile_size[t];
		gnm_style_link_multiple (style, i);
		while (--i >= 0)
			res->style_any.style[i] = style;
	}

	return res;
}

static CellTile *
cell_tile_ptr_matrix_new (CellTile *t)
{
	CellTilePtrMatrix *res;

	g_return_val_if_fail (t != NULL, NULL);
	g_return_val_if_fail (TILE_SIMPLE <= t->type &&
			      TILE_MATRIX >= t->type, NULL);

	res = CHUNK_ALLOC (CellTilePtrMatrix, TILE_PTR_MATRIX);
	*((CellTileType *)&(res->type)) = TILE_PTR_MATRIX;

	/* TODO:
	 * If we wanted to get fancy we could use self similarity to decrease
	 * the number of subtiles.  However, this would increase the cost of
	 * applying changes later so I'm not sure it is worth the effort.
	 */
	switch (t->type) {
	case TILE_SIMPLE: {
		int i = TILE_SIZE_COL * TILE_SIZE_ROW;
		while (--i >= 0)
			res->ptr[i] = cell_tile_style_new (
				t->style_simple.style[0], TILE_SIMPLE);
		break;
	}
	case TILE_COL: {
		int i, r, c;
		for (i = r = 0 ; r < TILE_SIZE_ROW ; ++r)
			for (c = 0 ; c < TILE_SIZE_COL ; ++c)
				res->ptr[i++] = cell_tile_style_new (
					t->style_col.style[c], TILE_SIMPLE);
		break;
	}
	case TILE_ROW: {
		int i, r, c;
		for (i = r = 0 ; r < TILE_SIZE_ROW ; ++r)
			for (c = 0 ; c < TILE_SIZE_COL ; ++c)
				res->ptr[i++] = cell_tile_style_new (
					t->style_row.style[r], TILE_SIMPLE);
		break;
	}
	case TILE_MATRIX: {
		int i = TILE_SIZE_COL * TILE_SIZE_ROW;
		while (--i >= 0)
			res->ptr[i] = cell_tile_style_new (
				t->style_matrix.style[i], TILE_SIMPLE);
		break;
	}
	default: ;
	}

	return (CellTile *)res;
}

static CellTile *
cell_tile_matrix_set (CellTile *t)
{
	int r, c;
	CellTileStyleMatrix *res;

	g_return_val_if_fail (t != NULL, NULL);
	g_return_val_if_fail (TILE_SIMPLE <= t->type &&
			      TILE_MATRIX >= t->type, NULL);

	if (t->type == TILE_MATRIX)
		return t;

	res = (CellTileStyleMatrix *)cell_tile_style_new (NULL, TILE_MATRIX);

	switch (t->type) {
	case TILE_SIMPLE: {
		GnmStyle *tmp = t->style_simple.style[0];
		int i = TILE_SIZE_COL * TILE_SIZE_ROW;
		gnm_style_link_multiple (tmp, i);
		while (--i >= 0)
			res->style[i] = tmp;
		break;
	}

	case TILE_COL: {
		int i = 0;
		for (r = 0; r < TILE_SIZE_ROW; ++r)
			for (c = 0; c < TILE_SIZE_COL; ++c)
				gnm_style_link (res->style[i++] =
						t->style_col.style[c]);
		break;
	}

	case TILE_ROW: {
		int i = 0;
		for (r = 0; r < TILE_SIZE_ROW; ++r) {
			GnmStyle *tmp = t->style_row.style[r];
			gnm_style_link_multiple (tmp, TILE_SIZE_COL);
			for (c = 0; c < TILE_SIZE_COL; ++c)
				res->style[i++] = tmp;
		}
		break;
	}

	case TILE_MATRIX:
	default:
		g_assert_not_reached();
	}

	cell_tile_dtor (t);

	return (CellTile *)res;
}

/****************************************************************************/

static void
sheet_style_sanity_check (void)
{
	unsigned c, r;
	int i;

	for (c = 1, i = 0; i <= TILE_TOP_LEVEL; i++) {
		g_assert (c < G_MAXUINT / TILE_SIZE_COL);
		c *= TILE_SIZE_COL;
	}
	g_assert (c >= GNM_MAX_COLS);

	for (r = 1, i = 0; i <= TILE_TOP_LEVEL; i++) {
		g_assert (r < G_MAXUINT / TILE_SIZE_COL);
		r *= TILE_SIZE_ROW;
	}
	g_assert (r >= GNM_MAX_ROWS);

	g_assert (G_N_ELEMENTS (tile_heights) > TILE_TOP_LEVEL + 1);

	g_assert (G_N_ELEMENTS (tile_widths) > TILE_TOP_LEVEL + 1);
}

static void
sheet_style_init_size (Sheet *sheet, int cols, int rows)
{
	GnmStyle *default_style;
	int lc = 0, lr = 0, w = TILE_SIZE_COL, h = TILE_SIZE_ROW;

	while (w < cols) {
		w *= TILE_SIZE_COL;
		lc++;
	}
	while (h < rows) {
		h *= TILE_SIZE_ROW;
		lr++;
	}
	sheet->tile_top_level = MAX (lc, lr);

	if (active_sheet_count++ == 0) {
#if USE_TILE_POOLS
		tile_pools[TILE_SIMPLE] =
			go_mem_chunk_new ("simple tile pool",
					   sizeof (CellTileStyleSimple),
					   16 * 1024 - 128);
		tile_pools[TILE_COL] =
			go_mem_chunk_new ("column tile pool",
					   sizeof (CellTileStyleCol),
					   16 * 1024 - 128);
		tile_pools[TILE_ROW] =
			go_mem_chunk_new ("row tile pool",
					   sizeof (CellTileStyleRow),
					   16 * 1024 - 128);
		tile_pools[TILE_MATRIX] =
			go_mem_chunk_new ("matrix tile pool",
					   sizeof (CellTileStyleMatrix),
					   MAX (16 * 1024 - 128,
						100 * sizeof (CellTileStyleMatrix)));

		/* If this fails one day, just make two pools.  */
		g_assert (sizeof (CellTileStyleMatrix) == sizeof (CellTilePtrMatrix));
		tile_pools[TILE_PTR_MATRIX] = tile_pools[TILE_MATRIX];
#endif
	}

	sheet->style_data = g_new (GnmSheetStyleData, 1);
	sheet->style_data->style_hash = sh_create ();

	{
		GnmColor *ap = style_color_auto_pattern ();
#warning "FIXME: Allocating a GnmColor here is dubious."
		sheet->style_data->auto_pattern_color = g_new (GnmColor, 1);
		*sheet->style_data->auto_pattern_color = *ap;
		sheet->style_data->auto_pattern_color->ref_count = 1;
		style_color_unref (ap);
	}

	default_style =  gnm_style_new_default ();
#if 0
	/* We can not do this, XL creates full page charts with background
	 * 'none' by default.  Then displays that as white. */
	if (sheet->sheet_type == GNM_SHEET_OBJECT) {
		gnm_style_set_back_color (default_style,
			gnm_color_new_rgb8 (0x50, 0x50, 0x50));
		gnm_style_set_pattern (default_style, 1);
	}
#endif
	sheet->style_data->default_style =
		sheet_style_find (sheet, default_style);
	sheet->style_data->styles =
		cell_tile_style_new (sheet->style_data->default_style,
				     TILE_SIMPLE);
}

void
sheet_style_init (Sheet *sheet)
{
	int cols = gnm_sheet_get_max_cols (sheet);
	int rows = gnm_sheet_get_max_rows (sheet);

	debug_style_optimize = gnm_debug_flag ("style-optimize");

	sheet_style_sanity_check ();

	sheet_style_init_size (sheet, cols, rows);
}

void
sheet_style_resize (Sheet *sheet, int cols, int rows)
{
	GnmStyleList *styles, *l;
	int old_cols = gnm_sheet_get_max_cols (sheet);
	int old_rows = gnm_sheet_get_max_rows (sheet);
	GnmRange save_range, new_full;

	/* Save the style for the surviving area.  */
	range_init (&save_range, 0, 0,
		    MIN (cols, old_cols) - 1, MIN (rows, old_rows) - 1);
	styles = sheet_style_get_range (sheet, &save_range);

	/* Build new empty structures.  */
	sheet_style_shutdown (sheet);
	sheet_style_init_size (sheet, cols, rows);

	/* Reapply styles.  */
	range_init (&new_full, 0, 0, cols - 1, rows - 1);
	for (l = styles; l; l = l->next) {
		GnmStyleRegion const *sr = l->data;
		GnmRange const *r = &sr->range;
		GnmStyle *style = sr->style;
		GnmRange newr;
		if (range_intersection (&newr, r, &new_full)) {
			gnm_style_ref (style);
			sheet_style_apply_range (sheet, &newr, style);
		}
	}

	style_list_free	(styles);
}

#if USE_TILE_POOLS
static void
cb_tile_pool_leak (gpointer data, gpointer user)
{
	CellTile *tile = data;
	g_printerr ("Leaking tile at %p.\n", (void *)tile);
}
#endif

void
sheet_style_shutdown (Sheet *sheet)
{
	GnmStyleHash *table;
	GnmRange r;

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (sheet->style_data != NULL);

	/*
	 * Clear all styles.  This is an easy way to clear out all
	 * style dependencies.
	 */
	range_init_full_sheet (&r, sheet);
	sheet_style_set_range (sheet, &r, sheet_style_default (sheet));

	cell_tile_dtor (sheet->style_data->styles);
	sheet->style_data->styles = NULL;

	sheet->style_data->default_style = NULL;

	/* Clear the pointer to the hash BEFORE clearing and add a test in
	 * sheet_style_unlink.  If we don't then it is possible/probable that
	 * unlinking the styles will attempt to remove them from the hash while
	 * we are walking it.
	 */
	table = sheet->style_data->style_hash;
	sheet->style_data->style_hash = NULL;
	g_slist_free_full (sh_all_styles (table),
			   (GDestroyNotify)gnm_style_unlink);
	sh_destroy (table);
	style_color_unref (sheet->style_data->auto_pattern_color);

	g_free (sheet->style_data);
	sheet->style_data = NULL;

	if (--active_sheet_count == 0) {
#if USE_TILE_POOLS
		go_mem_chunk_foreach_leak (tile_pools[TILE_SIMPLE],
					    cb_tile_pool_leak, NULL);
		go_mem_chunk_destroy (tile_pools[TILE_SIMPLE], FALSE);
		tile_pools[TILE_SIMPLE] = NULL;

		go_mem_chunk_foreach_leak (tile_pools[TILE_COL],
					    cb_tile_pool_leak, NULL);
		go_mem_chunk_destroy (tile_pools[TILE_COL], FALSE);
		tile_pools[TILE_COL] = NULL;

		go_mem_chunk_foreach_leak (tile_pools[TILE_ROW],
					    cb_tile_pool_leak, NULL);
		go_mem_chunk_destroy (tile_pools[TILE_ROW], FALSE);
		tile_pools[TILE_ROW] = NULL;

		go_mem_chunk_foreach_leak (tile_pools[TILE_MATRIX],
					    cb_tile_pool_leak, NULL);
		go_mem_chunk_destroy (tile_pools[TILE_MATRIX], FALSE);
		tile_pools[TILE_MATRIX] = NULL;

		/* If this fails one day, just make two pools.  */
		g_assert (sizeof (CellTileStyleMatrix) == sizeof (CellTilePtrMatrix));
		tile_pools[TILE_PTR_MATRIX] = NULL;
#else
		if (tile_allocations)
			g_printerr ("Leaking %d style tiles.\n", tile_allocations);
#endif
	}
}

/**
 * sheet_style_set_auto_pattern_color:
 * @sheet: The sheet
 * @grid_color: The color
 *
 * Set the color for rendering auto colored patterns in this sheet.
 * Absorbs a reference to @pattern_color;
 **/
void
sheet_style_set_auto_pattern_color (Sheet *sheet, GnmColor *pattern_color)
{
	GnmColor *apc;
	int ref_count;

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (sheet->style_data != NULL);

	apc = sheet->style_data->auto_pattern_color;
	ref_count = apc->ref_count;
	*apc = *pattern_color;
	apc->is_auto = TRUE;
	apc->ref_count = ref_count;
	style_color_unref (pattern_color);
}

/**
 * sheet_style_get_auto_pattern_color:
 * @sheet: the sheet
 *
 * Caller receives a reference to the result.
 * Returns the color for rendering auto colored patterns in this sheet.
 **/
GnmColor *
sheet_style_get_auto_pattern_color (Sheet const *sheet)
{
	GnmColor *sc;
	g_return_val_if_fail (IS_SHEET (sheet), style_color_black ());
	g_return_val_if_fail (sheet->style_data != NULL, style_color_black ());
	g_return_val_if_fail (sheet->style_data->auto_pattern_color != NULL,
			      style_color_black ());

	sc = sheet->style_data->auto_pattern_color;
	style_color_ref (sc);

	return sc;
}

/**
 * sheet_style_update_grid_color:
 *
 * This function updates the color of gnm_style_border_none when the sheet to be
 * rendered is known. gnm_style_border_none tells how to render the
 * grid. Because the grid color may be different for different sheets, the
 * functions which render the grid call this function first.  The rule for
 * selecting the grid color, which is the same as in Excel, is: - if the
 * auto pattern color is default (which is black), the grid color is gray,
 * as returned by style_color_grid ().  - otherwise, the auto pattern color
 * is used for the grid.
 */
void
sheet_style_update_grid_color (Sheet const *sheet)
{
	GnmColor *default_auto = style_color_auto_pattern ();
	GnmColor *sheet_auto = sheet_style_get_auto_pattern_color (sheet);
	GnmColor *grid_color = style_color_grid ();
	GnmColor *new_color;

	new_color = (style_color_equal (default_auto, sheet_auto)
		     ? grid_color : sheet_auto);

	/* Do nothing if we already have the right color */
	if (gnm_style_border_none()->color != new_color) {
		style_color_ref (new_color); /* none_set eats the ref */
		gnm_style_border_none_set_color (new_color);
	}
	style_color_unref (grid_color);
	style_color_unref (sheet_auto);
	style_color_unref (default_auto);
}

/****************************************************************************/

static gboolean
tile_is_uniform (CellTile const *tile)
{
	const int s = tile_size[tile->type];
	GnmStyle const *st = tile->style_any.style[0];
	int i;

	for (i = 1; i < s; i++)
		if (tile->style_any.style[i] != st)
			return FALSE;

	return TRUE;
}

static void
vector_apply_pstyle (CellTile *tile, ReplacementStyle *rs,
		     int cc, int cr, int level, GnmRange const *indic)
{
	const CellTileType type = tile->type;
	const int ncols = tile_col_count[type];
	const int nrows = tile_row_count[type];
	const int w1 = tile_widths[level + 1] / ncols;
	const int h1 = tile_heights[level + 1] / nrows;
	const int fcol = indic->start.col;
	const int frow = indic->start.row;
	const int lcol = MIN (ncols - 1, indic->end.col);
	const int lrow = MIN (nrows - 1, indic->end.row);
	GnmSheetSize const *ss = gnm_sheet_get_size (rs->sheet);
	int r, c;
	GnmRange rng;

	for (r = frow; r <= lrow; r++) {
		GnmStyle **st = tile->style_any.style + ncols * r;
		rng.start.row = cr + h1 * r;
		rng.end.row = MIN (rng.start.row + (h1 - 1),
				   ss->max_rows - 1);
		for (c = fcol; c <= lcol; c++) {
			rng.start.col = cc + w1 * c;
			rng.end.col = MIN (rng.start.col + (w1 - 1),
					   ss->max_cols - 1);
			rstyle_apply (st + c, rs, &rng);
		}
	}
}

/*
 * Determine whether before applying a style in the area of apply_to
 * one needs to split the tile column-wise.
 *
 * If FALSE is returned then the tile need to be split to a TILE_PTR_MATRIX
 * because the current level is not fine-grained enough.
 *
 * If TRUE is returned, TILE_SIMPLE needs to be split into TILE_COL and
 * TILE_ROW needs to be split into TILE_MATRIX.  TILE_COL and TILE_MATRIX
 * should be kept.  In indic, the inclusive post-split indicies of the
 * range will be returned.
 *
 * If apply_to covers the entire tile, TRUE will be returned and the judgement
 * on splitting above should be ignored.  The indices in indic will be as-if
 * the split was done.
 */
static gboolean
col_indicies (int corner_col, int w, GnmRange const *apply_to,
	      GnmRange *indec)
{
	int i, tmp;

	i = apply_to->start.col - corner_col;
	if (i <= 0)
		indec->start.col = 0;
	else {
		tmp = i / w;
		if (i != tmp * w)
			return FALSE;
		indec->start.col = tmp;
	}

	i = 1 + apply_to->end.col - corner_col;
	tmp = i / w;
	if (tmp >= TILE_SIZE_COL)
		indec->end.col = TILE_SIZE_COL - 1;
	else {
		if (i != tmp * w)
			return FALSE;
		indec->end.col = tmp - 1;
	}

	return TRUE;
}

/* See docs for col_indicies.  Swap cols and rows.  */
static gboolean
row_indicies (int corner_row, int h, GnmRange const *apply_to,
	      GnmRange *indic)
{
	int i, tmp;

	i = apply_to->start.row - corner_row;
	if (i <= 0)
		indic->start.row = 0;
	else {
		int tmp = i / h;
		if (i != tmp * h)
			return FALSE;
		indic->start.row = tmp;
	}

	i = 1 + apply_to->end.row - corner_row;
	tmp = i / h;
	if (tmp >= TILE_SIZE_ROW)
		indic->end.row = TILE_SIZE_ROW - 1;
	else {
		if (i != tmp * h)
			return FALSE;
		indic->end.row = tmp - 1;
	}

	return TRUE;
}

/*
 * cell_tile_apply: This is the primary logic for making changing areas in the
 * tree.  It could be further optimised if it becomes a bottle neck.
 */
static void
cell_tile_apply (CellTile **tile, int level,
		 int corner_col, int corner_row,
		 GnmRange const *apply_to,
		 ReplacementStyle *rs)
{
	int const width = tile_widths[level+1];
	int const height = tile_heights[level+1];
	int const w = tile_widths[level];
	int const h = tile_heights[level];
	gboolean const full_width = (apply_to->start.col <= corner_col &&
				     apply_to->end.col >= (corner_col+width-1));
	gboolean const full_height = (apply_to->start.row <= corner_row &&
				      apply_to->end.row >= (corner_row+height-1));
	GnmRange indic;
	CellTileType type;
	int c, r, i;

	g_return_if_fail (TILE_TOP_LEVEL >= level && level >= 0);
	g_return_if_fail (tile != NULL);
	g_return_if_fail (*tile != NULL);

	type = (*tile)->type;
	g_return_if_fail (TILE_SIMPLE <= type && type <= TILE_PTR_MATRIX);

	/* applying the same style to part of a simple-tile is a nop */
	if (type == TILE_SIMPLE &&
	    (*tile)->style_simple.style[0] == rs->new_style)
		return;

	/*
	 * Indices for the whole tile assuming a split to matrix.
	 * We can still use these indices if we don't split either way.
	 */
	indic.start.col = 0;
	indic.start.row = 0;
	indic.end.col = TILE_SIZE_COL - 1;
	indic.end.row = TILE_SIZE_ROW - 1;

	if (type == TILE_PTR_MATRIX)
		goto drill_down;
	else if (full_width && full_height)
		goto apply;
	else if (full_height) {
		if (!col_indicies (corner_col, w, apply_to, &indic))
			goto split_to_ptr_matrix;

		switch (type) {
		case TILE_SIMPLE: {
			CellTile *res;
			type = TILE_COL;
			res = cell_tile_style_new (
				(*tile)->style_simple.style[0],
				type);
			cell_tile_dtor (*tile);
			*tile = res;
			/* Fall through */
		}
		case TILE_COL:
		case TILE_MATRIX:
			goto apply;
		case TILE_ROW:
			goto split_to_matrix;
		default:
			g_assert_not_reached ();
		}
	} else if (full_width) {
		if (!row_indicies (corner_row, h, apply_to, &indic))
			goto split_to_ptr_matrix;
		switch (type) {
		case TILE_SIMPLE: {
			CellTile *res;

			type = TILE_ROW;
			res = cell_tile_style_new (
				(*tile)->style_simple.style[0],
				type);
			cell_tile_dtor (*tile);
			*tile = res;
			/* Fall through */
		}
		case TILE_ROW:
		case TILE_MATRIX:
			goto apply;
		case TILE_COL:
			goto split_to_matrix;
		default:
			g_assert_not_reached ();
		}
	} else {
		if (col_indicies (corner_col, w, apply_to, &indic) &&
		    row_indicies (corner_row, h, apply_to, &indic))
			goto split_to_matrix;
		else
			goto split_to_ptr_matrix;
	}

	g_assert_not_reached ();

split_to_matrix:
	*tile = cell_tile_matrix_set (*tile);

apply:
	vector_apply_pstyle (*tile, rs, corner_col, corner_row, level, &indic);

try_optimize:
	{
		CellTileOptimize cto;
		cto.ss = gnm_sheet_get_size (rs->sheet);
		cto.recursion = FALSE;
		cell_tile_optimize (tile, level, &cto, corner_col, corner_row);
	}
	return;

split_to_ptr_matrix:
	/*
	 * We get here when apply_to's corners are not on a TILE_MATRIX grid.
	 * Split to pointer matrix whose element tiles will have a finer grid.
	 */
	g_return_if_fail (type != TILE_PTR_MATRIX);
	{
		CellTile *res = cell_tile_ptr_matrix_new (*tile);
		cell_tile_dtor (*tile);
		*tile = res;
		type = TILE_PTR_MATRIX;
	}

drill_down:
	g_return_if_fail (type == TILE_PTR_MATRIX);
	for (i = r = 0 ; r < TILE_SIZE_ROW ; ++r, i += TILE_SIZE_COL) {
		int const cr = corner_row + h*r;
		if (cr > apply_to->end.row)
			break;
		if ((cr + h) <= apply_to->start.row)
			continue;

		for (c = 0 ; c < TILE_SIZE_COL ; ++c) {
			int const cc = corner_col + w*c;
			if (cc > apply_to->end.col)
				break;
			if ((cc + w) <= apply_to->start.col)
				continue;

			cell_tile_apply ((*tile)->ptr_matrix.ptr + i + c,
					 level - 1, cc, cr, apply_to, rs);
		}
	}
	goto try_optimize;
}

/* Handler for foreach_tile.
 *
 * "width" and "height" refer to tile size which may extend beyond
 * the range supplied to foreach_tile and even beyond the sheet.
 */
typedef void (*ForeachTileFunc) (GnmStyle *style,
				 int corner_col, int corner_row, int width, int height,
				 GnmRange const *apply_to, gpointer user);
static void
foreach_tile (CellTile *tile, int level,
	      int corner_col, int corner_row,
	      GnmRange const *apply_to,
	      ForeachTileFunc handler,
	      gpointer user)
{
	int const width = tile_widths[level+1];
	int const height = tile_heights[level+1];
	int const w = tile_widths[level];
	int const h = tile_heights[level];
	int c, r, i, last;

	g_return_if_fail (TILE_TOP_LEVEL >= level && level >= 0);
	g_return_if_fail (tile != NULL);

	switch (tile->type) {
	case TILE_SIMPLE:
		handler (tile->style_simple.style[0],
			 corner_col, corner_row, width, height,
			 apply_to, user);
		break;

	case TILE_COL:
		if (apply_to != NULL) {
			c = (apply_to->start.col - corner_col) / w;
			if (c < 0)
				c = 0;
			last = (apply_to->end.col - corner_col) / w + 1;
			if (last > TILE_SIZE_COL)
				last = TILE_SIZE_COL;
		} else {
			c = 0;
			last = TILE_SIZE_COL;
		}
		for (; c < last ; ++c)
			handler (tile->style_col.style[c],
				 corner_col + c*w, corner_row, w, height,
				 apply_to, user);
		break;

	case TILE_ROW:
		if (apply_to != NULL) {
			r = (apply_to->start.row - corner_row) / h;
			if (r < 0)
				r = 0;
			last = (apply_to->end.row - corner_row) / h + 1;
			if (last > TILE_SIZE_ROW)
				last = TILE_SIZE_ROW;
		} else {
			r = 0;
			last = TILE_SIZE_ROW;
		}
		for (; r < last ; ++r)
			handler (tile->style_row.style[r],
				 corner_col, corner_row + r*h, width, h,
				 apply_to, user);
		break;

	case TILE_MATRIX:
	case TILE_PTR_MATRIX:
		for (i = r = 0 ; r < TILE_SIZE_ROW ; ++r, i += TILE_SIZE_COL) {
			int const cr = corner_row + h*r;
			if (apply_to) {
				if (cr > apply_to->end.row)
					break;
				if ((cr + h) <= apply_to->start.row)
					continue;
			}

			for (c = 0 ; c < TILE_SIZE_COL ; ++c) {
				int const cc = corner_col + w*c;
				if (apply_to) {
					if (cc > apply_to->end.col)
						break;
					if ((cc + w) <= apply_to->start.col)
						continue;
				}

				if (tile->type == TILE_MATRIX) {
					handler (tile->style_matrix.style[r*TILE_SIZE_COL+c],
						 corner_col + c * w,
						 corner_row + r * h,
						 w, h, apply_to, user);
				} else {
					foreach_tile (
						tile->ptr_matrix.ptr[c + r*TILE_SIZE_COL],
						level-1, cc, cr, apply_to, handler, user);
				}
			}
		}
		break;

	default:
		g_warning ("Adaptive Quad Tree corruption !");
	}
}

/*
 * cell_tile_apply_pos: This is an simplified version of cell_tile_apply.  It
 * does not need all the bells and whistles because it operates on single cells.
 */
static void
cell_tile_apply_pos (CellTile **tile, int level,
		     int col, int row,
		     ReplacementStyle *rs)
{
	CellTile *tmp;
	CellTileType type;
	GnmRange rng;

	g_return_if_fail (col >= 0);
	g_return_if_fail (col < gnm_sheet_get_max_cols (rs->sheet));
	g_return_if_fail (row >= 0);
	g_return_if_fail (row < gnm_sheet_get_max_rows (rs->sheet));

	range_init (&rng, col, row, col, row);

tail_recursion:
	g_return_if_fail (TILE_TOP_LEVEL >= level && level >= 0);
	g_return_if_fail (tile != NULL);
	g_return_if_fail (*tile != NULL);

	tmp = *tile;
	type = tmp->type;
	g_return_if_fail (TILE_SIMPLE <= type && type <= TILE_PTR_MATRIX);

	if (level > 0) {
		int const w = tile_widths[level];
		int const c = col / w;
		int const h = tile_heights[level];
		int const r = row / h;

		if (type != TILE_PTR_MATRIX) {
			/* applying the same style to part of a simple-tile is a nop */
			if (type == TILE_SIMPLE &&
			    (*tile)->style_simple.style[0] == rs->new_style)
				return;

			tmp = cell_tile_ptr_matrix_new (tmp);
			cell_tile_dtor (*tile);
			*tile = tmp;
		}
		tile = tmp->ptr_matrix.ptr + r * TILE_SIZE_COL + c;
		level--;
		col -= c*w;
		row -= r*h;
		goto tail_recursion;
	} else if (type != TILE_MATRIX)
		*tile = tmp = cell_tile_matrix_set (tmp);

	g_return_if_fail (tmp->type == TILE_MATRIX);
	rstyle_apply (tmp->style_matrix.style + row * TILE_SIZE_COL + col,
		      rs,
		      &rng);
}

/**
 * sheet_style_set_range:
 * @sheet:
 * @range:
 * @style: #GnmStyle
 *
 * Change the complete style for a region.
 * This function absorbs a reference to the new @style.
 */
void
sheet_style_set_range (Sheet *sheet, GnmRange const *range,
		       GnmStyle *style)
{
	ReplacementStyle rs;

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (range != NULL);

	rstyle_ctor_style (&rs, style, sheet);
	cell_tile_apply (&sheet->style_data->styles,
			 sheet->tile_top_level, 0, 0,
			 range, &rs);
	rstyle_dtor (&rs);
}

/**
 * sheet_style_apply_col:
 * @sheet:
 * @col:
 * @style: #GnmStyle
 *
 * NOTE: This is a simple wrapper for now.  When we support col/row styles it
 *	will make life easier.
 *
 * Apply a partial style to a full col.
 * The routine absorbs a reference to the partial style.
 **/
void
sheet_style_apply_col (Sheet *sheet, int col, GnmStyle *pstyle)
{
	GnmRange r;
	range_init_cols (&r, sheet, col, col);
	sheet_style_apply_range (sheet, &r, pstyle);
}

/**
 * sheet_style_apply_row:
 * @sheet:
 * @row:
 * @style: #GnmStyle
 *
 * NOTE: This is a simple wrapper for now.  When we support col/row styles it
 *	will make life easier.
 *
 * Apply a partial style to a full col.
 * The routine absorbs a reference to the partial style.
 **/
void
sheet_style_apply_row (Sheet  *sheet, int row, GnmStyle *pstyle)
{
	GnmRange r;
	range_init_rows (&r, sheet, row, row);
	sheet_style_apply_range (sheet, &r, pstyle);
}

/**
 * sheet_style_apply_pos:
 * @sheet:
 * @col:
 * @row:
 * @style: #GnmStyle
 *
 * Apply a partial style to a single cell
 * This function absorbs a reference to the new @style.
 **/
void
sheet_style_apply_pos (Sheet *sheet, int col, int row,
		       GnmStyle *pstyle)
{
	ReplacementStyle rs;

	g_return_if_fail (IS_SHEET (sheet));

	rstyle_ctor_pstyle (&rs, pstyle, sheet);
	cell_tile_apply_pos (&sheet->style_data->styles,
			     sheet->tile_top_level, col, row,
			     &rs);
	rstyle_dtor (&rs);
}
/**
 * sheet_style_set_pos:
 * @sheet:
 * @col:
 * @row:
 * @style:
 *
 * Change the complete style for a single cell.
 * This function absorbs a reference to the new @style.
 **/
void
sheet_style_set_pos (Sheet *sheet, int col, int row,
		     GnmStyle *style)
{
	ReplacementStyle rs;

	g_return_if_fail (IS_SHEET (sheet));

	rstyle_ctor_style (&rs, style, sheet);
	cell_tile_apply_pos (&sheet->style_data->styles,
			     sheet->tile_top_level, col, row,
			     &rs);
	rstyle_dtor (&rs);
}

/**
 * sheet_style_default:
 * @sheet:
 *
 * Returns a reference to default style for a sheet.
 **/
GnmStyle *
sheet_style_default (Sheet const *sheet)
{
	g_return_val_if_fail (IS_SHEET (sheet), NULL);
	g_return_val_if_fail (sheet->style_data != NULL, NULL);

	gnm_style_ref (sheet->style_data->default_style);
	return sheet->style_data->default_style;
}

/**
 * sheet_style_get:
 * @sheet: #Sheet
 * @col:
 * @row:
 *
 * Find the fully qualified style applicable to the specified cellpos.
 * Does _not_ add a reference.
 **/
GnmStyle const *
sheet_style_get (Sheet const *sheet, int col, int row)
{
	int level = sheet->tile_top_level;
	CellTile *tile = sheet->style_data->styles;

	while (1) {
		int width = tile_widths[level];
		int height = tile_heights[level];
		int c = col / width;
		int r = row / height;

		g_return_val_if_fail (tile != NULL, NULL);
		g_return_val_if_fail (0 <= c && c < TILE_SIZE_COL, NULL);
		g_return_val_if_fail (0 <= r && r < TILE_SIZE_ROW, NULL);

		switch (tile->type) {
		case TILE_SIMPLE:
			return tile->style_simple.style[0];
		case TILE_COL:
			return tile->style_col.style[c];
		case TILE_ROW:
			return tile->style_row.style[r];
		case TILE_MATRIX:
			return tile->style_matrix.style[r * TILE_SIZE_COL + c];

		case TILE_PTR_MATRIX:
			g_return_val_if_fail (level > 0, NULL);

			level--;
			tile = tile->ptr_matrix.ptr[r * TILE_SIZE_COL + c];
			col -= c * width;
			row -= r * height;
			continue;

		default:
			g_warning ("Adaptive Quad Tree corruption !");
			return NULL;
		}
	}
}

#define border_null(b)	((b) == none || (b) == NULL)

static void
style_row (GnmStyle *style, int start_col, int end_col, GnmStyleRow *sr, gboolean accept_conditions)
{
	GnmBorder const *top, *bottom, *none = gnm_style_border_none ();
	GnmBorder const *left, *right, *v;
	int const end = MIN (end_col, sr->end_col);
	int i = MAX (start_col, sr->start_col);

	if (accept_conditions && style->conditions) {
		GnmEvalPos ep;
		int res;

		for (eval_pos_init (&ep, (Sheet *)sr->sheet, i, sr->row); ep.eval.col <= end ; ep.eval.col++) {
			res = gnm_style_conditions_eval (style->conditions, &ep);
			style_row (res >= 0 ? g_ptr_array_index (style->cond_styles, res) : style,
				   ep.eval.col, ep.eval.col, sr, FALSE);
		}
		return;
	}

	top = gnm_style_get_border (style, MSTYLE_BORDER_TOP);
	bottom = gnm_style_get_border (style, MSTYLE_BORDER_BOTTOM);
	left = gnm_style_get_border (style, MSTYLE_BORDER_LEFT);
	right = gnm_style_get_border (style, MSTYLE_BORDER_RIGHT);

	/* Cancel grids if there is a background */
	if (sr->hide_grid || gnm_style_get_pattern (style) > 0) {
		if (top == none)
			top = NULL;
		if (bottom == none)
			bottom = NULL;
		if (left == none)
			left = NULL;
		if (right == none)
			right = NULL;
	}

	if (left != none && border_null (sr->vertical[i]))
		sr->vertical[i] = left;
	v = border_null (right) ? left : right;

	while (i <= end) {
		sr->styles[i] = style;
		if (top != none && border_null (sr->top[i]))
			sr->top[i] = top;
		sr->bottom[i] = bottom;
		sr->vertical[++i] = v;
	}
	if (border_null (right))
		sr->vertical[i] = right;
}

static void
get_style_row (CellTile const *tile, int level,
	       int corner_col, int corner_row,
	       GnmStyleRow *sr)
{
	int const width = tile_widths[level+1];
	int const w = tile_widths[level];
	int const h = tile_heights[level];
	int r = 0;
	CellTileType t;

	g_return_if_fail (TILE_TOP_LEVEL >= level && level >= 0);
	g_return_if_fail (tile != NULL);

	t = tile->type;

	if (t != TILE_SIMPLE && t != TILE_COL) {
		r = (sr->row > corner_row) ? (sr->row - corner_row)/ h : 0;
		g_return_if_fail (r < TILE_SIZE_ROW);
	}

	if (t == TILE_ROW || t == TILE_SIMPLE) {
		style_row (tile->style_any.style[r],
			   corner_col, corner_col + width - 1, sr, TRUE);
	} else {
		/* find the start and end */
		int c;
		int last_c = (sr->end_col - corner_col) / w;
		if (last_c >= TILE_SIZE_COL)
			last_c = TILE_SIZE_COL-1;
		if (sr->start_col > corner_col) {
			c = (sr->start_col - corner_col) / w;
			corner_col += c * w;
		} else
			c = 0;

		corner_row += h*r;

		if (t != TILE_PTR_MATRIX) {
			GnmStyle * const *styles = tile->style_any.style + r*TILE_SIZE_COL;

			for ( ; c <= last_c ; c++, corner_col += w)
				style_row (styles[c],
					   corner_col, corner_col + w - 1, sr, TRUE);
		} else {
			CellTile * const *tiles = tile->ptr_matrix.ptr + r*TILE_SIZE_COL;

			g_return_if_fail (level > 0);

			for ( level-- ; c <= last_c ; c++, corner_col += w)
				get_style_row (tiles[c], level,
					       corner_col, corner_row, sr);
		}
	}
}

/**
 * sheet_style_get_row:
 * @sheet: #Sheet
 * @sr: #GnmStyleRow
 *
 * A utility routine which efficiently retrieves a range of styles within a row.
 * It also merges adjacent borders as necessary.
 **/
void
sheet_style_get_row (Sheet const *sheet, GnmStyleRow *sr)
{

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (sr != NULL);
	g_return_if_fail (sr->styles != NULL);
	g_return_if_fail (sr->vertical != NULL);
	g_return_if_fail (sr->top != NULL);
	g_return_if_fail (sr->bottom != NULL);

	sr->sheet = sheet;
	sr->vertical[sr->start_col] = gnm_style_border_none ();
	get_style_row (sheet->style_data->styles, sheet->tile_top_level, 0, 0, sr);
}

static void
cb_get_row (GnmStyle *style,
	    int corner_col, G_GNUC_UNUSED int corner_row,
	    int width, G_GNUC_UNUSED int height,
	    GnmRange const *apply_to, gpointer user_)
{
	GnmStyle **res = user_;
	int i;

	/* The given dimensions refer to the tile, not the area. */
	width = MIN (width, apply_to->end.col - corner_col + 1);

	for (i = 0; i < width; i++)
		res[corner_col + i] = style;
}

GnmStyle **
sheet_style_get_row2 (Sheet const *sheet, int row)
{
	GnmRange r;
	GnmStyle **res = g_new (GnmStyle *, gnm_sheet_get_max_cols (sheet));

	range_init_rows (&r, sheet, row, row);

	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, &r,
		      cb_get_row, res);

	return res;
}


/**
 * style_row_init:
 *
 * A small utility routine to initialize the grid drawing GnmStyleRow data
 * structure.
 */
void
style_row_init (GnmBorder const * * *prev_vert,
		GnmStyleRow *sr, GnmStyleRow *next_sr,
		int start_col, int end_col, gpointer mem, gboolean hide_grid)
{
	int n, col;
	GnmBorder const *none = hide_grid ? NULL : gnm_style_border_none ();

	/* alias the arrays for easy access so that array[col] is valid
	 * for all elements start_col-1 .. end_col+1 inclusive.
	 * Note that this means that in some cases array[-1] is legal.
	 */
	n = end_col - start_col + 3; /* 1 before, 1 after, 1 fencepost */
	sr->vertical	 = mem;
	sr->vertical	-= start_col-1;
	sr->top		 = sr->vertical + n;
	sr->bottom	 = sr->top + n;
	next_sr->top	 = sr->bottom; /* yes they should share */
	next_sr->bottom	 = next_sr->top + n;
	next_sr->vertical = next_sr->bottom + n;
	*prev_vert	 = next_sr->vertical + n;
	sr->styles	 = ((GnmStyle const **) (*prev_vert + n));
	next_sr->styles	 = sr->styles + n;
	sr->start_col	 = next_sr->start_col = start_col;
	sr->end_col	 = next_sr->end_col   = end_col;
	sr->hide_grid    = next_sr->hide_grid = hide_grid;

	/* Init the areas that sheet_style_get_row will not */
	for (col = start_col-1 ; col <= end_col+1; ++col)
		(*prev_vert)[col] = sr->top[col] = none;
	sr->vertical	 [start_col-1] = sr->vertical	   [end_col+1] =
	next_sr->vertical[start_col-1] = next_sr->vertical[end_col+1] =
	next_sr->top	 [start_col-1] = next_sr->top	   [end_col+1] =
	next_sr->bottom	 [start_col-1] = next_sr->bottom  [end_col+1] = none;
}

/**
 * sheet_style_apply_range:
 * @sheet:
 * @range:
 * @pstyle:
 *
 * Apply a partial style to a region.
 * The routine absorbs a reference to the partial style.
 */
void
sheet_style_apply_range (Sheet *sheet, GnmRange const *range, GnmStyle *pstyle)
{
	ReplacementStyle rs;

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (range != NULL);

	rstyle_ctor_pstyle (&rs, pstyle, sheet);
	cell_tile_apply (&sheet->style_data->styles,
			 sheet->tile_top_level, 0, 0,
			 range, &rs);
	rstyle_dtor (&rs);
}

static void
apply_border (Sheet *sheet, GnmRange const *r,
	      GnmStyleBorderLocation side,
	      GnmBorder *border)
{
	GnmStyle *pstyle = gnm_style_new ();
	pstyle_set_border (pstyle, border, side);
	sheet_style_apply_range (sheet, r, pstyle);
}

/**
 * sheet_style_apply_border:
 * @sheet:
 * @range:
 * @borders:
 *
 * When a user applies a border to a region we attempt to remove the border
 * from the opposing side to avoid overlapping border specifications.
 * eg
 * if we apply a top border to a range, we would clear the bottom border
 * of the range offset upwards.
 */
void
sheet_style_apply_border (Sheet       *sheet,
			  GnmRange const *range,
			  GnmBorder **borders)
{
	GnmStyle *pstyle = NULL;

	if (borders == NULL)
		return;

	if (borders[GNM_STYLE_BORDER_TOP]) {
		/* 1.1 top inner */
		GnmRange r = *range;
		r.end.row = r.start.row;
		apply_border (sheet, &r, GNM_STYLE_BORDER_TOP,
			      borders[GNM_STYLE_BORDER_TOP]);

		/* 1.2 top outer */
		r.start.row--;
		if (r.start.row >= 0) {
			r.end.row = r.start.row;
			apply_border (sheet, &r, GNM_STYLE_BORDER_BOTTOM,
				      gnm_style_border_none ());
		}
	}

	if (borders[GNM_STYLE_BORDER_BOTTOM]) {
		/* 2.1 bottom inner */
		GnmRange r = *range;
		r.start.row = r.end.row;
		apply_border (sheet, &r, GNM_STYLE_BORDER_BOTTOM,
			      borders[GNM_STYLE_BORDER_BOTTOM]);

		/* 2.2 bottom outer */
		r.end.row++;
		if (r.end.row < gnm_sheet_get_last_row (sheet)) {
			r.start.row = r.end.row;
			apply_border (sheet, &r, GNM_STYLE_BORDER_TOP,
				      gnm_style_border_none ());
		}
	}

	if (borders[GNM_STYLE_BORDER_LEFT]) {
		/* 3.1 left inner */
		GnmRange r = *range;
		r.end.col = r.start.col;
		apply_border (sheet, &r, GNM_STYLE_BORDER_LEFT,
			      borders[GNM_STYLE_BORDER_LEFT]);

		/* 3.2 left outer */
		r.start.col--;
		if (r.start.col >= 0) {
			r.end.col = r.start.col;
			apply_border (sheet, &r, GNM_STYLE_BORDER_RIGHT,
				      gnm_style_border_none ());
		}
	}

	if (borders[GNM_STYLE_BORDER_RIGHT]) {
		/* 4.1 right inner */
		GnmRange r = *range;
		r.start.col = r.end.col;
		apply_border (sheet, &r, GNM_STYLE_BORDER_RIGHT,
			      borders[GNM_STYLE_BORDER_RIGHT]);

		/* 4.2 right outer */
		r.end.col++;
		if (r.end.col < gnm_sheet_get_last_col (sheet)) {
			r.start.col = r.end.col;
			apply_border (sheet, &r, GNM_STYLE_BORDER_LEFT,
				      gnm_style_border_none ());
		}
	}

	/* Interiors horizontal : prefer top */
	if (borders[GNM_STYLE_BORDER_HORIZ] != NULL) {
		/* 5.1 horizontal interior top */
		if (range->start.row != range->end.row) {
			GnmRange r = *range;
			++r.start.row;
			apply_border (sheet, &r, GNM_STYLE_BORDER_TOP,
				      borders[GNM_STYLE_BORDER_HORIZ]);
		}
		/* 5.2 interior bottom */
		if (range->start.row != range->end.row) {
			GnmRange r = *range;
			--r.end.row;
			apply_border (sheet, &r, GNM_STYLE_BORDER_BOTTOM,
				      gnm_style_border_none ());
		}
	}

	/* Interiors vertical: prefer left */
	if (borders[GNM_STYLE_BORDER_VERT] != NULL) {
		/* 6.1 vertical interior left */
		if (range->start.col != range->end.col) {
			GnmRange r = *range;
			++r.start.col;
			apply_border (sheet, &r, GNM_STYLE_BORDER_LEFT,
				      borders[GNM_STYLE_BORDER_VERT]);
		}

		/* 6.2 The vertical interior right */
		if (range->start.col != range->end.col) {
			GnmRange r = *range;
			--r.end.col;
			apply_border (sheet, &r, GNM_STYLE_BORDER_RIGHT,
				      gnm_style_border_none ());
		}
	}

	/* 7. Diagonals (apply both in one pass) */
	if (borders[GNM_STYLE_BORDER_DIAG] != NULL) {
		pstyle = gnm_style_new ();
		pstyle_set_border (pstyle, borders[GNM_STYLE_BORDER_DIAG],
				   GNM_STYLE_BORDER_DIAG);
	}
	if (borders[GNM_STYLE_BORDER_REV_DIAG]) {
		if (pstyle == NULL)
			pstyle = gnm_style_new ();
		pstyle_set_border (pstyle, borders[GNM_STYLE_BORDER_REV_DIAG],
				   GNM_STYLE_BORDER_REV_DIAG);
	}
	if (pstyle != NULL)
		sheet_style_apply_range (sheet, range, pstyle);
}

/****************************************************************************/

typedef struct {
	GnmStyle	*accum;
	unsigned int	 conflicts;
} FindConflicts;

static void
cb_find_conflicts (GnmStyle *style,
		   G_GNUC_UNUSED int corner_col, G_GNUC_UNUSED int corner_row,
		   G_GNUC_UNUSED int width, G_GNUC_UNUSED int height,
		   G_GNUC_UNUSED GnmRange const *apply_to, FindConflicts *ptr)
{
	ptr->conflicts = gnm_style_find_conflicts (ptr->accum, style, ptr->conflicts);
}

static void
border_mask_internal (gboolean *known, GnmBorder **borders,
		      GnmBorder const *b, GnmStyleBorderLocation l)
{
	if (!known[l]) {
		known[l] = TRUE;
		borders[l] = (GnmBorder *)b;
		gnm_style_border_ref (borders[l]);
	} else if (borders[l] != b && borders[l] != NULL) {
		gnm_style_border_unref (borders[l]);
		borders[l] = NULL;
	}
}

static void
border_mask (gboolean *known, GnmBorder **borders,
	     GnmBorder const *b, GnmStyleBorderLocation l)
{
	if (b == NULL)
		b = gnm_style_border_none ();
	border_mask_internal (known, borders, b, l);
}

static void
border_mask_vec (gboolean *known, GnmBorder **borders,
		 GnmBorder const * const *vec, int first, int last,
		 GnmStyleBorderLocation l)
{
	GnmBorder const *b = vec[first];

	if (b == NULL)
		b = gnm_style_border_none ();
	while (first++ < last) {
		GnmBorder const *tmp = vec[first];
		if (tmp == NULL)
			tmp = gnm_style_border_none ();
		if (b != tmp) {
			b = NULL;
			break;
		}
	}

	border_mask_internal (known, borders, b, l);
}

/**
 * sheet_style_get_uniform:
 * @sheet:
 * @range:
 * @borders:
 *
 * Find out what style elements are common to every cell in a range
 * Returns a flag of TRUE if there was a conflict a given style element
 */
unsigned int
sheet_style_find_conflicts (Sheet const *sheet, GnmRange const *r,
			    GnmStyle **style, GnmBorder **borders)
{
	int n, col, row, start_col, end_col;
	GnmStyleRow sr;
	GnmStyleBorderLocation i;
	gboolean known[GNM_STYLE_BORDER_EDGE_MAX];
	GnmBorder const *none = gnm_style_border_none ();
	FindConflicts user;

	g_return_val_if_fail (IS_SHEET (sheet), 0);
	g_return_val_if_fail (r != NULL, 0);
	g_return_val_if_fail (style != NULL, 0);
	g_return_val_if_fail (borders != NULL, 0);

	/* init style set with a copy of the top left corner of the 1st range */
	if (*style == NULL) {
		GnmStyle const *tmp = sheet_style_get (sheet, r->start.col, r->start.row);
		*style = gnm_style_dup (tmp);
		for (i = GNM_STYLE_BORDER_TOP ; i < GNM_STYLE_BORDER_EDGE_MAX ; i++) {
			known[i] = FALSE;
			borders[i] = gnm_style_border_ref ((GnmBorder *)none);
		}
	} else {
		for (i = GNM_STYLE_BORDER_TOP ; i < GNM_STYLE_BORDER_EDGE_MAX ; i++)
			known[i] = TRUE;
	}

	user.accum = *style;
	user.conflicts = 0; /* no conflicts yet */
	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, r,
		      (ForeachTileFunc)cb_find_conflicts, &user);

	/* copy over the diagonals */
	for (i = GNM_STYLE_BORDER_REV_DIAG ; i <= GNM_STYLE_BORDER_DIAG ; i++) {
		GnmStyleElement se = GNM_STYLE_BORDER_LOCATION_TO_STYLE_ELEMENT (i);
		if (user.conflicts & (1 << se))
			borders[i] = NULL;
		else
			borders[i] = gnm_style_border_ref (
				gnm_style_get_border (*style, se));
	}

	start_col = r->start.col;
	if (r->start.col > 0)
		start_col--;
	end_col = r->end.col;
	if (r->end.col < gnm_sheet_get_max_cols (sheet))
		end_col++;

	/* allocate then alias the arrays for easy access */
	n = end_col - start_col + 2;
	sr.vertical	 = (GnmBorder const **)g_alloca (n *
			    (3 * sizeof (GnmBorder const *) +
			     sizeof (GnmStyle const *)));
	sr.top	      = sr.vertical + n;
	sr.bottom     = sr.top + n;
	sr.styles     = ((GnmStyle const **) (sr.bottom + n));
	sr.vertical  -= start_col; sr.top     -= start_col;
	sr.bottom    -= start_col; sr.styles  -= start_col;
	sr.start_col  = start_col; sr.end_col  = end_col;
	sr.hide_grid  = sheet->hide_grid;

	/* pretend the previous bottom had no borders */
	for (col = start_col ; col <= end_col; ++col)
		sr.top[col] = none;

	/* merge the bottom of the previous row */
	if (r->start.row > 0) {
		GnmBorder const ** roller;
		sr.row = r->start.row - 1;
		sheet_style_get_row (sheet, &sr);
		roller = sr.top; sr.top = sr.bottom; sr.bottom = roller;
	}

	/*
	 * TODO: The border handling is tricky and currently VERY slow for
	 * large ranges.  We could easily optimize this.  There is no need to
	 * retrieve the style in every cell just to do a filter for uniformity
	 * by row.  One day we should do a special case version of
	 * sheet_style_get_row probably style_get_uniform_col (this will be
	 * faster)
	 */
	for (row = r->start.row ; row <= r->end.row ; row++) {
		GnmBorder const **roller;
		sr.row = row;
		sheet_style_get_row (sheet, &sr);

		border_mask (known, borders, sr.vertical[r->start.col],
			     GNM_STYLE_BORDER_LEFT);
		border_mask (known, borders, sr.vertical[r->end.col+1],
			     GNM_STYLE_BORDER_RIGHT);
		border_mask_vec (known, borders, sr.top,
				 r->start.col, r->end.col, (row == r->start.row)
				 ? GNM_STYLE_BORDER_TOP : GNM_STYLE_BORDER_HORIZ);
		if (r->start.col != r->end.col)
			border_mask_vec (known, borders, sr.vertical,
					 r->start.col+1, r->end.col,
					 GNM_STYLE_BORDER_VERT);

		roller = sr.top; sr.top = sr.bottom; sr.bottom = roller;
	}

	/* merge the top of the next row */
	if (r->end.row < gnm_sheet_get_last_row (sheet)) {
		sr.row = r->end.row + 1;
		sheet_style_get_row (sheet, &sr);
	}
	border_mask_vec (known, borders, sr.top, r->start.col, r->end.col,
			 GNM_STYLE_BORDER_BOTTOM);

	return user.conflicts;
}

/**
 * sheet_style_relocate:
 * @rinfo:
 *
 * Slide the styles from the origin region to the new position.
 */
void
sheet_style_relocate (GnmExprRelocateInfo const *rinfo)
{
	GnmCellPos corner;
	GnmStyleList *styles;

	g_return_if_fail (rinfo != NULL);

	styles = sheet_style_get_range (rinfo->origin_sheet, &rinfo->origin);

	sheet_style_set_range (rinfo->origin_sheet, &rinfo->origin,
			       sheet_style_default (rinfo->origin_sheet));
	corner.col = rinfo->origin.start.col + rinfo->col_offset;
	corner.row = rinfo->origin.start.row + rinfo->row_offset;
	sheet_style_set_list (rinfo->target_sheet, &corner, styles, NULL, NULL);
	style_list_free	(styles);
}

/**
 * sheet_style_insdel_colrow:
 * @rinfo:
 *
 * Insert of delete style columns/rows.
 *
 * For the insert case, we stretch the preceding column/row into there space
 * we open.
 */
void
sheet_style_insdel_colrow (GnmExprRelocateInfo const *rinfo)
{
	GnmStyleList *styles = NULL;
	Sheet *sheet;
	GnmCellPos corner;
	gboolean is_insert;

	g_return_if_fail (rinfo != NULL);
	g_return_if_fail (rinfo->origin_sheet == rinfo->target_sheet);
	g_return_if_fail ((rinfo->col_offset == 0) != (rinfo->row_offset == 0));

	is_insert = (rinfo->col_offset + rinfo->row_offset > 0);
	sheet = rinfo->origin_sheet;

	if (is_insert) {
		/* 1) copy col/row to the top/left of the region, and extend it */
		corner = rinfo->origin.start;
		if (rinfo->col_offset) {
			int col = MAX (corner.col - 1, 0);
			GnmStyleList *ptr;
			GnmRange r;

			corner.row = 0;
			range_init_cols (&r, sheet, col, col);
			styles = sheet_style_get_range (sheet, &r);
			for (ptr = styles ; ptr != NULL ; ptr = ptr->next) {
				GnmStyleRegion *sr = ptr->data;
				sr->range.end.col = rinfo->col_offset - 1;
			}
		} else {
			int row = MAX (corner.row - 1, 0);
			GnmStyleList *ptr;
			GnmRange r;

			corner.col = 0;
			range_init_rows (&r, sheet, row, row);
			styles = sheet_style_get_range (sheet, &r);
			for (ptr = styles ; ptr != NULL ; ptr = ptr->next) {
				GnmStyleRegion *sr = ptr->data;
				sr->range.end.row = rinfo->row_offset - 1;
			}
		}
	}

	sheet_style_relocate (rinfo);

	if (styles) {
		sheet_style_set_list (sheet, &corner, styles, NULL, NULL);
		style_list_free	(styles);
	}
}

static void
cb_style_extent (GnmStyle *style,
		 int corner_col, int corner_row, int width, int height,
		 GnmRange const *apply_to, gpointer user)
{
	GnmRange *res = user;
	if (gnm_style_visible_in_blank (style)) {
		int tmp;

		/* The given dimensions refer to the tile, not the area. */
		width = MIN (width, apply_to->end.col - corner_col + 1);
		height = MIN (height, apply_to->end.row - corner_row + 1);

		tmp = corner_col+width-1;
		if (res->end.col < tmp)
			res->end.col = tmp;
		if (res->start.col > corner_col)
			res->start.col = corner_col;

		tmp = corner_row+height-1;
		if (res->end.row < tmp)
			res->end.row = tmp;
		if (res->start.row > corner_row)
			res->start.row = corner_row;
	}
}

/**
 * sheet_style_get_extent:
 * @sheet: sheet to measure
 * @r: starting range and resulting range
 *
 * A simple implementation that finds the smallest range containing all visible styles
 * and containing @res.
 */
void
sheet_style_get_extent (Sheet const *sheet, GnmRange *res)
{
	GnmRange r;

	range_init_full_sheet (&r, sheet);
	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, &r,
		      cb_style_extent, res);
}

struct cb_nondefault_extent {
	GnmRange *res;
	GnmStyle **col_defaults;
};

static void
cb_nondefault_extent (GnmStyle *style,
		      int corner_col, int corner_row, int width, int height,
		      GnmRange const *apply_to, gpointer user_)
{
	struct cb_nondefault_extent *user = user_;
	GnmRange *res = user->res;
	int i;

	for (i = 0; i < width; i++) {
		int col = corner_col + i;
		if (col >= apply_to->start.col &&
		    col <= apply_to->end.col &&
		    style != user->col_defaults[col]) {
			int max_row = MIN (corner_row + height - 1,
					   apply_to->end.row);
			int min_row = MAX (corner_row, apply_to->start.row);

			res->start.col = MIN (col, res->start.col);
			res->start.row = MIN (min_row, res->start.row);

			res->end.col = MAX (col, res->end.col);
			res->end.row = MAX (max_row, res->end.row);
		}
	}
}

void
sheet_style_get_nondefault_extent (Sheet const *sheet, GnmRange *extent,
				   const GnmRange *src, GnmStyle **col_defaults)
{
	struct cb_nondefault_extent user;
	user.res = extent;
	user.col_defaults = col_defaults;
	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, src,
		      cb_nondefault_extent, &user);
}

struct cb_is_default {
	gboolean res;
	GnmStyle **col_defaults;
};

static void
cb_is_default (GnmStyle *style,
	       int corner_col, G_GNUC_UNUSED int corner_row,
	       int width, G_GNUC_UNUSED int height,
	       GnmRange const *apply_to, gpointer user_)
{
	struct cb_is_default *user = user_;
	int i;

	/* The given "width" refers to the tile, not the area. */
	width = MIN (width, apply_to->end.col - corner_col + 1);

	for (i = 0; user->res && i < width; i++) {
		if (style != user->col_defaults[corner_col + i])
			user->res = FALSE;
	}
}

gboolean
sheet_style_is_default (Sheet const *sheet, const GnmRange *r, GnmStyle **col_defaults)
{
	struct cb_is_default user;

	user.res = TRUE;
	user.col_defaults = col_defaults;

	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, r,
		      cb_is_default, &user);

	return user.res;
}

struct cb_get_nondefault {
	guint8 *res;
	GnmStyle **col_defaults;
};

static void
cb_get_nondefault (GnmStyle *style,
		   int corner_col, G_GNUC_UNUSED int corner_row,
		   int width, G_GNUC_UNUSED int height,
		   GnmRange const *apply_to, gpointer user_)
{
	struct cb_get_nondefault *user = user_;
	int i;

	/* The given dimensions refer to the tile, not the area. */
	width = MIN (width, apply_to->end.col - corner_col + 1);
	height = MIN (height, apply_to->end.row - corner_row + 1);

	for (i = 0; i < width; i++) {
		if (style != user->col_defaults[corner_col + i]) {
			int j;
			for (j = 0; j < height; j++)
				user->res[corner_row + j] = 1;
			break;
		}
	}
}

guint8 *
sheet_style_get_nondefault_rows (Sheet const *sheet, GnmStyle **col_defaults)
{
	struct cb_get_nondefault user;
	GnmRange r;

	range_init_full_sheet (&r, sheet);

	user.res = g_new0 (guint8, gnm_sheet_get_max_rows (sheet));
	user.col_defaults = col_defaults;

	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, &r,
		      cb_get_nondefault, &user);

	return user.res;
}

struct cb_most_common {
	GHashTable *h;
	int l;
	gboolean is_col;
};

static void
cb_most_common (GnmStyle *style,
		int corner_col, int corner_row, int width, int height,
		GnmRange const *apply_to, gpointer user)
{
	struct cb_most_common *cmc = user;
	int *counts = g_hash_table_lookup (cmc->h, style);
	int i;
	if (!counts) {
		counts = g_new0 (int, cmc->l);
		g_hash_table_insert (cmc->h, style, counts);
	}

	/* The given dimensions refer to the tile, not the area. */
	width = MIN (width, apply_to->end.col - corner_col + 1);
	height = MIN (height, apply_to->end.row - corner_row + 1);

	if (cmc->is_col)
		for (i = 0; i < width; i++)
			counts[corner_col + i] += height;
	else
		for (i = 0; i < height; i++)
			counts[corner_row + i] += width;
}

/**
 * sheet_style_most_common:
 * @sheet: sheet to inspect
 * @is_col: if %TRUE, look for common styles in columns; if FALSE, look in rows.
 *
 * Returns: an array of styles describing the most common styles, one per column
 * or row.
 */
GnmStyle **
sheet_style_most_common (Sheet const *sheet, gboolean is_col)
{
	GnmRange r;
	struct cb_most_common cmc;
	int *max;
	GnmStyle **res;
	GHashTableIter iter;
	gpointer key, value;

	g_return_val_if_fail (IS_SHEET (sheet), NULL);

	range_init_full_sheet (&r, sheet);
	cmc.h = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
	cmc.l = colrow_max (is_col, sheet);
	cmc.is_col = is_col;
	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, &r,
		      cb_most_common, &cmc);

	max = g_new0 (int, cmc.l);
	res = g_new0 (GnmStyle *, cmc.l);
	g_hash_table_iter_init (&iter, cmc.h);
	while (g_hash_table_iter_next (&iter, &key, &value)) {
		int *counts = value;
		GnmStyle *style = key;
		int j;
		for (j = 0; j < cmc.l; j++) {
			/* FIXME: we really ought to break ties in a
			   consistent way that does not depend on hash
			   order.  */
			if (counts[j] > max[j]) {
				max[j] = counts[j];
				res[j] = style;
			}
		}
	}
	g_hash_table_destroy (cmc.h);
	g_free (max);

	return res;
}

/****************************************************************************/

/**
 * gnm_style_region_new:
 * @range: #GnmRange
 * @style: #GnmStyle
 *
 * Returns: (transfer full): the newly allocated #GnmStyleRegion.
 **/
GnmStyleRegion *
gnm_style_region_new (GnmRange const *range, GnmStyle *style)
{
	GnmStyleRegion *sr;

	sr = g_new (GnmStyleRegion, 1);
	sr->range = *range;
	sr->style = style;
	gnm_style_ref (style);

	return sr;
}

void
gnm_style_region_free (GnmStyleRegion *sr)
{
	g_return_if_fail (sr != NULL);

	gnm_style_unref (sr->style);
	sr->style = NULL;
	g_free (sr);
}

static GnmStyleRegion *
gnm_style_region_copy (GnmStyleRegion *sr)
{
	GnmStyleRegion *res = g_new (GnmStyleRegion, 1);
	*res = *sr;
	gnm_style_ref (sr->style);
	return res;
}

GType
gnm_style_region_get_type (void)
{
	static GType t = 0;

	if (t == 0) {
		t = g_boxed_type_register_static ("GnmStyleRegion",
			 (GBoxedCopyFunc)gnm_style_region_copy,
			 (GBoxedFreeFunc)gnm_style_region_free);
	}
	return t;
}


static gboolean
debug_style_list (void)
{
	static int debug = -1;
	if (debug < 0)
		debug = gnm_debug_flag ("style-list");
	return debug;
}

typedef struct {
	GPtrArray *accum;
	GHashTable *by_tl, *by_br;
	guint64 area;
	gboolean (*style_equal) (GnmStyle const *a, GnmStyle const *b);
	gboolean (*style_filter) (GnmStyle const *style);
	GnmSheetSize const *sheet_size;
} ISL;

static gboolean
merge_ranges (GnmRange *a, GnmRange const *b)
{
	if (a->start.row == b->start.row &&
	    a->end.row == b->end.row &&
	    a->end.col + 1 == b->start.col) {
		/* "a" is just left of "b".  */
		a->end.col = b->end.col;
		return TRUE;
	}

	if (a->start.col == b->start.col &&
	    a->end.col == b->end.col &&
	    a->end.row + 1 == b->start.row) {
		/* "a" is just on top of "b".  */
		a->end.row = b->end.row;
		return TRUE;
	}

	/* Punt.  */
	return FALSE;
}

static gboolean
try_merge_pair (ISL *data, unsigned ui1, unsigned ui2)
{
	GnmStyleRegion *a;
	GnmStyleRegion *b;

	if (ui1 >= data->accum->len || ui2 >= data->accum->len)
		return FALSE;

	a = g_ptr_array_index (data->accum, ui1);
	b = g_ptr_array_index (data->accum, ui2);

	if (!data->style_equal (a->style, b->style))
		return FALSE;

	if (!merge_ranges (&a->range, &b->range))
		return FALSE;

	gnm_style_region_free (b);
	g_ptr_array_remove_index (data->accum, ui2);

	return TRUE;
}

static void
cb_style_list_add_node (GnmStyle *style,
			int corner_col, int corner_row, int width, int height,
			GnmRange const *apply_to, gpointer user_)
{
	ISL *data = user_;
	GnmSheetSize const *ss = data->sheet_size;
	GnmStyleRegion *sr;
	GnmRange range;

	/* Can this even happen? */
	if (corner_col >= ss->max_cols || corner_row >= ss->max_rows)
		return;

	if (data->style_filter && !data->style_filter (style))
		return;

	range.start.col = corner_col;
	range.start.row = corner_row;
	range.end.col = MIN (corner_col + width - 1, ss->max_cols - 1);
	range.end.row = MIN (corner_row + height - 1, ss->max_rows - 1);

	if (apply_to) {
		range.start.col -= apply_to->start.col;
		if (range.start.col < 0)
			range.start.col = 0;
		range.start.row -= apply_to->start.row;
		if (range.start.row < 0)
			range.start.row = 0;

		if (range.end.col > apply_to->end.col)
			range.end.col = apply_to->end.col;
		range.end.col -= apply_to->start.col;
		if (range.end.row > apply_to->end.row)
			range.end.row = apply_to->end.row;
		range.end.row -= apply_to->start.row;
	}

	data->area += (guint64)range_width (&range) * range_height (&range);

	sr = gnm_style_region_new (&range, style);
	g_ptr_array_add (data->accum, sr);

	while (try_merge_pair (data, data->accum->len - 2, data->accum->len - 1))
		/* Nothing */;
}

static void
verify_hashes (ISL *data)
{
	GHashTable *by_tl = data->by_tl;
	GHashTable *by_br = data->by_br;
	unsigned ui;
	guint64 area = 0;

	g_return_if_fail (g_hash_table_size (by_tl) == data->accum->len);
	g_return_if_fail (g_hash_table_size (by_br) == data->accum->len);

	for (ui = 0; ui < data->accum->len; ui++) {
		GnmStyleRegion *sr = g_ptr_array_index (data->accum, ui);
		g_return_if_fail (g_hash_table_lookup (by_tl, &sr->range.start) == sr);
		g_return_if_fail (g_hash_table_lookup (by_br, &sr->range.end) == sr);
		area += range_height (&sr->range) *
			(guint64)range_width (&sr->range);
	}

	g_return_if_fail (area == data->area);
}

static void
merge_vertical_stripes (ISL *data)
{
	unsigned ui;
	GHashTable *by_tl = data->by_tl;
	GHashTable *by_br = data->by_br;
	gboolean debug = debug_style_list ();
	gboolean paranoid = debug;

	for (ui = 0; ui < data->accum->len; ui++) {
		GnmStyleRegion *a = g_ptr_array_index (data->accum, ui);
		GnmStyleRegion *c;
		GnmCellPos cr;
		GSList *Bs = NULL, *l;
		gboolean fail = FALSE;

		/*  We're looking for the setup below and extend Bs down  */
		/*  taking over part of C which is then extended to       */
		/*  include all of A.                                     */
		/*                                                        */
		/*             +----+                                     */
		/*             |    +---------+                           */
		/*   +---------+ B1 |   B2    |                           */
		/*   |    A    |    |         |                           */
		/*   +---------+----+---------+                           */
		/*   |           C            |                           */
		/*   +------------------------+                           */

		cr.col = a->range.start.col;
		cr.row = a->range.end.row + 1;
		c = g_hash_table_lookup (by_tl, &cr);
		if (!c || !data->style_equal (a->style, c->style))
			continue;

		cr.col = c->range.end.col;
		cr.row = a->range.end.row;
		while (cr.col > a->range.end.col) {
			GnmStyleRegion *b = g_hash_table_lookup (by_br, &cr);
			if (!b || !data->style_equal (a->style, b->style)) {
				fail = TRUE;
				break;
			}
			Bs = g_slist_prepend (Bs, b);
			cr.col = b->range.start.col - 1;
		}
		if (fail || cr.col != a->range.end.col) {
			g_slist_free (Bs);
			continue;
		}

		if (debug) {
			g_printerr ("Vertical stripe merge:\n");
			g_printerr ("A: %s\n", range_as_string (&a->range));
			for (l = Bs; l; l = l-> next) {
				GnmStyleRegion *b = l->data;
				g_printerr ("B: %s\n", range_as_string (&b->range));
			}
			g_printerr ("C: %s\n", range_as_string (&c->range));
		}

		g_hash_table_remove (by_tl, &a->range.start);
		g_hash_table_remove (by_br, &a->range.end);
		g_ptr_array_remove_index_fast (data->accum, ui);
		ui--;

		g_hash_table_remove (by_tl, &c->range.start);
		g_hash_table_remove (by_br, &c->range.end);
		c->range.start.row = a->range.start.row;
		c->range.end.col = a->range.end.col;
		g_hash_table_insert (by_tl, &c->range.start, c);
		g_hash_table_insert (by_br, &c->range.end, c);
		if (debug)
			g_printerr ("New C: %s\n", range_as_string (&c->range));

		for (l = Bs; l; l = l-> next) {
			GnmStyleRegion *b = l->data;
			g_hash_table_remove (by_br, &b->range.end);
			b->range.end.row = c->range.end.row;
			g_hash_table_insert (by_br, &b->range.end, b);
			if (debug)
				g_printerr ("New B: %s\n", range_as_string (&b->range));
		}
		if (debug)
			g_printerr ("\n");

		gnm_style_region_free (a);
		g_slist_free (Bs);

		if (paranoid) verify_hashes (data);
	}
}

static void
merge_horizontal_stripes (ISL *data)
{
	unsigned ui;
	GHashTable *by_tl = data->by_tl;
	GHashTable *by_br = data->by_br;
	gboolean debug = debug_style_list ();
	gboolean paranoid = debug;

	for (ui = 0; ui < data->accum->len; ui++) {
		GnmStyleRegion *a = g_ptr_array_index (data->accum, ui);
		GnmStyleRegion *c;
		GnmCellPos cr;
		GSList *Bs = NULL, *l;
		gboolean fail = FALSE;

		/*  We're looking for the setup below and extend Bs right */
		/*  taking over part of C which is then extended to       */
		/*  include all of A.                                     */
		/*                                                        */
		/*                        +-----+-----+                   */
		/*                        |  A  |     |                   */
		/*                   +----+-----+     |                   */
		/*                   |    B1    |     |                   */
		/*                   +--+-------+     |                   */
		/*                      |       |  C  |                   */
		/*                      |       |     |                   */
		/*                      |  B2   |     |                   */
		/*                      |       |     |                   */
		/*                      |       |     |                   */
		/*                      +-------+-----+                   */

		cr.col = a->range.end.col + 1;
		cr.row = a->range.start.row;
		c = g_hash_table_lookup (by_tl, &cr);
		if (!c || !data->style_equal (a->style, c->style))
			continue;

		cr.col = a->range.end.col;
		cr.row = c->range.end.row;
		while (cr.row > a->range.end.row) {
			GnmStyleRegion *b = g_hash_table_lookup (by_br, &cr);
			if (!b || !data->style_equal (a->style, b->style)) {
				fail = TRUE;
				break;
			}
			Bs = g_slist_prepend (Bs, b);
			cr.row = b->range.start.row - 1;
		}
		if (fail || cr.row != a->range.end.row) {
			g_slist_free (Bs);
			continue;
		}

		if (debug) {
			g_printerr ("Horizontal stripe merge:\n");
			g_printerr ("A: %s\n", range_as_string (&a->range));
			for (l = Bs; l; l = l-> next) {
				GnmStyleRegion *b = l->data;
				g_printerr ("B: %s\n", range_as_string (&b->range));
			}
			g_printerr ("C: %s\n", range_as_string (&c->range));
		}

		g_hash_table_remove (by_tl, &a->range.start);
		g_hash_table_remove (by_br, &a->range.end);
		g_ptr_array_remove_index_fast (data->accum, ui);
		ui--;

		g_hash_table_remove (by_tl, &c->range.start);
		g_hash_table_remove (by_br, &c->range.end);
		c->range.start.col = a->range.start.col;
		c->range.end.row = a->range.end.row;
		g_hash_table_insert (by_tl, &c->range.start, c);
		g_hash_table_insert (by_br, &c->range.end, c);
		if (debug)
			g_printerr ("New C: %s\n", range_as_string (&c->range));

		for (l = Bs; l; l = l-> next) {
			GnmStyleRegion *b = l->data;
			g_hash_table_remove (by_br, &b->range.end);
			b->range.end.col = c->range.end.col;
			g_hash_table_insert (by_br, &b->range.end, b);
			if (debug)
				g_printerr ("New B: %s\n", range_as_string (&b->range));
		}
		if (debug)
			g_printerr ("\n");

		gnm_style_region_free (a);
		g_slist_free (Bs);

		if (paranoid) verify_hashes (data);
	}
}

static int
by_col_row (GnmStyleRegion **a, GnmStyleRegion **b)
{
	int d;

	d = (*a)->range.start.col - (*b)->range.start.col;
	if (d)
		return d;

	d = (*a)->range.start.row - (*b)->range.start.row;
	return d;
}

static GnmStyleList *
internal_style_list (Sheet const *sheet, GnmRange const *r,
		     gboolean (*style_equal) (GnmStyle const *a, GnmStyle const *b),
		     gboolean (*style_filter) (GnmStyle const *style))
{
	GnmRange full_sheet;
	ISL data;
	GnmStyleList *res = NULL;
	unsigned ui, prelen;
	gboolean paranoid = FALSE;
	guint64 sheet_area;

	g_return_val_if_fail (IS_SHEET (sheet), NULL);

	if (r) {
		/* This can happen if the last row or column is deleted.  */
		if (!range_valid (r))
			return NULL;
	} else
		r = range_init_full_sheet (&full_sheet, sheet);

	data.accum = g_ptr_array_new ();
	data.by_tl = g_hash_table_new ((GHashFunc)gnm_cellpos_hash,
				       (GEqualFunc)gnm_cellpos_equal);
	data.by_br = g_hash_table_new ((GHashFunc)gnm_cellpos_hash,
				       (GEqualFunc)gnm_cellpos_equal);
	data.area = 0;
	data.style_equal = style_equal;
	data.style_filter = style_filter;
	data.sheet_size = gnm_sheet_get_size (sheet);

	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, r,
		      cb_style_list_add_node, &data);

	sheet_area = (guint64)range_height (r) * range_width (r);
	if (data.style_filter ? (data.area > sheet_area) : (data.area != sheet_area))
		g_warning ("Strange size issue in internal_style_list");

	/*
	 * Simple, fast optimization first.  For the file underlying
	 * bug 699045 this brings down 332688 entries to just 86.
	 */
	if (data.accum->len >= 2) {
		g_ptr_array_sort (data.accum, (GCompareFunc)by_col_row);
		for (ui = data.accum->len - 1; ui > 0; ui--) {
			try_merge_pair (&data, ui - 1, ui);
		}
	}

	/* Populate hashes.  */
	for (ui = 0; ui < data.accum->len; ui++) {
		GnmStyleRegion *sr = g_ptr_array_index (data.accum, ui);
		g_hash_table_insert (data.by_tl, &sr->range.start, sr);
		g_hash_table_insert (data.by_br, &sr->range.end, sr);
	}

	if (paranoid) verify_hashes (&data);

	do {
		prelen = data.accum->len;
		merge_vertical_stripes (&data);
		merge_horizontal_stripes (&data);
	} while (prelen > data.accum->len);

	/* Always verify once.  */
	verify_hashes (&data);

	if (debug_style_list ())
		g_printerr ("Total of %d ranges:\n", data.accum->len);
	for (ui = data.accum->len; ui-- > 0; ) {
		GnmStyleRegion *sr = g_ptr_array_index (data.accum, ui);
		if (debug_style_list ())
			g_printerr ("  %s %p\n",
				    range_as_string (&sr->range),
				    sr->style);
		res = g_slist_prepend (res, sr);
	}

	g_ptr_array_free (data.accum, TRUE);
	g_hash_table_destroy (data.by_tl);
	g_hash_table_destroy (data.by_br);
	return res;
}

/**
 * sheet_style_get_range:
 * @sheet: the sheet in which to find styles
 * @r:     optional range to scan
 *
 * Get a list of rectangles and their associated styles.
 * Caller is responsible for freeing.  Note that when a range is given,
 * the resulting ranges are relative to the input range.
 *
 * Returns: (transfer full):
 */
GnmStyleList *
sheet_style_get_range (Sheet const *sheet, GnmRange const *r)
{
	return internal_style_list (sheet, r,
				    gnm_style_eq,
				    NULL);
}

static gboolean
style_conditions_equal (GnmStyle const *a, GnmStyle const *b)
{
	return	gnm_style_get_conditions (a) == gnm_style_get_conditions (b);
}

static gboolean
style_conditions_filter (GnmStyle const *style)
{
	return gnm_style_get_conditions (style) != NULL;
}

/**
 * sheet_style_collect_conditions:
 * @sheet:
 * @r:
 *
 * Returns: (transfer full): a list of areas with conditionals, Caller is
 * responsible for freeing.
 **/
GnmStyleList *
sheet_style_collect_conditions (Sheet const *sheet, GnmRange const *r)
{
	return internal_style_list (sheet, r,
				    style_conditions_equal,
				    style_conditions_filter);
}


static gboolean
style_hlink_equal (GnmStyle const *a, GnmStyle const *b)
{
	return	gnm_style_get_hlink (a) == gnm_style_get_hlink (b);
}

static gboolean
style_hlink_filter (GnmStyle const *style)
{
	return gnm_style_get_hlink (style) != NULL;
}

/**
 * sheet_style_collect_hlinks:
 * @sheet:
 * @r:
 *
 * Returns: (transfer full): a list of areas with hyperlinks, Caller is
 * responsible for freeing.
 **/
GnmStyleList *
sheet_style_collect_hlinks (Sheet const *sheet, GnmRange const *r)
{
	return internal_style_list (sheet, r,
				    style_hlink_equal,
				    style_hlink_filter);
}


static gboolean
style_validation_equal (GnmStyle const *a, GnmStyle const *b)
{
	return	gnm_style_get_validation (a) == gnm_style_get_validation (b) &&
		gnm_style_get_input_msg (a) == gnm_style_get_input_msg (b);
}

static gboolean
style_validation_filter (GnmStyle const *style)
{
	return (gnm_style_get_validation (style) != NULL ||
		gnm_style_get_input_msg (style) != NULL);
}

/**
 * sheet_style_collect_validations:
 * @sheet: the to trawl
 * @r: (allow-none): range to restrict to
 *
 * Returns: (transfer full): a list of areas with validation or input
 * message.
 **/
GnmStyleList *
sheet_style_collect_validations (Sheet const *sheet, GnmRange const *r)
{
	return internal_style_list (sheet, r,
				    style_validation_equal,
				    style_validation_filter);
}

/**
 * sheet_style_set_list:
 * @sheet: #Sheet
 * @corner: The top-left corner (in LTR mode)
 * @l: #GnmStyleList
 * @range_modify: (scope call):
 * @data: user data
 *
 * Overwrites the styles of the ranges given by @corner with the content of
 * @list. Optionally transposing the ranges
 **/
GnmSpanCalcFlags
sheet_style_set_list (Sheet *sheet, GnmCellPos const *corner,
		      GnmStyleList const *list,
		      sheet_style_set_list_cb_t range_modify,
		      gpointer data)
{
	GnmSpanCalcFlags spanflags = GNM_SPANCALC_SIMPLE;
	GnmStyleList const *l;

	g_return_val_if_fail (IS_SHEET (sheet), spanflags);

	/* Sluggish but simple implementation for now */
	for (l = list; l; l = l->next) {
		GnmStyleRegion const *sr = l->data;
		GnmRange              r  = sr->range;

		range_translate (&r, sheet, +corner->col, +corner->row);
		if (range_modify)
			range_modify (&r, sheet, data);

		gnm_style_ref (sr->style);
		sheet_style_set_range (sheet, &r, sr->style);
		spanflags |= gnm_style_required_spanflags (sr->style);
	}
	return spanflags;
}

/**
 * style_list_free:
 * @l: the list to free
 *
 * Free up the ressources in the style list.  Including unreferencing the
 * styles.
 */
void
style_list_free (GnmStyleList *list)
{
	g_slist_free_full (list, (GDestroyNotify)gnm_style_region_free);
}

/**
 * style_list_get_style:
 * @l: A style list.
 * @col:
 * @row:
 *
 * Attempts to find the style associated with the @pos offset within the 0,0
 * based style list.
 * The resulting style does not have its reference count bumped.
 **/
GnmStyle const *
style_list_get_style (GnmStyleList const *list, int col, int row)
{
	GnmStyleList const *l;

	for (l = list; l; l = l->next) {
		GnmStyleRegion const *sr = l->data;
		GnmRange const *r = &sr->range;
		if (range_contains (r, col, row))
			return sr->style;
	}
	return NULL;
}

static void
cb_find_link (GnmStyle *style,
	      G_GNUC_UNUSED int corner_col, G_GNUC_UNUSED int corner_row,
	      G_GNUC_UNUSED int width, G_GNUC_UNUSED int height,
	      G_GNUC_UNUSED GnmRange const *apply_to, gpointer user)
{
	GnmHLink **link = user;
	if (*link == NULL)
		*link = gnm_style_get_hlink (style);
}

/**
 * sheet_style_region_contains_link:
 * @sheet:
 * @r:
 *
 * Utility routine that checks to see if a region contains at least 1 hyper link
 * and returns the 1st one it finds.
 *
 * Returns: (transfer none): the found #GmHLink if any.
 **/
GnmHLink *
sheet_style_region_contains_link (Sheet const *sheet, GnmRange const *r)
{
	GnmHLink *res = NULL;

	g_return_val_if_fail (IS_SHEET (sheet), NULL);
	g_return_val_if_fail (r != NULL, NULL);

	foreach_tile (sheet->style_data->styles,
		      sheet->tile_top_level, 0, 0, r,
		      cb_find_link, &res);
	return res;
}

/**
 * sheet_style_foreach:
 * @sheet: #Sheet
 * @func: (scope call): callback
 * @user_data: user data.
 *
 * Executes @func for each style in the sheet.
 **/
void
sheet_style_foreach (Sheet const *sheet, GFunc func, gpointer user_data)
{
	GSList *styles;

	g_return_if_fail (IS_SHEET (sheet));
	g_return_if_fail (sheet->style_data != NULL);

	styles = sh_all_styles (sheet->style_data->style_hash);
	styles = g_slist_sort (styles, (GCompareFunc)gnm_style_cmp);
	g_slist_foreach (styles, func, user_data);
	g_slist_free (styles);
}

/**
 * sheet_style_range_foreach:
 * @sheet: #Sheet
 * @r: optional range
 * @func: (scope call): callback.
 * @user_data: user data
 *
 **/
void
sheet_style_range_foreach (Sheet const *sheet, GnmRange const *r,
			   GHFunc func, gpointer user_data)
{
	GnmStyleList *styles, *l;

	styles = sheet_style_get_range (sheet, r);

	for (l = styles; l; l = l->next) {
		GnmStyleRegion *sr = l->data;
		if (r) {
			sr->range.start.col += r->start.col;
			sr->range.start.row += r->start.row;
			sr->range.end.col += r->start.col;
			sr->range.end.row += r->start.row;
		}
		func (NULL, sr, user_data);
		gnm_style_region_free (sr);
	}

	g_slist_free (styles);
}

/* ------------------------------------------------------------------------- */

static void
cell_tile_dump (CellTile **tile, int level, CellTileOptimize *data,
		int ccol, int crow)
{
	CellTileType type;
	int const w = tile_widths[level];
	int const h = tile_heights[level];
	GnmRange rng;
	const char *indent = "";

	type = (*tile)->type;

	range_init (&rng,
		    ccol, crow,
		    MIN (ccol + tile_widths[level + 1] - 1,
			 data->ss->max_cols - 1),
		    MIN (crow + tile_heights[level + 1] - 1,
			 data->ss->max_rows - 1));

	g_printerr ("%s%s: type %s\n",
		    indent,
		    range_as_string (&rng),
		    tile_type_str[type]);

	if (type == TILE_PTR_MATRIX) {
		int i;

		for (i = 0; i < TILE_SIZE_COL * TILE_SIZE_ROW; i++) {
			CellTile **subtile = (*tile)->ptr_matrix.ptr + i;
			int c = i % TILE_SIZE_COL;
			int r = i / TILE_SIZE_COL;
			cell_tile_dump (subtile, level - 1, data,
					ccol + w * c,
					crow + h * r);
		}
	} else {
#if 0
		int i;

		for (i = 0; i < tile_size[type]; i++) {
			g_printerr ("%s: %d %p\n",
				    indent,
				    i,
				    (*tile)->style_any.style[i]);
		}
#endif
	}
}

/* ------------------------------------------------------------------------- */

static void
cell_tile_optimize (CellTile **tile, int level, CellTileOptimize *data,
		    int ccol, int crow)
{
	CellTileType type;
	int const w = tile_widths[level];
	int const h = tile_heights[level];
	CellTile *res;
	int i;
	GnmRange rng;

	type = (*tile)->type;
	if (type == TILE_SIMPLE)
		return;

	range_init (&rng,
		    ccol, crow,
		    MIN (ccol + tile_widths[level + 1] - 1,
			 data->ss->max_cols - 1),
		    MIN (crow + tile_heights[level + 1] - 1,
			 data->ss->max_rows - 1));

	switch (type) {
	case TILE_COL:
	case TILE_ROW:
		if (!tile_is_uniform (*tile))
			return;

		type = TILE_SIMPLE;
		break;

	case TILE_PTR_MATRIX: {
		gboolean all_simple = TRUE;
		int i;

		for (i = 0; i < TILE_SIZE_COL * TILE_SIZE_ROW; i++) {
			CellTile **subtile = (*tile)->ptr_matrix.ptr + i;
			if (data->recursion) {
				int c = i % TILE_SIZE_COL;
				int r = i / TILE_SIZE_COL;
				cell_tile_optimize (subtile, level - 1, data,
						    ccol + w * c,
						    crow + h * r);
			}
			if ((*subtile)->type != TILE_SIMPLE)
				all_simple = FALSE;
		}
		if (!all_simple)
			return;

		res = cell_tile_style_new (NULL, TILE_MATRIX);
		for (i = 0; i < TILE_SIZE_COL * TILE_SIZE_ROW; i++) {
			CellTile *subtile = (*tile)->ptr_matrix.ptr[i];
			GnmStyle *st = subtile->style_simple.style[0];
			gnm_style_link (st);
			res->style_matrix.style[i] = st;
		}

		if (debug_style_optimize)
			g_printerr ("Turning %s (%dx%d) from a %s into a %s\n",
				    range_as_string (&rng),
				    range_width (&rng), range_height (&rng),
				    tile_type_str[(*tile)->type],
				    tile_type_str[res->type]);
		cell_tile_dtor (*tile);
		*tile = res;

		/* Fall through */
	}

	case TILE_MATRIX: {
		gboolean csame = TRUE;
		gboolean rsame = TRUE;
		int c, r, i;

		for (i = r = 0 ; r < TILE_SIZE_ROW ; ++r, i += TILE_SIZE_COL) {
			for (c = 0 ; c < TILE_SIZE_COL ; ++c) {
				if (rsame && c &&
				    !gnm_style_eq ((*tile)->style_matrix.style[i + c],
						   (*tile)->style_matrix.style[i    ])) {
					rsame = FALSE;
					if (!csame)
						return;
				}
				if (csame && r &&
				    !gnm_style_eq ((*tile)->style_matrix.style[i + c],
						   (*tile)->style_matrix.style[    c])) {
					csame = FALSE;
					if (!rsame)
						return;
				}
			}
		}

		if (csame && rsame)
			type = TILE_SIMPLE;
		else if (csame) {
			type = TILE_COL;
		} else {
			type = TILE_ROW;
		}
		break;
	}

	default:
		g_assert_not_reached ();
	}

	if (debug_style_optimize)
		g_printerr ("Turning %s (%dx%d) from a %s into a %s\n",
			    range_as_string (&rng),
			    range_width (&rng), range_height (&rng),
			    tile_type_str[(*tile)->type],
			    tile_type_str[type]);

	res = cell_tile_style_new (NULL, type);
	switch (type) {
	case TILE_SIMPLE:
		res->style_simple.style[0] = (*tile)->style_any.style[0];
		break;
	case TILE_ROW:
		for (i = 0; i < TILE_SIZE_ROW; i++)
			res->style_row.style[i] =
				(*tile)->style_matrix.style[i * TILE_SIZE_COL];
		break;
	case TILE_COL:
		for (i = 0; i < TILE_SIZE_COL; i++)
			res->style_col.style[i] =
				(*tile)->style_matrix.style[i];
		break;
	default:
		g_assert_not_reached ();
	}

	for (i = 0; i < tile_size[type]; i++)
		gnm_style_link (res->style_any.style[i]);

	cell_tile_dtor (*tile);
	*tile = res;
}

static GSList *
sample_styles (Sheet *sheet)
{
	GnmSheetSize const *ss = gnm_sheet_get_size (sheet);
	GSList *res = NULL;
	int c = 0, r = 0;
	const int SKIP = 1;

	while (1) {
		GnmStyle const *mstyle = sheet_style_get (sheet, c, r);
		if (res == NULL ||  !gnm_style_eq (mstyle, res->data)) {
			gnm_style_ref (mstyle);
			res = g_slist_prepend (res, GINT_TO_POINTER (c));
			res = g_slist_prepend (res, GINT_TO_POINTER (r));
			res = g_slist_prepend (res, (gpointer)mstyle);
		}

		c += SKIP;
		if (c >= ss->max_cols) {
			c -= ss->max_cols;
			r++;
			if (r >= ss->max_rows)
				break;
		}
	}

	return g_slist_reverse (res);
}

static void
verify_styles (GSList *pre, GSList *post)
{
	GSList *lpre, *lpost;
	gboolean silent = FALSE, bad = FALSE;

	for (lpre = pre, lpost = post;
	     lpre || lpost;
	     lpre = (lpre ? lpre->next->next->next : NULL),
	     lpost = (lpost ? lpost->next->next->next : NULL)) {
		int cpre = lpre ? GPOINTER_TO_INT (lpre->data) : -1;
		int rpre = lpre ? GPOINTER_TO_INT (lpre->next->data) : -1;
		GnmStyle const *spre = lpre ? lpre->next->next->data : NULL;
		int cpost = lpost ? GPOINTER_TO_INT (lpost->data) : -1;
		int rpost = lpost ? GPOINTER_TO_INT (lpost->next->data) : -1;
		GnmStyle const *spost = lpost ? lpost->next->next->data : NULL;

		if (!silent) {
			if (!spre || !spost) {
				bad = TRUE;
				g_warning ("Style optimizer failure at end!");
				silent = TRUE;
			} else if (cpre != cpost || rpre != rpost) {
				bad = TRUE;
				g_warning ("Style optimizer position conflict at %s!",
					   cell_coord_name (cpre, rpre));
				silent = TRUE;
			} else if (!gnm_style_eq (spre, spost)) {
				bad = TRUE;
				g_warning ("Style optimizer failure at %s!",
					   cell_coord_name (cpre, rpre));
			}
		}

		if (spre) gnm_style_unref (spre);
		if (spost) gnm_style_unref (spost);
	}

	g_slist_free (pre);
	g_slist_free (post);

	g_assert (!bad);
}

void
sheet_style_optimize (Sheet *sheet)
{
	CellTileOptimize data;
	GSList *pre;
	gboolean verify;

	g_return_if_fail (IS_SHEET (sheet));

	if (gnm_debug_flag ("no-style-optimize"))
		return;

	sheet_colrow_optimize (sheet);

	data.ss = gnm_sheet_get_size (sheet);
	data.recursion = TRUE;

	if (debug_style_optimize) {
		g_printerr ("Optimizing %s\n", sheet->name_unquoted);
		cell_tile_dump (&sheet->style_data->styles,
				sheet->tile_top_level, &data,
				0, 0);
	}

	verify = gnm_debug_flag ("style-optimize-verify");
	pre = verify ? sample_styles (sheet) : NULL;

	cell_tile_optimize (&sheet->style_data->styles,
			    sheet->tile_top_level, &data,
			    0, 0);

	if (debug_style_optimize)
		g_printerr ("Optimizing %s...done\n", sheet->name_unquoted);

	if (verify) {
		GSList *post = sample_styles (sheet);
		verify_styles (pre, post);
	}
}
