/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * gnm-style.c: Storing a style
 *
 * Authors:
 *   Michael Meeks <mmeeks@gnu.org>
 *   Almer S. Tigelaar <almer@gnome.org>
 *   Jody Goldberg <jody@gnome.org>
 *   Morten Welinder <terra@gnome.org>
 */
#include <gnumeric-config.h>
#include "gnumeric.h"
#include "style.h"

#include "gnm-style-impl.h"
#include "sheet-style.h"
#include "style-conditions.h"
#include "application.h"
#include "parse-util.h"
#include "expr.h"
#include "value.h"
#include "gutils.h"
#include "ranges.h"
#include "gnumeric-conf.h"
#include <goffice/goffice.h>
#include <string.h>

#define DEBUG_STYLES
#ifndef USE_MSTYLE_POOL
#define USE_MSTYLE_POOL 1
#endif

#if USE_MSTYLE_POOL
/* Memory pool for GnmStyles.  */
static GOMemChunk *gnm_style_pool;
#define CHUNK_ALLOC(T,p) ((T*)go_mem_chunk_alloc (p))
#define CHUNK_ALLOC0(T,p) ((T*)go_mem_chunk_alloc0 (p))
#define CHUNK_FREE(p,v) go_mem_chunk_free ((p), (v))
#else
#define CHUNK_ALLOC(T,c) g_new (T,1)
#define CHUNK_ALLOC0(T,c) g_new0 (T,1)
#define CHUNK_FREE(p,v) g_free ((v))
#endif

#define UNROLLED_FOR(init_,cond_,step_,code_)			\
do {								\
	init_;							\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	if (cond_) { code_; step_;				\
	g_assert_not_reached ();				\
	}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}	\
} while (0)



static char const * const
gnm_style_element_name[MSTYLE_ELEMENT_MAX] = {
	"Color.Back",
	"Color.Pattern",
	"Border.Top",
	"Border.Bottom",
	"Border.Left",
	"Border.Right",
	"Border.RevDiagonal",
	"Border.Diagonal",
	"Pattern",
	"Color.Fore",
	"Font.Name",
	"Font.Bold",
	"Font.Italic",
	"Font.Underline",
	"Font.Strikethrough",
	"Font.Script",
	"Font.Size",
	"Format",
	"Align.v",
	"Align.h",
	"Indent",
	"Rotation",
	"WrapText",
	"ShrinkToFit",
	"Contents.Locked",
	"Contents.Hidden",
	"Validation",
	"Hyper Link",
	"Input Msg"
};

/* Some ref/link count debugging */
#if 0
#define d(arg)	g_printerr arg
#else
#define d(arg)	do { } while (0)
#endif

static void
clear_conditional_merges (GnmStyle *style)
{
	if (style->cond_styles) {
		unsigned i = style->cond_styles->len;
		while (i-- > 0)
			gnm_style_unref (g_ptr_array_index (style->cond_styles, i));
		g_ptr_array_free (style->cond_styles, TRUE);
		style->cond_styles = NULL;
	}
}

#define MIX(H) do {				\
  H *= G_GUINT64_CONSTANT(123456789012345);	\
  H ^= (H >> 31);				\
} while (0)

static void
gnm_style_update (GnmStyle *style)
{
	guint64 hash = 0;
	int i;

	g_return_if_fail (style->changed);

	style->changed = 0;

	clear_conditional_merges (style);
	if (elem_is_set (style, MSTYLE_CONDITIONS) && style->conditions)
		style->cond_styles = gnm_style_conditions_overlay (style->conditions, style);

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

	if (elem_is_set (style, MSTYLE_COLOR_BACK)) {
		if (!style->color.back->is_auto)
			hash ^= GPOINTER_TO_UINT (style->color.back);
		else
			hash++;
	}
	MIX (hash);

	if (elem_is_set (style, MSTYLE_COLOR_PATTERN)) {
		if (!style->color.pattern->is_auto)
			hash ^= GPOINTER_TO_UINT (style->color.pattern);
		else
			hash++;
	}
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_COLOR)) {
		if (!style->color.font->is_auto)
			hash ^= GPOINTER_TO_UINT (style->color.font);
		else
			hash++;
	}
	MIX (hash);

	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_DIAGONAL; i++) {
		if (elem_is_set (style, i))
			hash ^= GPOINTER_TO_UINT (style->borders[i - MSTYLE_BORDER_TOP]);
		else
			hash++;
		MIX (hash);
	}

	if (elem_is_set (style, MSTYLE_PATTERN))
		hash ^= style->pattern;
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_NAME))
		hash ^= GPOINTER_TO_UINT (style->font_detail.name);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_BOLD))
		hash ^= (style->font_detail.bold ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_ITALIC))
		hash ^= (style->font_detail.italic ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_UNDERLINE))
		hash ^= (style->font_detail.underline ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_STRIKETHROUGH))
		hash ^= (style->font_detail.strikethrough ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_SCRIPT))
		hash ^= (style->font_detail.script + 0x100);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FONT_SIZE))
		hash ^= ((int)(style->font_detail.size * 97));
	MIX (hash);

	if (elem_is_set (style, MSTYLE_FORMAT))
		hash ^= GPOINTER_TO_UINT (style->format);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_ALIGN_H))
		hash ^= (style->h_align + 0x100);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_ALIGN_V))
		hash ^= (style->v_align + 0x100);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_INDENT))
		hash ^= style->indent;
	MIX (hash);

	if (elem_is_set (style, MSTYLE_ROTATION))
		hash ^= style->rotation;
	MIX (hash);

	if (elem_is_set (style, MSTYLE_TEXT_DIR))
		hash ^= (style->text_dir + 0x100);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_WRAP_TEXT))
		hash ^= (style->wrap_text ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_SHRINK_TO_FIT))
		hash ^= (style->shrink_to_fit ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_CONTENTS_LOCKED))
		hash ^= (style->contents_locked ? 1 : 2);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_CONTENTS_HIDDEN))
		hash ^= (style->contents_hidden ? 1 : 2);
	MIX (hash);

	style->hash_key_xl = (guint32)hash;

	/* From here on, fields are not in MS XL */

	if (elem_is_set (style, MSTYLE_VALIDATION)) {
		/*
		 * The hash used must not depend on the expressions inside
		 * the validation.
		 */
		hash ^= (style->validation != NULL ? 1 : 2);
	}
	MIX (hash);

	if (elem_is_set (style, MSTYLE_HLINK))
		hash ^= GPOINTER_TO_UINT (style->hlink);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_INPUT_MSG))
		hash ^= GPOINTER_TO_UINT (style->input_msg);
	MIX (hash);

	if (elem_is_set (style, MSTYLE_CONDITIONS)) {
		/*
		 * The hash used must not depend on the expressions inside
		 * the conditions.
		 */
		hash ^= style->conditions
			? gnm_style_conditions_hash (style->conditions)
			: 1u;
	}
	MIX (hash);

	style->hash_key = (guint32)hash;

	if (G_UNLIKELY (style->set == 0)) {
		/*
		 * gnm_style_new and gnm_style_dup both assume that the
		 * correct hash values (both of them) for the empty style
		 * is zero.
		 */
		g_assert (style->hash_key == 0);
		g_assert (style->hash_key_xl == 0);
	}
}

#undef MIX

guint
gnm_style_hash_XL (gconstpointer style)
{
	if (((GnmStyle const *)style)->changed)
		gnm_style_update ((GnmStyle *)style);
	return ((GnmStyle const *)style)->hash_key_xl;
}

guint
gnm_style_hash (gconstpointer style)
{
	if (((GnmStyle const *)style)->changed)
		gnm_style_update ((GnmStyle *)style);
	return ((GnmStyle const *)style)->hash_key;
}

#define ELEM_IS_EQ(a,b,elem)						\
    (elem == MSTYLE_COLOR_BACK						\
    ? a->color.back == b->color.back ||	(a->color.back->is_auto && b->color.back->is_auto) \
    : (elem == MSTYLE_COLOR_PATTERN					\
    ? a->color.pattern == b->color.pattern || (a->color.pattern->is_auto && b->color.pattern->is_auto) \
    : (elem >= MSTYLE_BORDER_TOP && elem <= MSTYLE_BORDER_DIAGONAL)	\
    ? a->borders[elem - MSTYLE_BORDER_TOP] == b->borders[elem - MSTYLE_BORDER_TOP] \
    : (elem == MSTYLE_PATTERN						\
    ? a->pattern == b->pattern						\
    : (elem == MSTYLE_FONT_COLOR					\
    ? a->color.font == b->color.font || (a->color.font->is_auto && b->color.font->is_auto) \
    : (elem == MSTYLE_FONT_NAME						\
    ? a->font_detail.name == b->font_detail.name			\
    : (elem == MSTYLE_FONT_BOLD						\
    ? a->font_detail.bold == b->font_detail.bold			\
    : (elem == MSTYLE_FONT_ITALIC					\
    ? a->font_detail.italic == b->font_detail.italic			\
    : (elem == MSTYLE_FONT_UNDERLINE					\
    ? a->font_detail.underline == b->font_detail.underline		\
    : (elem == MSTYLE_FONT_STRIKETHROUGH				\
    ? a->font_detail.strikethrough == b->font_detail.strikethrough	\
    : (elem == MSTYLE_FONT_SCRIPT					\
    ? a->font_detail.script == b->font_detail.script			\
    : (elem == MSTYLE_FONT_SIZE						\
    ? a->font_detail.size == b->font_detail.size			\
    : (elem == MSTYLE_FORMAT						\
    ? a->format == b->format						\
    : (elem == MSTYLE_ALIGN_V						\
    ? a->v_align == b->v_align						\
    : (elem == MSTYLE_ALIGN_H						\
    ? a->h_align == b->h_align						\
    : (elem == MSTYLE_INDENT						\
    ? a->indent == b->indent						\
    : (elem == MSTYLE_ROTATION						\
    ? a->rotation == b->rotation					\
    : (elem == MSTYLE_TEXT_DIR						\
    ? a->text_dir == b->text_dir					\
    : (elem == MSTYLE_WRAP_TEXT						\
    ? a->wrap_text == b->wrap_text					\
    : (elem == MSTYLE_SHRINK_TO_FIT					\
    ? a->shrink_to_fit == b->shrink_to_fit				\
    : (elem == MSTYLE_CONTENTS_LOCKED					\
    ? a->contents_locked == b->contents_locked				\
    : (elem == MSTYLE_CONTENTS_HIDDEN					\
    ? a->contents_hidden == b->contents_hidden				\
    : (elem == MSTYLE_VALIDATION					\
    ? a->validation == b->validation					\
    : (elem == MSTYLE_HLINK						\
    ? a->hlink == b->hlink						\
    : (elem == MSTYLE_INPUT_MSG						\
    ? a->input_msg == b->input_msg					\
    : (elem == MSTYLE_CONDITIONS					\
    ? a->conditions == b->conditions					\
    : FALSE)))))))))))))))))))))))))

/*
 * Note: the above is suboptimal from validation and down.
 *
 * We are comparing pointers (which at least safely matches what we do
 * with the hash), but I think we want proper equality.
 */

static gboolean
elem_is_eq (GnmStyle const *a, GnmStyle const *b, GnmStyleElement elem)
{
	return ELEM_IS_EQ (a, b, elem);
}

static void
elem_assign_contents (GnmStyle *dst, GnmStyle const *src, GnmStyleElement elem)
{
#ifdef DEBUG_STYLES
	g_return_if_fail (src != dst);
	g_return_if_fail (elem_is_set (src, elem));
#endif
	switch (elem) {
	case MSTYLE_COLOR_BACK :	style_color_ref (dst->color.back = src->color.back); return;
	case MSTYLE_COLOR_PATTERN :	style_color_ref (dst->color.pattern = src->color.pattern); return;
	case MSTYLE_ANY_BORDER:
		elem -= MSTYLE_BORDER_TOP;
		gnm_style_border_ref (dst->borders[elem] = src->borders[elem]);
		return;
	case MSTYLE_PATTERN:		dst->pattern = src->pattern; return;
	case MSTYLE_FONT_COLOR :	style_color_ref (dst->color.font = src->color.font); return;
	case MSTYLE_FONT_NAME:		go_string_ref (dst->font_detail.name = src->font_detail.name); return;
	case MSTYLE_FONT_BOLD:		dst->font_detail.bold = src->font_detail.bold; return;
	case MSTYLE_FONT_ITALIC:	dst->font_detail.italic = src->font_detail.italic; return;
	case MSTYLE_FONT_UNDERLINE:	dst->font_detail.underline = src->font_detail.underline; return;
	case MSTYLE_FONT_STRIKETHROUGH: dst->font_detail.strikethrough = src->font_detail.strikethrough; return;
	case MSTYLE_FONT_SCRIPT:	dst->font_detail.script = src->font_detail.script; return;
	case MSTYLE_FONT_SIZE:		dst->font_detail.size = src->font_detail.size; return;
	case MSTYLE_FORMAT:		go_format_ref (dst->format = src->format); return;
	case MSTYLE_ALIGN_V:		dst->v_align = src->v_align; return;
	case MSTYLE_ALIGN_H:		dst->h_align = src->h_align; return;
	case MSTYLE_INDENT:		dst->indent = src->indent; return;
	case MSTYLE_ROTATION:		dst->rotation = src->rotation; return;
	case MSTYLE_TEXT_DIR:		dst->text_dir = src->text_dir; return;
	case MSTYLE_WRAP_TEXT:		dst->wrap_text = src->wrap_text; return;
	case MSTYLE_SHRINK_TO_FIT:	dst->shrink_to_fit = src->shrink_to_fit; return;
	case MSTYLE_CONTENTS_LOCKED:	dst->contents_locked = src->contents_locked; return;
	case MSTYLE_CONTENTS_HIDDEN:	dst->contents_hidden = src->contents_hidden; return;
	case MSTYLE_VALIDATION:
		if ((dst->validation = src->validation))
			gnm_validation_ref (dst->validation);
		return;
	case MSTYLE_HLINK:
		if ((dst->hlink = src->hlink))
			g_object_ref (dst->hlink);
		return;
	case MSTYLE_INPUT_MSG:
		if ((dst->input_msg = src->input_msg))
			g_object_ref (dst->input_msg);
		return;
	case MSTYLE_CONDITIONS:
		if ((dst->conditions = src->conditions))
			g_object_ref (dst->conditions);
		return;
	default:
		;
	}
}

static void
elem_clear_contents (GnmStyle *style, GnmStyleElement elem)
{
#ifdef DEBUG_STYLES
	g_return_if_fail (style != NULL);
#endif
	if (!elem_is_set (style, elem))
		return;

	switch (elem) {
	case MSTYLE_COLOR_BACK :	style_color_unref (style->color.back); return;
	case MSTYLE_COLOR_PATTERN :	style_color_unref (style->color.pattern); return;
	case MSTYLE_ANY_BORDER:
		gnm_style_border_unref (style->borders[elem - MSTYLE_BORDER_TOP]);
		return;
	case MSTYLE_FONT_COLOR :	style_color_unref (style->color.font); return;
	case MSTYLE_FONT_NAME:		go_string_unref (style->font_detail.name); return;
	case MSTYLE_FORMAT:		go_format_unref (style->format); return;
	case MSTYLE_VALIDATION:
		if (style->validation)
			gnm_validation_unref (style->validation);
		return;
	case MSTYLE_HLINK:
		if (style->hlink)
			g_object_unref (style->hlink);
		return;
	case MSTYLE_INPUT_MSG:
		if (style->input_msg)
			g_object_unref (style->input_msg);
		return;
	case MSTYLE_CONDITIONS:
		if (style->conditions) {
			clear_conditional_merges (style);
			g_object_unref (style->conditions);
		}
		return;
	default:
		;
	}
}

/**
 * gnm_style_find_conflicts :
 * @accum: accumulator #GnmStyle
 * @overlay: #GnmStyle
 * @conflicts: flags
 *
 * Copy any items from @overlay that do not conflict with the values in @accum.
 * If an element had a previous conflict (flagged via @conflicts) it is ignored.
 *
 * Returns @conflicts with any new conflicts added.
 **/
unsigned int
gnm_style_find_conflicts (GnmStyle *accum, GnmStyle const *overlay,
			  unsigned int conflicts)
{
	int i;

	g_assert (MSTYLE_ELEMENT_MAX <= CHAR_BIT * sizeof (conflicts));

	for (i = 0; i < MSTYLE_ELEMENT_MAX; i++) {
		if (conflicts & (1u << i) || !elem_is_set (overlay, i)) {
			/* Nothing */
		} else if (!elem_is_set (accum, i)) {
			elem_assign_contents (accum, overlay, i);
			elem_set (accum, i);
			elem_changed (accum, i);
		} else if (!elem_is_eq (accum, overlay, i))
			conflicts |= (1u << i);
	}

	return conflicts;
}

static inline void
gnm_style_clear_pango (GnmStyle *style)
{
	if (style->pango_attrs) {
		pango_attr_list_unref (style->pango_attrs);
		style->pango_attrs = NULL;
	}
}


static inline void
gnm_style_clear_font (GnmStyle *style)
{
	if (style->font) {
		gnm_font_unref (style->font);
		style->font = NULL;
	}
	g_clear_object (&style->font_context);
}

/**
 * gnm_style_new :
 *
 * Caller is responsible for unrefing the result.
 *
 * Returns a new style with _no_ elements set.
 **/
GnmStyle *
gnm_style_new (void)
{
	GnmStyle *style = CHUNK_ALLOC0 (GnmStyle, gnm_style_pool);

	style->ref_count = 1;
	style->link_count = 0;
	style->linked_sheet = NULL;
	style->pango_attrs = NULL;
	style->font = NULL;
	style->validation = NULL;

	style->set = style->changed = 0;
	style->validation = NULL;
	style->hlink = NULL;
	style->input_msg = NULL;
	style->conditions = NULL;

	d(("new %p\n", style));

	return style;
}

/**
 * gnm_style_new_default:
 *
 * Caller is responsible for unrefing the result.
 *
 * Return value: a new style initialized to the default state.
 **/
GnmStyle *
gnm_style_new_default (void)
{
	GnmStyle *new_style = gnm_style_new ();
	int i;

	gnm_style_set_font_name	  (new_style, gnm_conf_get_core_defaultfont_name ());
	gnm_style_set_font_size	  (new_style, gnm_conf_get_core_defaultfont_size ());
	gnm_style_set_font_bold	  (new_style, gnm_conf_get_core_defaultfont_bold ());
	gnm_style_set_font_italic (new_style, gnm_conf_get_core_defaultfont_italic ());

	gnm_style_set_format      (new_style, go_format_general ());
	gnm_style_set_align_v     (new_style, GNM_VALIGN_BOTTOM);
	gnm_style_set_align_h     (new_style, GNM_HALIGN_GENERAL);
	gnm_style_set_indent      (new_style, 0);
	gnm_style_set_rotation    (new_style, 0);
	gnm_style_set_text_dir    (new_style, GNM_TEXT_DIR_CONTEXT);
	gnm_style_set_wrap_text   (new_style, FALSE);
	gnm_style_set_shrink_to_fit (new_style, FALSE);
	gnm_style_set_contents_locked (new_style, TRUE);
	gnm_style_set_contents_hidden (new_style, FALSE);
	gnm_style_set_font_uline  (new_style, UNDERLINE_NONE);
	gnm_style_set_font_strike (new_style, FALSE);
	gnm_style_set_font_script (new_style, GO_FONT_SCRIPT_STANDARD);

	gnm_style_set_validation (new_style, NULL);
	gnm_style_set_hlink      (new_style, NULL);
	gnm_style_set_input_msg  (new_style, NULL);
	gnm_style_set_conditions (new_style, NULL);

	gnm_style_set_font_color (new_style, style_color_black ());
	gnm_style_set_back_color (new_style, style_color_auto_back ());
	gnm_style_set_pattern_color (new_style, style_color_black ());

	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_DIAGONAL; ++i)
		gnm_style_set_border (new_style, i,
			gnm_style_border_ref (gnm_style_border_none ()));
	gnm_style_set_pattern (new_style, 0);

	return new_style;
}

GnmStyle *
gnm_style_dup (GnmStyle const *src)
{
	GnmStyle *new_style = CHUNK_ALLOC0 (GnmStyle, gnm_style_pool);
	int i;

	new_style->ref_count = 1;
	for (i = 0; i < MSTYLE_ELEMENT_MAX; i++)
		if (elem_is_set (src, i)) {
			elem_assign_contents (new_style, src, i);
			elem_set (new_style, i);
			elem_changed (new_style, i);
		}

	if ((new_style->pango_attrs = src->pango_attrs)) {
		pango_attr_list_ref (new_style->pango_attrs);
		new_style->pango_attrs_zoom = src->pango_attrs_zoom;
	}

	if ((new_style->font = src->font)) {
		gnm_font_ref (new_style->font);
		new_style->font_context = g_object_ref (src->font_context);
	}

	d(("dup %p\n", new_style));
	return new_style;
}

/**
 * gnm_style_new_merged :
 * @base: #GnmStyle
 * @overlay: #GnmStyle
 *
 * A new GnmStyle that contains any elements of @overlay that are set, and uses
 * @base for anything that is not set in @overlay.
 *
 * Returns: (transfer full): A ref to a new GnmStyle.
 **/
GnmStyle *
gnm_style_new_merged (GnmStyle const *base, GnmStyle const *overlay)
{
	GnmStyle *new_style = CHUNK_ALLOC0 (GnmStyle, gnm_style_pool);
	int i;

	new_style->ref_count = 1;
	for (i = 0; i < MSTYLE_ELEMENT_MAX; i++) {
		if (elem_is_set (overlay, i))
			elem_assign_contents (new_style, overlay, i);
		else if (elem_is_set (base, i))
			elem_assign_contents (new_style, base, i);
		else
			continue;
		elem_set (new_style, i);
		elem_changed (new_style, i);
	}
	d(("copy merge %p\n", new_style));
	return new_style;
}

void
gnm_style_ref (GnmStyle const *style)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (style->ref_count > 0);

	((GnmStyle *)style)->ref_count++;
	d(("ref %p = %d\n", style, style->ref_count));
}

/**
 * gnm_style_unref :
 * @style: #GnmStyle const
 *
 * Unrefs and _potentially frees_ @style.
 * Takes a _const_ pointer to facilitate life cycles.  The const indicates that
 * the content can not be changed, mainly when handling styles that are in the
 * style hash.
 **/
void
gnm_style_unref (GnmStyle const *style)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (style->ref_count > 0);

	d(("unref %p = %d\n", style, style->ref_count-1));
	if (((GnmStyle *)style)->ref_count-- <= 1) {
		GnmStyle *unconst = (GnmStyle *)style;
		int i;

		g_return_if_fail (style->link_count == 0);
		g_return_if_fail (style->linked_sheet == NULL);

		for (i = 0; i < MSTYLE_ELEMENT_MAX; i++)
			elem_clear_contents (unconst, i);
		unconst->set = 0;
		clear_conditional_merges (unconst);
		gnm_style_clear_pango (unconst);
		gnm_style_clear_font (unconst);

		if (style->deps) {
			if (style->deps->len > 0)
				g_warning ("Leftover style deps!");
			g_ptr_array_free (style->deps, TRUE);
		}

		CHUNK_FREE (gnm_style_pool, unconst);
	}
}

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

	if (t == 0) {
		t = g_boxed_type_register_static ("GnmStyle",
			 (GBoxedCopyFunc)gnm_style_ref,
			 (GBoxedFreeFunc)gnm_style_unref);
	}
	return t;
}

/*
 * Replace auto pattern color in style with sheet's auto pattern color.
 * make_copy tells if we are allowed to modify the style in place or we must
 * make a copy first.
 */
static GnmStyle *
link_pattern_color (GnmStyle *style, GnmColor *auto_color, gboolean make_copy)
{
	GnmColor *pattern_color = style->color.pattern;

	if (pattern_color->is_auto && auto_color != pattern_color) {
		style_color_ref (auto_color);
		if (make_copy) {
			GnmStyle *orig = style;
			style = gnm_style_dup (style);
			gnm_style_unref (orig);
		}
		gnm_style_set_pattern_color (style, auto_color);
	}
	return style;
}

/*
 * Replace auto border colors in style with sheet's auto pattern
 * color. (pattern is *not* a typo.)
 * make_copy tells if we are allowed to modify the style in place or we must
 * make a copy first.
 *
 * FIXME: We conjecture that XL color 64 in border should change with the
 * pattern, but not color 127. That distinction is not yet represented in
 * our data structures.
 */
static GnmStyle *
link_border_colors (GnmStyle *style, GnmColor *auto_color, gboolean make_copy)
{
	int i;

	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_DIAGONAL; ++i) {
		if (elem_is_set (style, i)) {
			GnmBorder *border =
				style->borders[i- MSTYLE_BORDER_TOP];
			GnmColor *color;

			if (!border)
				continue;

			color = border->color;
			if (color->is_auto && auto_color != color) {
				GnmBorder *new_border;
				GnmStyleBorderOrientation orientation;

				switch (i) {
				case MSTYLE_BORDER_LEFT:
				case MSTYLE_BORDER_RIGHT:
					orientation = GNM_STYLE_BORDER_VERTICAL;
					break;
				case MSTYLE_BORDER_REV_DIAGONAL:
				case MSTYLE_BORDER_DIAGONAL:
					orientation = GNM_STYLE_BORDER_DIAGONAL;
					break;
				case MSTYLE_BORDER_TOP:
				case MSTYLE_BORDER_BOTTOM:
				default:
					orientation = GNM_STYLE_BORDER_HORIZONTAL;
					break;
				}
				style_color_ref (auto_color);
				new_border = gnm_style_border_fetch (
					border->line_type, auto_color,
					orientation);

				if (make_copy) {
					GnmStyle *orig = style;
					style = gnm_style_dup (style);
					gnm_style_unref (orig);
					make_copy = FALSE;
				}
				gnm_style_set_border (style, i, new_border);
			}
		}
	}
	return style;
}

static void
gnm_style_linked_sheet_changed (GnmStyle *style)
{
	Sheet *sheet = style->linked_sheet;

	if (elem_is_set (style, MSTYLE_VALIDATION) &&
	    style->validation &&
	    gnm_validation_get_sheet (style->validation) != sheet) {
		GnmValidation *new_v = gnm_validation_dup (style->validation);
		gnm_validation_set_sheet (new_v, sheet);
		gnm_style_set_validation (style, new_v);
	}

	if (elem_is_set (style, MSTYLE_CONDITIONS) &&
	    style->conditions
	    && gnm_style_conditions_get_sheet (style->conditions) != sheet
		) {
		GnmStyleConditions *new_c = gnm_style_conditions_dup (style->conditions);
		gnm_style_conditions_set_sheet (new_c, sheet);
		gnm_style_set_conditions (style, new_c);
	}
}

/**
 * gnm_style_link_sheet :
 * @style:
 * @sheet:
 *
 * ABSORBS a reference to the style and sets the link count to 1.
 *
 * Where auto pattern color occurs in the style (it may for pattern and
 * borders), it is replaced with the sheet's auto pattern color. We make
 * sure that we do not modify the style which was passed in to us, but also
 * that we don't copy more than once. The final argument to the
 * link_xxxxx_color functions tell whether or not to copy.
 */
GnmStyle *
gnm_style_link_sheet (GnmStyle *style, Sheet *sheet)
{
	GnmColor *auto_color;
	gboolean style_is_orig = TRUE;

	if (style->linked_sheet != NULL) {
		GnmStyle *orig = style;
		style = gnm_style_dup (style);
		gnm_style_unref (orig);
		style_is_orig = FALSE;

		/* safety test */
		g_return_val_if_fail (style->linked_sheet != sheet, style);
	}

	g_return_val_if_fail (style->link_count == 0, style);
	g_return_val_if_fail (style->linked_sheet == NULL, style);

	auto_color = sheet_style_get_auto_pattern_color (sheet);
	if (elem_is_set (style, MSTYLE_COLOR_PATTERN))
		style = link_pattern_color (style, auto_color, style_is_orig);
	style = link_border_colors (style, auto_color, style_is_orig);
	style_color_unref (auto_color);

	style->linked_sheet = sheet;
	style->link_count = 1;

	gnm_style_linked_sheet_changed (style);

	d(("link sheet %p = 1\n", style));
	return style;
}

void
gnm_style_link (GnmStyle *style)
{
	g_return_if_fail (style->link_count > 0);

	style->link_count++;
	d(("link %p = %d\n", style, style->link_count));
}

void
gnm_style_link_multiple (GnmStyle *style, int count)
{
	g_return_if_fail (style->link_count > 0);

	style->link_count += count;
	d(("multiple link %p + %d = %d\n", style, count, style->link_count));
}

void
gnm_style_unlink (GnmStyle *style)
{
	g_return_if_fail (style->link_count > 0);

	d(("unlink %p = %d\n", style, style->link_count-1));
	if (style->link_count-- == 1) {
		sheet_style_unlink (style->linked_sheet, style);
		style->linked_sheet = NULL;
		gnm_style_unref (style);
	}
}

gboolean
gnm_style_eq (GnmStyle const *a, GnmStyle const *b)
{
	return a == b;
}

gboolean
gnm_style_equal (GnmStyle const *a, GnmStyle const *b)
{
	int i;

	if (a == b)
		return TRUE;
	if (a->set != b->set || !gnm_style_equal_XL (a, b))
		return FALSE;
	UNROLLED_FOR (i = MSTYLE_VALIDATION, i < MSTYLE_ELEMENT_MAX, i++, {
		if (elem_is_set (a, i) && !ELEM_IS_EQ (a, b, i))
			return FALSE;
	});

	return TRUE;
}

gboolean
gnm_style_equal_XL (GnmStyle const *a, GnmStyle const *b)
{
	int i;

	g_return_val_if_fail (a != NULL, FALSE);
	g_return_val_if_fail (b != NULL, FALSE);

	if (a == b)
		return TRUE;

	if ((a->set ^ b->set) & ((1u << MSTYLE_VALIDATION) - 1))
		return FALSE;

	UNROLLED_FOR (i = MSTYLE_COLOR_BACK, i < MSTYLE_VALIDATION, i++, {
		if (elem_is_set (a, i) && !ELEM_IS_EQ (a, b, i))
			return FALSE;
	});
	return TRUE;
}

/**
 * gnm_style_equal_elem:
 * @a: first style
 * @b: second style
 * @e: style element
 *
 * Returns: %TRUE, if the two styles have the same contents for the
 * given element, either because neither have it set, or because both
 * have it set and to the same value.
 */
gboolean
gnm_style_equal_elem (GnmStyle const *a, GnmStyle const *b, GnmStyleElement e)
{
	if (elem_is_set (a, e))
		return elem_is_set (b, e) && elem_is_eq (a, b, e);
	else
		return !elem_is_set (b, e);
}



#define CMP_TRY_NUMBER_RAW(a_,b_)		\
  do {						\
    if ((a_) < (b_)) return -1;			\
    if ((a_) > (b_)) return -1;			\
  } while (0)

#define CMP_TRY_NUMBER(e_,f_)			\
  do {						\
    if (elem_is_set (a, (e_)))			\
      CMP_TRY_NUMBER_RAW(a->f_, b->f_);		\
  } while (0)

#define CMP_TRY_COLOR(e_,f_)					\
  do {								\
    if (elem_is_set (a, (e_))) {				\
      CMP_TRY_NUMBER_RAW(a->f_->is_auto, b->f_->is_auto);	\
      CMP_TRY_NUMBER_RAW(a->f_->go_color, b->f_->go_color);	\
    }								\
  } while (0)

/*
 * Ordering of GnmStyles.  Apart from FIXMEs, this shouldn't change
 * from one run to the next.
 */
int
gnm_style_cmp (GnmStyle const *a, GnmStyle const *b)
{
	GnmStyleElement e;

	if (a == b)
		return 0;

	/*
	 * Very quick comparison based on what is set.  This also allows
	 * us to check on one elem_is_set below.
	 */
	CMP_TRY_NUMBER_RAW (a->set, b->set);

	CMP_TRY_COLOR (MSTYLE_FONT_COLOR, color.font);
	CMP_TRY_COLOR (MSTYLE_COLOR_BACK, color.back);
	CMP_TRY_COLOR (MSTYLE_COLOR_PATTERN, color.pattern);
	for (e = MSTYLE_BORDER_TOP; e <= MSTYLE_BORDER_DIAGONAL; e++) {
		GnmBorder const *ba, *bb;
		if (!elem_is_set (a, e))
			continue;
		ba = a->borders[e - MSTYLE_BORDER_TOP];
		bb = b->borders[e - MSTYLE_BORDER_TOP];
		if (ba == bb)
			continue;  /* Handles both being NULL */
		CMP_TRY_NUMBER_RAW(!!ba, !!bb);
		CMP_TRY_NUMBER_RAW(ba->line_type, bb->line_type);
		CMP_TRY_NUMBER_RAW(ba->color->go_color, bb->color->go_color);
		CMP_TRY_NUMBER_RAW(ba->begin_margin, bb->begin_margin);
		CMP_TRY_NUMBER_RAW(ba->end_margin, bb->end_margin);
		CMP_TRY_NUMBER_RAW(ba->width, bb->width);
	}
	CMP_TRY_NUMBER (MSTYLE_PATTERN, pattern);
	if (elem_is_set (a, MSTYLE_FONT_NAME)) {
		/* Plain strcmp, not utf-8.  We need to see diffs.  */
		int tmp = strcmp (a->font_detail.name->str,
				  b->font_detail.name->str);
		if (tmp)
			return tmp;
	}
	CMP_TRY_NUMBER (MSTYLE_FONT_BOLD, font_detail.bold);
	CMP_TRY_NUMBER (MSTYLE_FONT_ITALIC, font_detail.italic);
	CMP_TRY_NUMBER (MSTYLE_FONT_UNDERLINE, font_detail.underline);
	CMP_TRY_NUMBER (MSTYLE_FONT_STRIKETHROUGH, font_detail.strikethrough);
	CMP_TRY_NUMBER (MSTYLE_FONT_SCRIPT, font_detail.script);
	CMP_TRY_NUMBER (MSTYLE_FONT_SIZE, font_detail.size);
	if (elem_is_set (a, MSTYLE_FORMAT)) {
		/* Plain strcmp, not utf-8.  We need to see diffs.  */
		int tmp = strcmp (go_format_as_XL (a->format),
				  go_format_as_XL (b->format));
		if (tmp)
			return tmp;
	}
	CMP_TRY_NUMBER (MSTYLE_ALIGN_H, h_align);
	CMP_TRY_NUMBER (MSTYLE_ALIGN_V, v_align);
	CMP_TRY_NUMBER (MSTYLE_INDENT, indent);
	CMP_TRY_NUMBER (MSTYLE_ROTATION, rotation);
	CMP_TRY_NUMBER (MSTYLE_TEXT_DIR, text_dir);
	CMP_TRY_NUMBER (MSTYLE_WRAP_TEXT, wrap_text);
	CMP_TRY_NUMBER (MSTYLE_SHRINK_TO_FIT, shrink_to_fit);
	CMP_TRY_NUMBER (MSTYLE_CONTENTS_LOCKED, contents_locked);
	CMP_TRY_NUMBER (MSTYLE_CONTENTS_HIDDEN, contents_hidden);
	/* FIXME: validation */
	/* FIXME: hlink */
	/* FIXME: input_msg */
	/* FIXME: conditions */
	/* FIXME: cond_styles */

	/* Last resort: pointer comparison.  */
	return a < b ? -1 : +1;
}

#undef CMP_TRY_NUMBER
#undef CMP_TRY_COLOR


/**
 * gnm_style_equal_header :
 * @a: #GnmStyle
 * @b: #GnmStyle
 * @top: is this a header vertically or horizontally
 *
 * Check to see if @a is different enough from @b to make us think that @a is
 * from a header.
 **/
gboolean
gnm_style_equal_header (GnmStyle const *a, GnmStyle const *b, gboolean top)
{
	int i = top ? MSTYLE_BORDER_BOTTOM : MSTYLE_BORDER_RIGHT;

	if (!elem_is_eq (a, b, i))
		return FALSE;
	for (i = MSTYLE_COLOR_BACK; i <= MSTYLE_COLOR_PATTERN ; i++)
		if (!elem_is_eq (a, b, i))
			return FALSE;
	for (i = MSTYLE_FONT_COLOR; i <= MSTYLE_SHRINK_TO_FIT ; i++)
		if (!elem_is_eq (a, b, i))
			return FALSE;
	return TRUE;
}


gboolean
gnm_style_is_element_set (GnmStyle const *style, GnmStyleElement elem)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (MSTYLE_COLOR_BACK <= elem && elem < MSTYLE_ELEMENT_MAX, FALSE);
	return elem_is_set (style, elem);
}

/**
 * gnm_style_is_complete :
 * @style: #GnmStyle
 *
 * Returns TRUE if all elements are set.
 **/
gboolean
gnm_style_is_complete (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);

	return style->set == ((1u << MSTYLE_ELEMENT_MAX) - 1);
}

void
gnm_style_unset_element (GnmStyle *style, GnmStyleElement elem)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (MSTYLE_COLOR_BACK <= elem && elem < MSTYLE_ELEMENT_MAX);

	if (elem_is_set (style, elem)) {
		elem_clear_contents (style, elem);
		elem_unset (style, elem);
	}
}

/**
 * gnm_style_merge :
 * @base: #GnmStyle
 * @overlay: #GnmStyle
 *
 * Applies all active elements of @overlay onto @base.
 **/
void
gnm_style_merge (GnmStyle *base, GnmStyle const *overlay)
{
	unsigned i;
	if (base == overlay)
		return;
	for (i = 0; i < MSTYLE_ELEMENT_MAX; i++)
		if (elem_is_set (overlay, i)) {
			elem_clear_contents (base, i);
			elem_assign_contents (base, overlay, i);
			elem_changed (base, i);
		}
}

/**
 * gnm_style_merge_element:
 * @dst: Destination style
 * @src: Source style
 * @elem: Element to replace
 *
 * This function replaces element @elem in style @dst with element @elem
 * in style @src. (If element @elem was already set in style @dst then
 * the element will first be unset)
 **/
void
gnm_style_merge_element (GnmStyle *dst, GnmStyle const *src, GnmStyleElement elem)
{
	g_return_if_fail (src != NULL);
	g_return_if_fail (dst != NULL);
	g_return_if_fail (src != dst);

	if (elem_is_set (src, elem)) {
		elem_clear_contents (dst, elem);
		elem_assign_contents (dst, src, elem);
		elem_set (dst, elem);
		elem_changed (dst, elem);
	}
}

void
gnm_style_set_font_color (GnmStyle *style, GnmColor *col)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (col != NULL);

	elem_changed (style, MSTYLE_FONT_COLOR);
	if (elem_is_set (style, MSTYLE_FONT_COLOR))
		style_color_unref (style->color.font);
	else
		elem_set (style, MSTYLE_FONT_COLOR);
	elem_changed (style, MSTYLE_FONT_COLOR);
	style->color.font = col;
	gnm_style_clear_pango (style);
}

/**
 * gnm_style_set_back_color :
 * @style: #GnmStyle
 * @col: #GnmColor
 *
 * Assigns @col as the background of @style.
 *
 * NOTE : the background colour is only visibile if
 *	GnmStyle::pattern > 0
 **/
void
gnm_style_set_back_color (GnmStyle *style, GnmColor *col)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (col != NULL);

	elem_changed (style, MSTYLE_COLOR_BACK);
	if (elem_is_set (style, MSTYLE_COLOR_BACK))
		style_color_unref (style->color.back);
	else
		elem_set (style, MSTYLE_COLOR_BACK);
	style->color.back = col;
	gnm_style_clear_pango (style);
}
void
gnm_style_set_pattern_color (GnmStyle *style, GnmColor *col)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (col != NULL);

	elem_changed (style, MSTYLE_COLOR_PATTERN);
	if (elem_is_set (style, MSTYLE_COLOR_PATTERN))
		style_color_unref (style->color.pattern);
	else
		elem_set (style, MSTYLE_COLOR_PATTERN);
	style->color.pattern = col;
	gnm_style_clear_pango (style);
}

GnmColor *
gnm_style_get_font_color (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_COLOR), NULL);
	return style->color.font;
}

GnmColor *
gnm_style_get_back_color (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_COLOR_BACK), NULL);
	return style->color.back;
}

GnmColor *
gnm_style_get_pattern_color (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_COLOR_PATTERN), NULL);
	return style->color.pattern;
}

void
gnm_style_set_border (GnmStyle *style, GnmStyleElement elem,
		      GnmBorder *border)
{
	g_return_if_fail (style != NULL);

	/* NOTE : It is legal for border to be NULL */
	switch (elem) {
	case MSTYLE_ANY_BORDER:
		elem_changed (style, elem);
		elem_set (style, elem);
		elem -= MSTYLE_BORDER_TOP;
		if (style->borders[elem])
			gnm_style_border_unref (style->borders[elem]);
		style->borders[elem] = border;
		break;
	default:
		g_warning ("Not a border element");
		break;
	}
}

GnmBorder *
gnm_style_get_border (GnmStyle const *style, GnmStyleElement elem)
{
	g_return_val_if_fail (style != NULL, NULL);

	switch (elem) {
	case MSTYLE_ANY_BORDER:
		return style->borders[elem - MSTYLE_BORDER_TOP ];

	default:
		g_warning ("Not a border element");
		return NULL;
	}
}

void
gnm_style_set_pattern (GnmStyle *style, int pattern)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (pattern >= 0);
	g_return_if_fail (pattern < GNUMERIC_SHEET_PATTERNS);

	elem_changed (style, MSTYLE_PATTERN);
	elem_set (style, MSTYLE_PATTERN);
	style->pattern = pattern;
}

int
gnm_style_get_pattern (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, 0);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_PATTERN), 0);

	return style->pattern;
}

/**
 * gnm_style_get_font:
 * @style: #GnmStyle
 * @context: #PangoContext
 *
 * Returns: (transfer none):
 **/
GnmFont *
gnm_style_get_font (GnmStyle const *style, PangoContext *context)
{
	g_return_val_if_fail (style != NULL, NULL);

	if (!style->font || style->font_context != context) {
		char const *name;
		gboolean bold, italic;
		double size;

		gnm_style_clear_font ((GnmStyle *)style);

		if (elem_is_set (style, MSTYLE_FONT_NAME))
			name = gnm_style_get_font_name (style);
		else
			name = DEFAULT_FONT;

		if (elem_is_set (style, MSTYLE_FONT_BOLD))
			bold = gnm_style_get_font_bold (style);
		else
			bold = FALSE;

		if (elem_is_set (style, MSTYLE_FONT_ITALIC))
			italic = gnm_style_get_font_italic (style);
		else
			italic = FALSE;

		if (elem_is_set (style, MSTYLE_FONT_SIZE))
			size = gnm_style_get_font_size (style);
		else
			size = DEFAULT_SIZE;

		((GnmStyle *)style)->font =
			gnm_font_new (context, name, size, bold, italic);
		((GnmStyle *)style)->font_context = g_object_ref (context);
	}

	return style->font;
}

void
gnm_style_set_font_name (GnmStyle *style, char const *name)
{
	g_return_if_fail (name != NULL);
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_FONT_NAME);
	if (elem_is_set (style, MSTYLE_FONT_NAME))
		go_string_unref (style->font_detail.name);
	else
		elem_set (style, MSTYLE_FONT_NAME);
	style->font_detail.name = go_string_new (name);
	gnm_style_clear_font (style);
	gnm_style_clear_pango (style);
}

char const *
gnm_style_get_font_name (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_NAME), NULL);

	return style->font_detail.name->str;
}

void
gnm_style_set_font_bold (GnmStyle *style, gboolean bold)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_FONT_BOLD);
	elem_set (style, MSTYLE_FONT_BOLD);
	style->font_detail.bold = !!bold;
	gnm_style_clear_font (style);
	gnm_style_clear_pango (style);
}

gboolean
gnm_style_get_font_bold (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_BOLD), FALSE);

	return style->font_detail.bold;
}

void
gnm_style_set_font_italic (GnmStyle *style, gboolean italic)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_FONT_ITALIC);
	elem_set (style, MSTYLE_FONT_ITALIC);
	style->font_detail.italic = !!italic;
	gnm_style_clear_font (style);
	gnm_style_clear_pango (style);
}

gboolean
gnm_style_get_font_italic (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_ITALIC), FALSE);

	return style->font_detail.italic;
}

void
gnm_style_set_font_uline (GnmStyle *style, GnmUnderline const underline)
{
	g_return_if_fail (style != NULL);
	elem_changed (style, MSTYLE_FONT_UNDERLINE);
	elem_set (style, MSTYLE_FONT_UNDERLINE);
	style->font_detail.underline = underline;
	gnm_style_clear_pango (style);
}

GnmUnderline
gnm_style_get_font_uline (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, UNDERLINE_NONE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_UNDERLINE), UNDERLINE_NONE);

	return style->font_detail.underline;
}

void
gnm_style_set_font_strike (GnmStyle *style, gboolean strikethrough)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_FONT_STRIKETHROUGH);
	elem_set (style, MSTYLE_FONT_STRIKETHROUGH);
	style->font_detail.strikethrough = !!strikethrough;
	gnm_style_clear_pango (style);
}

gboolean
gnm_style_get_font_strike (GnmStyle const *style)
{
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_STRIKETHROUGH), FALSE);

	return style->font_detail.strikethrough;
}

void
gnm_style_set_font_script (GnmStyle *style, GOFontScript script)
{
	g_return_if_fail (style != NULL);
	elem_changed (style, MSTYLE_FONT_SCRIPT);
	elem_set (style, MSTYLE_FONT_SCRIPT);
	style->font_detail.script = script;
	gnm_style_clear_pango (style);
}

GOFontScript
gnm_style_get_font_script (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, GO_FONT_SCRIPT_STANDARD);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_SCRIPT), GO_FONT_SCRIPT_STANDARD);

	return style->font_detail.script;
}

void
gnm_style_set_font_size (GnmStyle *style, double size)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (size >= 1.);
	elem_changed (style, MSTYLE_FONT_SIZE);
	elem_set (style, MSTYLE_FONT_SIZE);
	style->font_detail.size = size;
	gnm_style_clear_font (style);
	gnm_style_clear_pango (style);
}

double
gnm_style_get_font_size (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, 12.0);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FONT_SIZE), 12.0);

	return style->font_detail.size;
}

void
gnm_style_set_format (GnmStyle *style, GOFormat const *format)
{
	g_return_if_fail (style != NULL);
	g_return_if_fail (format != NULL);

	elem_changed (style, MSTYLE_FORMAT);
	go_format_ref (format);
	elem_clear_contents (style, MSTYLE_FORMAT);
	elem_set (style, MSTYLE_FORMAT);
	style->format = format;
}

/*
 * gnm_style_set_format_text:
 *
 * @style: mstyle to change.
 * @format: An *untranslated* format string.
 */
void
gnm_style_set_format_text (GnmStyle *style, char const *format)
{
	GOFormat *sf;

	g_return_if_fail (style != NULL);
	g_return_if_fail (format != NULL);

	sf = go_format_new_from_XL (format);
	gnm_style_set_format (style, sf);
	go_format_unref (sf);
}

const GOFormat *
gnm_style_get_format (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_FORMAT), NULL);

	return style->format;
}

void
gnm_style_set_align_h (GnmStyle *style, GnmHAlign a)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_ALIGN_H);
	elem_set (style, MSTYLE_ALIGN_H);
	style->h_align = a;
}

GnmHAlign
gnm_style_get_align_h (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, GNM_HALIGN_LEFT);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_H), GNM_HALIGN_LEFT);

	return style->h_align;
}

void
gnm_style_set_align_v (GnmStyle *style, GnmVAlign a)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_ALIGN_V);
	elem_set (style, MSTYLE_ALIGN_V);
	style->v_align = a;
}

GnmVAlign
gnm_style_get_align_v (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, GNM_VALIGN_TOP);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_V), GNM_VALIGN_TOP);

	return style->v_align;
}

void
gnm_style_set_indent (GnmStyle *style, int i)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_INDENT);
	elem_set (style, MSTYLE_INDENT);
	style->indent = i;
}

int
gnm_style_get_indent (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, 0);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_INDENT), 0);

	return style->indent;
}

void
gnm_style_set_rotation (GnmStyle *style, int rot_deg)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_ROTATION);
	elem_set (style, MSTYLE_ROTATION);
	style->rotation = rot_deg;
}

int
gnm_style_get_rotation (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, 0);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_ROTATION), 0);

	return style->rotation;
}

void
gnm_style_set_text_dir (GnmStyle *style, GnmTextDir text_dir)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_TEXT_DIR);
	elem_set (style, MSTYLE_TEXT_DIR);
	style->text_dir = text_dir;
}

GnmTextDir
gnm_style_get_text_dir (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, GNM_TEXT_DIR_CONTEXT);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_TEXT_DIR), GNM_TEXT_DIR_CONTEXT);

	return style->text_dir;
}

void
gnm_style_set_wrap_text (GnmStyle *style, gboolean f)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_WRAP_TEXT);
	elem_set (style, MSTYLE_WRAP_TEXT);
	style->wrap_text = !!f;
}

gboolean
gnm_style_get_wrap_text (GnmStyle const *style)
{
	g_return_val_if_fail (elem_is_set (style, MSTYLE_WRAP_TEXT), FALSE);

	return style->wrap_text;
}

/*
 * Same as gnm_style_get_wrap_text except that if either halign or valign
 * is _JUSTIFY, the result will be TRUE.
 */
gboolean
gnm_style_get_effective_wrap_text (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_WRAP_TEXT), FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_V), FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_H), FALSE);

	/* Note: GNM_HALIGN_GENERAL never expands to GNM_HALIGN_JUSTIFY.  */
	return (style->wrap_text ||
		style->v_align == GNM_VALIGN_JUSTIFY ||
		style->v_align == GNM_VALIGN_DISTRIBUTED ||
		style->h_align == GNM_HALIGN_JUSTIFY);
}

void
gnm_style_set_shrink_to_fit (GnmStyle *style, gboolean f)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_SHRINK_TO_FIT);
	elem_set (style, MSTYLE_SHRINK_TO_FIT);
	style->shrink_to_fit = !!f;
}

gboolean
gnm_style_get_shrink_to_fit (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_SHRINK_TO_FIT), FALSE);

	return style->shrink_to_fit;
}

void
gnm_style_set_contents_locked (GnmStyle *style, gboolean f)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_CONTENTS_LOCKED);
	elem_set (style, MSTYLE_CONTENTS_LOCKED);
	style->contents_locked = !!f;
}

gboolean
gnm_style_get_contents_locked (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_CONTENTS_LOCKED), FALSE);

	return style->contents_locked;
}

void
gnm_style_set_contents_hidden (GnmStyle *style, gboolean f)
{
	g_return_if_fail (style != NULL);

	elem_changed (style, MSTYLE_CONTENTS_HIDDEN);
	elem_set (style, MSTYLE_CONTENTS_HIDDEN);
	style->contents_hidden = !!f;
}

gboolean
gnm_style_get_contents_hidden (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, FALSE);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_CONTENTS_HIDDEN), FALSE);

	return style->contents_hidden;
}

void
gnm_style_set_validation (GnmStyle *style, GnmValidation *v)
{
	g_return_if_fail (style != NULL);

	elem_clear_contents (style, MSTYLE_VALIDATION);
	elem_changed (style, MSTYLE_VALIDATION);
	elem_set (style, MSTYLE_VALIDATION);
	style->validation = v;
}

/**
 * gnm_style_get_validation:
 * @style: #GnmStyle
 *
 * Returns: (transfer none):
 **/
GnmValidation const *
gnm_style_get_validation (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_VALIDATION), NULL);

	return style->validation;
}

void
gnm_style_set_hlink (GnmStyle *style, GnmHLink *link)
{
	g_return_if_fail (style != NULL);

	elem_clear_contents (style, MSTYLE_HLINK);
	elem_changed (style, MSTYLE_HLINK);
	elem_set (style, MSTYLE_HLINK);
	style->hlink = link;
}

/**
 * gnm_style_get_hlink:
 * @style: #GnmStyle
 *
 * Returns: (transfer none): the associated #GnmHLink.
 **/
GnmHLink *
gnm_style_get_hlink (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_HLINK), NULL);

	return style->hlink;
}

void
gnm_style_set_input_msg (GnmStyle *style, GnmInputMsg *msg)
{
	g_return_if_fail (style != NULL);

	elem_clear_contents (style, MSTYLE_INPUT_MSG);
	elem_changed (style, MSTYLE_INPUT_MSG);
	elem_set (style, MSTYLE_INPUT_MSG);
	style->input_msg = msg;
}

/**
 * gnm_style_get_input_msg:
 * @style: #GnmStyle
 *
 * Returns: (transfer none):
 **/
GnmInputMsg *
gnm_style_get_input_msg (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_INPUT_MSG), NULL);

	return style->input_msg;
}

void
gnm_style_set_conditions (GnmStyle *style, GnmStyleConditions *sc)
{
	g_return_if_fail (style != NULL);

	elem_clear_contents (style, MSTYLE_CONDITIONS);
	elem_changed (style, MSTYLE_CONDITIONS);
	elem_set (style, MSTYLE_CONDITIONS);
	style->conditions = sc;
}

/**
 * gnm_style_get_conditions:
 * @style: #GnmStyle
 *
 * Returns: (transfer none):
 **/
GnmStyleConditions *
gnm_style_get_conditions (GnmStyle const *style)
{
	g_return_val_if_fail (style != NULL, NULL);
	g_return_val_if_fail (elem_is_set (style, MSTYLE_CONDITIONS), NULL);
	return style->conditions;
}

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

/*
 * Just a simple version for now.  We can also ignore most function
 * calls[1] and self-references[2].
 *
 * [1] Excluding volatile (TODAY, ...) and those that can create references
 * outside the arguments (INDIRECT).
 *
 * [2] References that print like A1 when used in A1.
 */
static gboolean
cond_expr_harmless (GnmExpr const *expr)
{
	GnmValue const *v = gnm_expr_get_constant (expr);
	if (v && v->type != VALUE_CELLRANGE)
		return TRUE;

	return FALSE;
}


void
gnm_style_link_dependents (GnmStyle *style, GnmRange const *r)
{
	GnmStyleConditions *sc;
	Sheet *sheet;

	g_return_if_fail (style != NULL);
	g_return_if_fail (r != NULL);

	sheet = style->linked_sheet;

	/*
	 * Conditional formatting.
	 *
	 * We need to trigger a reformatting of the cell if a cell referenced
	 * by the condition changes.
	 */
	sc = elem_is_set (style, MSTYLE_CONDITIONS)
		? gnm_style_get_conditions (style)
		: NULL;
	if (sc) {
		GPtrArray const *conds = gnm_style_conditions_details (sc);
		guint ui;
		if (debug_style_deps ())
			g_printerr ("Linking %s for %p\n",
				    range_as_string (r), style);
		for (ui = 0; conds && ui < conds->len; ui++) {
			GnmStyleCond const *c = g_ptr_array_index (conds, ui);
			guint ei;

			for (ei = 0; ei < 2; ei++) {
				GnmExprTop const *texpr =
					gnm_style_cond_get_expr (c, ei);
				if (!texpr ||
				    cond_expr_harmless (texpr->expr))
					continue;
				if (!style->deps)
					style->deps = g_ptr_array_new ();
				gnm_dep_style_dependency
					(sheet, texpr, r, style->deps);
			}
		}
	}

	/*
	 * Validations.
	 *
	 * We can probably ignore those.  If a dependent cell changes such
	 * that a validation condition is no longer satisfied, it is
	 * grandfathered in as valid.
	 */

	/* The style owns the deps.  */
}

void
gnm_style_unlink_dependents (GnmStyle *style, GnmRange const *r)
{
	unsigned ui, k;

	g_return_if_fail (style != NULL);
	g_return_if_fail (r != NULL);

	if (!style->deps)
		return;

	for (ui = k = 0; ui < style->deps->len; ui++) {
		GnmDependent *dep = g_ptr_array_index (style->deps, ui);
		GnmCellPos const *pos = dependent_pos (dep);

		if (range_contains (r, pos->col, pos->row)) {
			if (debug_style_deps ())
				g_printerr ("Unlinking %s for %p\n",
					    cellpos_as_string (pos), style);
			dependent_set_expr (dep, NULL);
			g_free (dep);
		} else {
			g_ptr_array_index (style->deps, k) = dep;
			k++;
		}
	}

	g_ptr_array_set_size (style->deps, k);
}


gboolean
gnm_style_visible_in_blank (GnmStyle const *style)
{
	GnmStyleElement i;

	g_return_val_if_fail (style != NULL, FALSE);

	if (elem_is_set (style, MSTYLE_PATTERN) &&
	    gnm_style_get_pattern (style) > 0)
		return TRUE;

	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_DIAGONAL; ++i)
		if (elem_is_set (style, i) &&
		    gnm_style_border_visible_in_blank (gnm_style_get_border (style, i)))
			return TRUE;

	return FALSE;
}

static void
add_attr (PangoAttrList *attrs, PangoAttribute *attr)
{
	attr->start_index = 0;
	attr->end_index = G_MAXINT;
	pango_attr_list_insert (attrs, attr);
}

/**
 * gnm_style_get_pango_attrs :
 * @style: #GnmStyle
 **/
PangoAttrList *
gnm_style_get_pango_attrs (GnmStyle const *style,
			   PangoContext *context,
			   double zoom)
{
	PangoAttrList *l;
	GnmUnderline ul;
	GnmFont *font = gnm_style_get_font (style, context);

	if (style->pango_attrs) {
		if (zoom == style->pango_attrs_zoom) {
			pango_attr_list_ref (style->pango_attrs);
			return style->pango_attrs;
		}
		pango_attr_list_unref (((GnmStyle *)style)->pango_attrs);
	}

	((GnmStyle *)style)->pango_attrs = l = pango_attr_list_new ();
	((GnmStyle *)style)->pango_attrs_zoom = zoom;
	((GnmStyle *)style)->pango_attrs_height = -1;

	/* Foreground colour.  */
	/* See http://bugzilla.gnome.org/show_bug.cgi?id=105322 */
	if (0) {
		GnmColor const *fore = style->color.font;
		add_attr (l, go_color_to_pango (fore->go_color, TRUE));
	}

	/* Handle underlining.  */
	ul = gnm_style_get_font_uline (style);
	if (ul != UNDERLINE_NONE)
		add_attr (l,
			  pango_attr_underline_new (gnm_translate_underline_to_pango (ul)));

	/* Handle strikethrough. */
	if (gnm_style_get_font_strike (style))
		add_attr (l, pango_attr_strikethrough_new (TRUE));

	/* Handle script. */
	switch (gnm_style_get_font_script (style)) {
	default :
	case GO_FONT_SCRIPT_STANDARD :
		break;
	case GO_FONT_SCRIPT_SUB :
		add_attr (l, go_pango_attr_subscript_new (TRUE));
		break;
	case GO_FONT_SCRIPT_SUPER :
		add_attr (l, go_pango_attr_superscript_new (TRUE));
		break;
	}

	add_attr (l, pango_attr_font_desc_new (font->go.font->desc));

	if (zoom != 1)
		add_attr (l, pango_attr_scale_new (zoom));

	pango_attr_list_ref (l);
	return l;
}

PangoAttrList *
gnm_style_generate_attrs_full (GnmStyle const *style)
{
	GnmColor const *fore = style->color.font;
	PangoAttrList *l = pango_attr_list_new ();

	add_attr (l, pango_attr_family_new (gnm_style_get_font_name (style)));
	add_attr (l, pango_attr_size_new (gnm_style_get_font_size (style) * PANGO_SCALE));
	add_attr (l, pango_attr_style_new (gnm_style_get_font_italic (style)
		? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL));
	add_attr (l, pango_attr_weight_new (gnm_style_get_font_bold (style)
		? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL));
	add_attr (l, go_color_to_pango (fore->go_color, TRUE));
	add_attr (l, pango_attr_strikethrough_new
		  (gnm_style_get_font_strike (style)));
	add_attr (l, pango_attr_underline_new
		  (gnm_translate_underline_to_pango
		   (gnm_style_get_font_uline (style))));
	return l;
}

int
gnm_style_get_pango_height (GnmStyle const *style,
			    PangoContext *context,
			    double zoom)
{
	PangoAttrList *attrs = gnm_style_get_pango_attrs (style, context, zoom);

	if (style->pango_attrs_height == -1) {
		int h;
		PangoLayout *layout = pango_layout_new (context);
		GOFormat const *fmt;
		gboolean requires_translation = FALSE;

		fmt = gnm_style_get_format (style);
		if (!go_format_is_general (fmt)) {
			GOFormatDetails details;
			go_format_get_details (fmt, &details, NULL);
			if (details.family == GO_FORMAT_SCIENTIFIC &&
			    details.use_markup) {
				PangoAttribute *a
					= go_pango_attr_superscript_new (TRUE);
				/* We want to superscript the "-01" in the */
				/* string "+1.23456789E-01" */
				a->start_index = 12;
				a->end_index = 15;
				pango_attr_list_insert (attrs, a);
				requires_translation = TRUE;
			}
		}
		pango_layout_set_attributes (layout, attrs);
		pango_layout_set_text (layout, "+1.23456789E-01", -1);
		if (requires_translation)
			go_pango_translate_layout (layout);
		pango_layout_get_pixel_size (layout, NULL, &h);
		g_object_unref (layout);
		((GnmStyle *)style)->pango_attrs_height = h;
	}

	pango_attr_list_unref (attrs);
	return style->pango_attrs_height;
}


void
gnm_style_set_from_pango_attribute (GnmStyle *style, PangoAttribute const *attr)
{
	switch (attr->klass->type) {
	case PANGO_ATTR_FAMILY :
		gnm_style_set_font_name (style, ((PangoAttrString *)attr)->value);
		break;
	case PANGO_ATTR_SIZE :
		gnm_style_set_font_size (style,
					 ((PangoAttrInt *)attr)->value / (double)PANGO_SCALE);
		break;
	case PANGO_ATTR_STYLE :
		gnm_style_set_font_italic (style,
			((PangoAttrInt *)attr)->value == PANGO_STYLE_ITALIC);
		break;
	case PANGO_ATTR_WEIGHT :
		gnm_style_set_font_bold (style,
			((PangoAttrInt *)attr)->value >= PANGO_WEIGHT_BOLD);
		break;
	case PANGO_ATTR_FOREGROUND :
		gnm_style_set_font_color (style, gnm_color_new_pango (
			&((PangoAttrColor *)attr)->color));
		break;
	case PANGO_ATTR_UNDERLINE :
		gnm_style_set_font_uline
			(style, gnm_translate_underline_from_pango
			 (((PangoAttrInt *)attr)->value));
		break;
	case PANGO_ATTR_STRIKETHROUGH :
		gnm_style_set_font_strike (style,
			((PangoAttrInt *)attr)->value != 0);
		break;
	default : {
		gboolean script_seen = FALSE, script_set = FALSE;
		if (attr->klass->type == go_pango_attr_superscript_get_attr_type ()) {
			script_seen = TRUE;
			if (((GOPangoAttrSuperscript *)attr)->val == 1) {
				script_set = TRUE;
				gnm_style_set_font_script
					(style, GO_FONT_SCRIPT_SUPER);
			}
		} else if (attr->klass->type == go_pango_attr_subscript_get_attr_type ()) {
			script_seen = TRUE;
			if (((GOPangoAttrSubscript *)attr)->val == 1) {
				script_set = TRUE;
				gnm_style_set_font_script
					(style, GO_FONT_SCRIPT_SUB);
			}
		}
		if (script_seen && !script_set)
			gnm_style_set_font_script
				(style, GO_FONT_SCRIPT_STANDARD);
		break; /* ignored */
	}
	}
}

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

static void
gnm_style_dump_color (GnmColor *color, GnmStyleElement elem)
{
	if (color)
		g_printerr ("\t%s: %x:%x:%x\n", gnm_style_element_name [elem],
			    GO_COLOR_UINT_R (color->go_color),
			    GO_COLOR_UINT_G (color->go_color),
			    GO_COLOR_UINT_B (color->go_color));
	else
		g_printerr ("\t%s: (NULL)\n", gnm_style_element_name [elem]);
}

static void
gnm_style_dump_border (GnmBorder *border, GnmStyleElement elem)
{
	g_printerr ("\t%s: ", gnm_style_element_name[elem]);
	if (border)
		g_printerr ("%d\n", border->line_type);
	else
		g_printerr ("blank\n");
}

void
gnm_style_dump (GnmStyle const *style)
{
	int i;

	g_printerr ("Style Refs %d\n", style->ref_count);
	if (elem_is_set (style, MSTYLE_COLOR_BACK))
		gnm_style_dump_color (style->color.back, MSTYLE_COLOR_BACK);
	if (elem_is_set (style, MSTYLE_COLOR_PATTERN))
		gnm_style_dump_color (style->color.pattern, MSTYLE_COLOR_PATTERN);

	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_DIAGONAL; ++i)
		if (elem_is_set (style, i))
			gnm_style_dump_border (style->borders[i-MSTYLE_BORDER_TOP], i);

	if (elem_is_set (style, MSTYLE_PATTERN))
		g_printerr ("\tpattern %d\n", style->pattern);
	if (elem_is_set (style, MSTYLE_FONT_COLOR))
		gnm_style_dump_color (style->color.font, MSTYLE_FONT_COLOR);
	if (elem_is_set (style, MSTYLE_FONT_NAME))
		g_printerr ("\tname '%s'\n", style->font_detail.name->str);
	if (elem_is_set (style, MSTYLE_FONT_BOLD))
		g_printerr (style->font_detail.bold ? "\tbold\n" : "\tnot bold\n");
	if (elem_is_set (style, MSTYLE_FONT_ITALIC))
		g_printerr (style->font_detail.italic ? "\titalic\n" : "\tnot italic\n");
	if (elem_is_set (style, MSTYLE_FONT_UNDERLINE))
		switch (style->font_detail.underline) {
		default :
		case UNDERLINE_NONE :
			g_printerr ("\tno underline\n"); break;
		case UNDERLINE_SINGLE :
			g_printerr ("\tsingle underline\n"); break;
		case UNDERLINE_DOUBLE :
			g_printerr ("\tdouble underline\n"); break;
		}
	if (elem_is_set (style, MSTYLE_FONT_STRIKETHROUGH))
		g_printerr (style->font_detail.strikethrough ? "\tstrikethrough\n" : "\tno strikethrough\n");
	if (elem_is_set (style, MSTYLE_FONT_SCRIPT))
		switch (style->font_detail.script) {
		case GO_FONT_SCRIPT_SUB :
			g_printerr ("\tsubscript\n"); break;
		default :
		case GO_FONT_SCRIPT_STANDARD :
			g_printerr ("\tno super or sub\n"); break;
		case GO_FONT_SCRIPT_SUPER :
			g_printerr ("\tsuperscript\n"); break;
		}
	if (elem_is_set (style, MSTYLE_FONT_SIZE))
		g_printerr ("\tsize %f\n", style->font_detail.size);
	if (elem_is_set (style, MSTYLE_FORMAT)) {
		const char *fmt = go_format_as_XL (style->format);
		g_printerr ("\tformat '%s'\n", fmt);
	}
	if (elem_is_set (style, MSTYLE_ALIGN_V))
		g_printerr ("\tvalign %hd\n", (short)style->v_align);
	if (elem_is_set (style, MSTYLE_ALIGN_H))
		g_printerr ("\thalign %hd\n", (short)style->h_align);
	if (elem_is_set (style, MSTYLE_INDENT))
		g_printerr ("\tindent %d\n", style->indent);
	if (elem_is_set (style, MSTYLE_ROTATION))
		g_printerr ("\trotation %d\n", style->rotation);
	if (elem_is_set (style, MSTYLE_TEXT_DIR))
		g_printerr ("\ttext dir %d\n", style->text_dir);
	if (elem_is_set (style, MSTYLE_WRAP_TEXT))
		g_printerr ("\twrap text %d\n", style->wrap_text);
	if (elem_is_set (style, MSTYLE_SHRINK_TO_FIT))
		g_printerr ("\tshrink to fit %d\n", style->shrink_to_fit);
	if (elem_is_set (style, MSTYLE_CONTENTS_LOCKED))
		g_printerr ("\tlocked %d\n", style->contents_locked);
	if (elem_is_set (style, MSTYLE_CONTENTS_HIDDEN))
		g_printerr ("\thidden %d\n", style->contents_hidden);
	if (elem_is_set (style, MSTYLE_VALIDATION))
		g_printerr ("\tvalidation %p\n", (void *)style->validation);
	if (elem_is_set (style, MSTYLE_HLINK))
		g_printerr ("\thlink %p\n", (void *)style->hlink);
	if (elem_is_set (style, MSTYLE_INPUT_MSG))
		g_printerr ("\tinput msg %p\n", (void *)style->input_msg);
	if (elem_is_set (style, MSTYLE_CONDITIONS))
		g_printerr ("\tconditions %p\n", (void *)style->conditions);
}

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

void
gnm_style_init (void)
{
#if USE_MSTYLE_POOL
	gnm_style_pool =
		go_mem_chunk_new ("style pool",
				   sizeof (GnmStyle),
				   16 * 1024 - 128);
#endif
}

#if USE_MSTYLE_POOL
static void
cb_gnm_style_pool_leak (gpointer data, G_GNUC_UNUSED gpointer user)
{
	GnmStyle *style = data;
	g_printerr ("Leaking style at %p.\n", (void *)style);
	gnm_style_dump (style);
}
#endif

void
gnm_style_shutdown (void)
{
#if USE_MSTYLE_POOL
	go_mem_chunk_foreach_leak (gnm_style_pool, cb_gnm_style_pool_leak, NULL);
	go_mem_chunk_destroy (gnm_style_pool, FALSE);
	gnm_style_pool = NULL;
#endif
}
