/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * Copyright 2004 Yeico S. A. de C. V. All Rights Reserved.
 * Copyright 2008-2011 David Hoerl All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <sstream>

#include "../xlslib/record.h"
#include "../xlslib/extformat.h"
#include "../xlslib/globalrec.h"
#include "../xlslib/rectypes.h"


using namespace std;
using namespace xlslib_core;


/*
 **********************************
 * xf_t class implementation
 **********************************
 */

const xf_init_t xf_t::xfiInit;

const unsigned8_t xf_t::HALIGN_OPTIONS_TABLE[_NUM_HALIGN_OPTIONS] =
{
	XF_HALIGN_GENERAL,
	XF_HALIGN_LEFT,
	XF_HALIGN_CENTER,
	XF_HALIGN_RIGHT,
	XF_HALIGN_FILL,
	XF_HALIGN_JUSTIFY,
	XF_HALIGN_CENTERACCROSS
};

const unsigned8_t xf_t::VALIGN_OPTIONS_TABLE[_NUM_VALIGN_OPTIONS] =
{
	XF_VALIGN_TOP,
	XF_VALIGN_CENTER,
	XF_VALIGN_BOTTOM,
	XF_VALIGN_JUSTIFY
};

const unsigned8_t xf_t::INDENT_OPTIONS_TABLE[_NUM_INDENT_OPTIONS] =
{
	XF_INDENT_0,
	XF_INDENT_1,
	XF_INDENT_2,
	XF_INDENT_3,
	XF_INDENT_4,
	XF_INDENT_5,
	XF_INDENT_6,
	XF_INDENT_7,
	XF_INDENT_8,
	XF_INDENT_9,
	XF_INDENT_10,
	XF_INDENT_11,
	XF_INDENT_12,
	XF_INDENT_13,
	XF_INDENT_14,
	XF_INDENT_15,
	XF_INDENT_SHRINK2FIT,
	XF_INDENT_L2R,
	XF_INDENT_R2L
};

const unsigned8_t xf_t::TXTORI_OPTIONS_TABLE[_NUM_TXTORI_OPTIONS] =
{
	XF_ORI_NONE,
	XF_ORI_TOPBOTTOMTXT,
	XF_ORI_90NOCLOCKTXT,
	XF_ORI_90CLOCKTXT
};

const unsigned8_t xf_t::COLOR_OPTIONS_TABLE[_NUM_COLOR_NAMES] =
{
	0,  // Black as used in the default fonts
	COLOR_CODE_BLACK,
	COLOR_CODE_BROWN,
	COLOR_CODE_OLIVE_GREEN,
	COLOR_CODE_DARK_GREEN,
	COLOR_CODE_DARK_TEAL,
	COLOR_CODE_DARK_BLUE,
	COLOR_CODE_INDIGO,
	COLOR_CODE_GRAY80,

	COLOR_CODE_DARK_RED,
	COLOR_CODE_ORANGE,
	COLOR_CODE_DARK_YELLOW,
	COLOR_CODE_GREEN,
	COLOR_CODE_TEAL,
	COLOR_CODE_BLUE,
	COLOR_CODE_BLUE_GRAY,
	COLOR_CODE_GRAY50,

	COLOR_CODE_RED,
	COLOR_CODE_LIGHT_ORANGE,
	COLOR_CODE_LIME,
	COLOR_CODE_SEA_GREEN,
	COLOR_CODE_AQUA,
	COLOR_CODE_LIGHT_BLUE,
	COLOR_CODE_VIOLET,
	COLOR_CODE_GRAY40,

	COLOR_CODE_PINK,
	COLOR_CODE_GOLD,
	COLOR_CODE_YELLOW,
	COLOR_CODE_BRIGHT_GREEN,
	COLOR_CODE_TURQUOISE,
	COLOR_CODE_SKY_BLUE,
	COLOR_CODE_PLUM,
	COLOR_CODE_GRAY25,

	COLOR_CODE_ROSE,
	COLOR_CODE_TAN,
	COLOR_CODE_LIGHT_YELLOW,
	COLOR_CODE_LIGHT_GREEN,
	COLOR_CODE_LIGHT_TURQUOISE,
	COLOR_CODE_PALEBLUE,
	COLOR_CODE_LAVENDER,
	COLOR_CODE_WHITE,

	COLOR_CODE_PERIWINKLE,
	COLOR_CODE_DARK_BLUE2,
	COLOR_CODE_PLUM2,
	COLOR_CODE_PINK2,
	COLOR_CODE_IVORY,
	COLOR_CODE_YELLOW2,
	COLOR_CODE_LIGHT_TURQUOISE2,
	COLOR_CODE_TURQUOISE2,

	COLOR_CODE_DARK_PURPLE,
	COLOR_CODE_VIOLET2,
	COLOR_CODE_CORAL,
	COLOR_CODE_DARK_RED2,
	COLOR_CODE_OCEAN_BLUE,
	COLOR_CODE_TEAL2,
	COLOR_CODE_ICE_BLUE,
	COLOR_CODE_BLUE2,

	COLOR_CODE_SYS_WIND_FG,
	COLOR_CODE_SYS_WIND_BG
};

const unsigned8_t xf_t::FILL_OPTIONS_TABLE[_NUM_FILL_OPTIONS] =
{
	XF_FILL_NONE,
	XF_FILL_SOLID,
	XF_FILL_ATEN75,
	XF_FILL_ATEN50,
	XF_FILL_ATEN25,
	XF_FILL_ATEN12,
	XF_FILL_ATEN06,
	XF_FILL_HORIZ_LIN,
	XF_FILL_VERTICAL_LIN,
	XF_FILL_DIAG,
	XF_FILL_INV_DIAG,
	XF_FILL_INTER_DIAG,
	XF_FILL_DIAG_THICK_INTER,
	XF_FILL_HORIZ_LINES_THIN,
	XF_FILL_VERTICAL_LINES_THIN,
	XF_FILL_DIAG_THIN,
	XF_FILL_INV_DIAG_THIN,
	XF_FILL_HORIZ_INT_THIN,
	XF_FILL_HORIZ_INTER_THICK
};

const unsigned8_t xf_t::BORDERSTYLE_OPTIONS_TABLE[_NUM_BORDER_STYLES] =
{
	XF_BRDOPTION_NONE,
	XF_BRDOPTION_THIN,
	XF_BRDOPTION_MEDIUM,
	XF_BRDOPTION_DASHED,
	XF_BRDOPTION_DOTTED,
	XF_BRDOPTION_THICK,
	XF_BRDOPTION_DOUBLE,
	XF_BRDOPTION_HAIR
};

/*
 ******************************************************
 * class xf_init_t: convenience structure to init an xf_t
 ******************************************************
 */
xf_init_t::xf_init_t() :
	font(NULL),
	formatIndex(FMTCODE_GENERAL),

	locked(XF_LOCKED),
	hidden(XF_NO_HIDDEN),
	wrap(XF_NO_WRAPPED),

	halign(HALIGN_GENERAL),
	valign(VALIGN_BOTTOM),

	indent(INDENT_0),
	txt_orient(ORI_NONE),

	fillstyle(FILL_NONE),
	fill_fgcolor(CLR_SYS_WIND_FG),
	fill_bgcolor(CLR_SYS_WIND_BG),

	border_style(),
	border_color()
{
	for(int i=0; i<_NUM_BORDERS; ++i) {
		border_style[i]	= BORDER_NONE;
		border_color[i] = ORIG_COLOR_BLACK;
	}
}

xf_init_t::~xf_init_t()
{
}

xf_init_t::xf_init_t(const xf_init_t &that) :
	font(that.font),
	formatIndex(that.formatIndex),

	locked(that.locked),
	hidden(that.hidden),
	wrap(that.wrap),

	halign(that.halign),
	valign(that.valign),

	indent(that.indent),
	txt_orient(that.txt_orient),

	fillstyle(that.fillstyle),
	fill_fgcolor(that.fill_fgcolor),
	fill_bgcolor(that.fill_bgcolor),

	border_style(),
	border_color()
{
	for(int i=0; i<_NUM_BORDERS; ++i) {
		border_style[i]	= that.border_style[i];
		border_color[i] = that.border_color[i];
	}
}

xf_init_t& xf_init_t::operator=(const xf_init_t& right)
{
	(void)right;    // stop warning
	throw std::string("Should never have invoked the xf_init_t copy operator!");
}

bool xf_init_t::operator==(const xf_init_t& right)
{
	// used by "range" in doing mass changes. Try to arrange so most
	// likely failures occur early

	if(font != right.font) {return false; }

	if(fill_fgcolor != right.fill_fgcolor) {return false; }
	if(fill_bgcolor != right.fill_bgcolor) {return false; }
	if(fillstyle != right.fillstyle) {return false; }

	for(int i=0; i<_NUM_BORDERS; ++i) {
		if(border_style[i] != right.border_style[i]) {return false; }
		if(border_color[i] != right.border_color[i]) {return false; }
	}

	if(halign != right.halign) {return false; }
	if(valign != right.valign) {return false; }
	if(indent != right.indent) {return false; }
	if(txt_orient != right.txt_orient) {return false; }

	if(locked != right.locked) {return false; }
	if(hidden != right.hidden) {return false; }
	if(wrap != right.wrap) {return false; }

	return true;
}

const xf_init_t &xf_t::GetDefaultXFshadow(CGlobalRecords& gRecords, bool userXF, bool isCell)
{
	(void)userXF; // remove warning
	if (!isCell) {
		const xf_t *xf = gRecords.GetDefaultXF();

		if (xf)	{
			return xf->GetXFshadow();
		}
	}
	return xfiInit;
}

/*
 ******************************************
 * GlobalRec, xftDup, and range(userXF==no)
 ******************************************
 */
xf_t::xf_t(xlslib_core::CGlobalRecords& gRecords, bool userXF, bool isCell, bool isMasterXF) :
	m_GlobalRecords(gRecords),
	xfi(GetDefaultXFshadow(gRecords, userXF, isCell)),
	m_usage_counter(0),
	index(0),
	parent_index(0),

	formatIndex(FMTCODE_GENERAL),
	font(NULL),
	format(NULL),
	halign(XF_HALIGN_GENERAL),
	valign(XF_VALIGN_BOTTOM),
	indent(XF_INDENT_0),
	txt_orient(XF_ORI_NONE),
	fillstyle(XF_FILL_NONE),
	fill_fgcolor(ORIG_COLOR_BLACK),
	fill_bgcolor(ORIG_COLOR_BLACK),

	locked(XF_NO_LOCKED),
	hidden(XF_NO_HIDDEN),
	wrap(XF_NO_WRAPPED),
	is_cell(isCell),
	is_userXF(userXF),

	border_style(),
	border_color(),

	flags(0)
{
	//	SetCellMode(isCell);

	// Flags have different meanings for Cell or Style formats
	flags = (isCell || isMasterXF) ? 0 : XF_ALIGN_ALL;

	// Set a default value for class members
	SetFormatIndex(xfi.formatIndex);
	SetHAlign(xfi.halign);
	SetVAlign(xfi.valign);
	SetIndent(xfi.indent);
	SetTxtOrientation(xfi.txt_orient);
	SetFillFGColor(xfi.fill_fgcolor);
	SetFillBGColor(xfi.fill_bgcolor);
	SetFillStyle(xfi.fillstyle);

	SetLocked(xfi.locked);
	SetHidden(xfi.hidden);
	SetWrap(xfi.wrap);

	for(int i=0; i<_NUM_BORDERS; ++i) {
		SetBorderStyle((border_side_t)i, xfi.border_style[i]);
		SetBorderColor((border_side_t)i, xfi.border_color[i]);
	}

	if(is_userXF) {
		m_GlobalRecords.AddXFormat(this);
	}
}

/*
 **********************************
 * Only for use by users
 **********************************
 */
xf_t::xf_t(const xf_t& orig) :
	m_GlobalRecords(orig.m_GlobalRecords),
	xfi(orig.xfi),
	m_usage_counter(0),
	index(0),
	parent_index(0),

	formatIndex(orig.formatIndex),
	font(NULL),                         // yes, need this as SetFont below depends on a set value
	format(NULL),
	halign(orig.halign),
	valign(orig.valign),
	indent(orig.indent),
	txt_orient(orig.txt_orient),
	fillstyle(orig.fillstyle),
	fill_fgcolor(orig.fill_fgcolor),
	fill_bgcolor(orig.fill_bgcolor),

	locked(orig.locked),
	hidden(orig.hidden),
	wrap(orig.wrap),
	is_cell(true),
	is_userXF(true),

	border_style(),
	border_color(),

	flags(orig.flags)
{
	SetFont(orig.font); // side effects
	if (orig.format) {
		SetFormat(orig.format); // side effects
	}

	for(int i=0; i<_NUM_BORDERS; ++i) {
		border_style[i]	= orig.border_style[i];
		border_color[i] = orig.border_color[i];
	}

	m_GlobalRecords.AddXFormat(this);
}

/*
 **********************************
 * Constructor using pre-set values: range
 **********************************
 */
xf_t::xf_t(CGlobalRecords& gRecords, const xf_init_t& xfinit) :
	m_GlobalRecords(gRecords),
	xfi(xfinit),
	m_usage_counter(0),
	index(0),
	parent_index(0),

	formatIndex(FMTCODE_GENERAL),
	font(NULL),
	format(NULL),
	halign(XF_HALIGN_GENERAL),
	valign(XF_VALIGN_BOTTOM),
	indent(XF_INDENT_0),
	txt_orient(XF_ORI_NONE),
	fillstyle(XF_FILL_NONE),
	fill_fgcolor(ORIG_COLOR_BLACK),
	fill_bgcolor(ORIG_COLOR_BLACK),

	locked(XF_NO_LOCKED),
	hidden(XF_NO_HIDDEN),
	wrap(XF_NO_WRAPPED),
	is_cell(true),
	is_userXF(true),

	border_style(),
	border_color(),

	flags(0)
{
	SetFont(xfinit.font);   // side effects
	//SetFormat(xfinit.format);	// side effects
	SetFormatIndex(xfinit.formatIndex);

	SetHAlign(xfinit.halign);
	SetVAlign(xfinit.valign);
	SetIndent(xfinit.indent);
	SetTxtOrientation(xfinit.txt_orient);
	SetFillFGColor(xfinit.fill_fgcolor);
	SetFillBGColor(xfinit.fill_bgcolor);
	SetFillStyle(xfinit.fillstyle);
	SetLocked(xfinit.locked);
	SetHidden(xfinit.hidden);
	SetWrap(xfinit.wrap);

	for(int i=0; i<_NUM_BORDERS; ++i) {
		SetBorderStyle((border_side_t)i, xfinit.border_style[i]);
		SetBorderColor((border_side_t)i, xfinit.border_color[i]);
	}
	m_GlobalRecords.AddXFormat(this);
}

xf_t::~xf_t()
{
}

void xf_t::SetFlag(unsigned8_t flag)
{
	if(IsCell()) {
#if 0
		if((flags & flag) == 0) {
			// The flag forces all these fields to be defined, so init them to defaults
			switch(flag) {
			case XF_ALIGN_ATRALC:
				XL_ASSERT(valign == XF_VALIGN_BOTTOM); /* is already set as default through xfinit() */
				break;
			case XF_ALIGN_ATRPAT:
				XL_ASSERT(fill_fgcolor == COLOR_CODE_SYS_WIND_FG);
				XL_ASSERT(fill_bgcolor == COLOR_CODE_SYS_WIND_BG);
				break;
			case XF_ALIGN_ATRBDR:
				XL_ASSERT(valign == XF_VALIGN_BOTTOM);
				break;
			}
		}
#endif
		// Cells indicate that a characteristic is not equal
		//  from its parent with the flag set.
		flags |= flag;
	} else {
		// Styles indicate that a characteristic is
		// being implemented with the flag cleared.
		flags &= ~flag;
	}
}

void xf_t::ClearFlag(unsigned8_t flag)
{
	if(!IsCell()) {
		// Cells indicate that a characteristic is not equal
		//  from its parent with the flag set.
		flags |= flag;
	} else {
		// Styles indicate that a characteristic is
		// being implemented with the flag cleared.
		flags &= ~flag;
	}
}

unsigned8_t xf_t::GetFlags() const
{
	return flags;
}

void xf_t::AtuneXF(void)
{
	if(font != xfi.font) {
		SetFlag(XF_ALIGN_ATRFONT);
	}
	if(formatIndex != xfi.formatIndex) {
		SetFlag(XF_ALIGN_ATRNUM);
	}

	for(int side = 0; side < _NUM_BORDERS; ++side) {
		if(border_style[side] != xfi.border_style[side]) {
			SetFlag(XF_ALIGN_ATRBDR);
		}
		if(border_color[side] != xfi.border_color[side]) {
			SetFlag(XF_ALIGN_ATRBDR);
		}
	}

	if(halign != xfi.halign) {
		SetFlag(XF_ALIGN_ATRALC);
	}
	if(valign != xfi.valign) {
		SetFlag(XF_ALIGN_ATRALC);
	}
	if(indent != xfi.indent) {
		SetFlag(XF_ALIGN_ATRALC);
	}
	if(txt_orient != xfi.txt_orient) {
		SetFlag(XF_ALIGN_ATRALC);
	}
	if(fill_fgcolor != xfi.fill_fgcolor) {
		SetFlag(XF_ALIGN_ATRPAT);
	}
	if(fill_bgcolor != xfi.fill_bgcolor) {
		SetFlag(XF_ALIGN_ATRPAT);
	}
	if(fillstyle != xfi.fillstyle) {
		SetFlag(XF_ALIGN_ATRPAT);
	}
	if(locked != xfi.locked) {
		SetFlag(XF_ALIGN_ATRPROT);
	}
	if(hidden != xfi.hidden) {
		SetFlag(XF_ALIGN_ATRPROT);
	}
	if(wrap != xfi.wrap) {
		SetFlag(XF_ALIGN_ATRALC);
	}
}

void xf_t::MarkUsed(void)
{
	m_usage_counter++;
}

void xf_t::UnMarkUsed(void)
{
	if(m_usage_counter) {
		m_usage_counter--;
	}

	if(m_usage_counter == 0) {
		if (font && font->Usage()) {
			font->UnMarkUsed();
		}
		if (format && format->Usage()) {
			format->UnMarkUsed();
		}
	}
}

unsigned32_t xf_t::Usage(void) const
{
	return m_usage_counter;
}

void xf_t::SetParent(const xf_t* parent)
{
	if (parent)	{
		xfi = parent->xfi;

		// now make sure all the flags are properly set, given that we probably have altered xfi 'shadow base' by now.
		AtuneXF();
	}
}

unsigned16_t xf_t::GetParentIndex(void) const
{
	/* TBD: derive XF's from other XF's, including the standard ones */
	return 0;
}

const xf_t* xf_t::GetParent(void) const
{
	return NULL;
}

void xf_t::SetFont(font_t* newfont)
{
	// Set the related flag
	if(newfont != xf_t::xfiInit.font) {
		SetFlag(XF_ALIGN_ATRFONT);
	}
	if(font) {
		font->UnMarkUsed();
	}

	font = newfont;
	if(font) {
		font->MarkUsed();
	}
}

font_t* xf_t::GetFont(void) const
{
	return font;
}

unsigned16_t xf_t::GetFontIndex(void) const
{
	if(font != NULL) {
		return font->GetIndex();
	} else {
		return 0;
	}
}

void xf_t::SetFormatIndex(unsigned16_t formatidx)
{
	// Set the related flag.
	if(formatidx != xf_t::xfiInit.formatIndex) {
		SetFlag(XF_ALIGN_ATRNUM);
	}
	formatIndex = formatidx;
	format = NULL;
}

void xf_t::SetFormat(format_number_t fmt)
{
	unsigned16_t idx;

	if(fmt > FMT_TEXT) {
		fmt = FMT_GENERAL;
	}
	idx = format_t::format2index(fmt);

	// Set the related flag.
	if(idx != xf_t::xfiInit.formatIndex) {
		SetFlag(XF_ALIGN_ATRNUM);
	}
	formatIndex = idx;
	format = NULL;
}

void xf_t::SetFormat(format_t *fmt)
{
	if (!fmt) {
		return;
	}

	if (format)	{
		format->UnMarkUsed();
	}

	unsigned16_t idx = fmt->GetIndex();

	// Set the related flag.
	if(idx != xf_t::xfiInit.formatIndex) {
		SetFlag(XF_ALIGN_ATRNUM);
	}

	formatIndex = idx;
	format = fmt;

	format->MarkUsed();
	//cerr << "ndx=" << formatIndex << endl << flush;
}

unsigned16_t xf_t::GetFormatIndex(void) const
{
	return formatIndex;
}

format_number_t xf_t::GetFormat(void) const
{
	int frmt;

	for(frmt=(int)FMT_GENERAL; frmt<=(int)FMT_TEXT; ++frmt)	{
		if(formatIndex == format_t::format2index((format_number_t)frmt)) {
			return (format_number_t)frmt;
		}
	}
	return FMT_GENERAL; // should never get here...
}

std::string xf_t::Description() const
{
	basic_ostringstream<char>	buf;

	buf << "-----------------------------------------" << endl;

	buf << "      INDEX: " << index << " parent=" << parent_index << " usage=" <<  m_usage_counter << endl;
	buf << "       Font: " << hex << font << dec << endl;
	buf << "  FormatIdx: " << formatIndex << endl;
	buf << "      Align: " << "h=" << hex << (int)halign << " v=" << (int)valign << " indent=" << (int)indent << " orient=" << (int)txt_orient << dec << endl;
	buf << "       Fill: " << "fgClr=" << (int)fill_fgcolor << " bgClr=" << (int)fill_bgcolor << " style=" << (int)fillstyle << dec << endl;
	buf << "  TopBorder: " << "style=" << hex << (int)border_style[BORDER_TOP] << " color=" << (int)border_color[BORDER_TOP] << dec << endl;
	buf << "  BotBorder: " << "style=" << hex << (int)border_style[BORDER_BOTTOM] << " color=" << (int)border_color[BORDER_BOTTOM] << dec << endl;
	buf << " LeftBorder: " << "style=" << hex << (int)border_style[BORDER_LEFT] << " color=" << (int)border_color[BORDER_LEFT] << dec << endl;
	buf << "RightBorder: " << "style=" << hex << (int)border_style[BORDER_RIGHT] << " color=" << (int)border_color[BORDER_RIGHT] << dec << endl;
	buf << "      Logic: " << "locked=" << locked << " hidden=" << hidden << " wrap=" << wrap << " isCell=" << is_cell << " isUserXF=" << is_userXF << endl;
	buf << "      FLAGS: " << hex << (int)flags << dec << endl;

	return buf.str();
}

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

/* Cell option wrappers*/
void xf_t::SetBorderStyle(border_side_t side, border_style_t style)
{
	XL_ASSERT(side >= 0);
	XL_ASSERT(side < _NUM_BORDERS);
	XL_ASSERT(style >= 0);
	XL_ASSERT(style < _NUM_BORDER_STYLES);
	border_style[side] = BORDERSTYLE_OPTIONS_TABLE[style];

	if(border_style[side] != xf_t::xfiInit.border_style[side]) {
		SetFlag(XF_ALIGN_ATRBDR);
	}
	// fix up XF record for Excel, who does not like color == 0 when the style is not NONE!
	if (IsCell() && border_color[side] == 0) {
		border_color[side] = COLOR_OPTIONS_TABLE[CLR_SYS_WIND_FG];
	}
}

void xf_t::SetBorderColor(border_side_t side, color_name_t color)
{
	XL_ASSERT(side >= 0);
	XL_ASSERT(side < _NUM_BORDERS);
	XL_ASSERT(color >= 0);
	XL_ASSERT(color < _NUM_COLOR_NAMES);
	border_color[side] = COLOR_OPTIONS_TABLE[color];

	if(border_color[side] != xf_t::xfiInit.border_color[side]) {
		SetFlag(XF_ALIGN_ATRBDR);
	}
}

void xf_t::SetBorderColor(border_side_t side, unsigned8_t color)
{
	XL_ASSERT(side >= 0);
	XL_ASSERT(side < _NUM_BORDERS);
	border_color[side] = color;

	if(border_color[side] != xf_t::xfiInit.border_color[side]) {
		SetFlag(XF_ALIGN_ATRBDR);
	}
}

/*
 **********************************
 **********************************
 */
unsigned8_t xf_t::GetBorderStyle(border_side_t side) const
{
	XL_ASSERT(side >= 0);
	XL_ASSERT(side < _NUM_BORDERS);
	return border_style[side];
}

/*
 **********************************
 **********************************
 */
unsigned16_t xf_t::GetBorderColorIdx(border_side_t side) const
{
	XL_ASSERT(side >= 0);
	XL_ASSERT(side < _NUM_BORDERS);
	return border_color[side];
}

xf_t& xf_t::operator=(const xf_t& right)
{
	if (&right != this)	{
		//m_GlobalRecords = right.GetGlobalRecords();
		xfi = right.xfi;

		index		= right.index; // or -1 or 0 ?
		parent_index = right.parent_index;

		font		= right.font;
		formatIndex = right.formatIndex;
		format      = right.format;

		halign = right.halign;
		valign = right.valign;
		indent = right.indent;

		txt_orient		= right.txt_orient;

		fill_fgcolor	= right.fill_fgcolor;
		fill_bgcolor	= right.fill_bgcolor;
		fillstyle		= right.fillstyle;

		locked		= right.locked;
		hidden		= right.hidden;
		wrap		= right.wrap;
		is_cell		= right.is_cell;
		is_userXF	= right.is_userXF;

		flags = right.flags;

		for(int i=0; i<_NUM_BORDERS; ++i) {
			border_style[i]	= right.border_style[i];
			border_color[i] = right.border_color[i];
		}
	}

	return *this;
}

bool xf_t::operator==(const xf_t& right)
{
	if (formatIndex != right.formatIndex)
		return false;
	if (font != right.font)
		return false;
	if (format != right.format)
		return false;

	if (halign != right.halign)
		return false;
	if (valign != right.valign)
		return false;
	if (indent != right.indent)
		return false;
	if (txt_orient != right.txt_orient)
		return false;

	if (fillstyle != right.fillstyle)
		return false;
	if (fill_fgcolor != right.fill_fgcolor)
		return false;
	if (fill_bgcolor != right.fill_bgcolor)
		return false;

	if (locked != right.locked)
		return false;
	if (hidden != right.hidden)
		return false;
	if (wrap != right.wrap)
		return false;
	if (is_cell != right.is_cell)
		return false;
	if (is_userXF != right.is_userXF)
		return false;

	for (int i=0; i<_NUM_BORDERS; i++) {
		if (border_style[i] != right.border_style[i])
			return false;
		if (border_color[i] != right.border_color[i])
	  		return false;
	}

	if (flags != right.flags)
		return false;

	return true;
}

/* Horizontal Align option wrappers*/
void xf_t::SetHAlign(halign_option_t ha_option)
{
	// Set the related flag.
	if(ha_option != xf_t::xfiInit.halign) {
		SetFlag(XF_ALIGN_ATRALC);
	}

	XL_ASSERT(ha_option >= 0);
	XL_ASSERT(ha_option < _NUM_HALIGN_OPTIONS);
	halign = xf_t::HALIGN_OPTIONS_TABLE[ha_option];
}

unsigned8_t xf_t::GetHAlign(void) const
{
	return halign;
}

/* Vertical Align option wrappers*/
void xf_t::SetVAlign(valign_option_t va_option)
{
	// Set the related flag.
	if(va_option != xf_t::xfiInit.valign) {
		SetFlag(XF_ALIGN_ATRALC);
	}

	XL_ASSERT(va_option >= 0);
	XL_ASSERT(va_option < _NUM_VALIGN_OPTIONS);
	valign = xf_t::VALIGN_OPTIONS_TABLE[va_option];
}

unsigned8_t xf_t::GetVAlign(void) const
{
	return valign;
}

void xf_t::SetIndent(indent_option_t indent_option)
{
	// Set the related flag.
	if(indent_option != xf_t::xfiInit.indent) {
		SetFlag(XF_ALIGN_ATRALC);
	}

	XL_ASSERT(indent_option >= 0);
	XL_ASSERT(indent_option < _NUM_INDENT_OPTIONS);
	indent = xf_t::INDENT_OPTIONS_TABLE[indent_option];
}

unsigned8_t xf_t::GetIndent(void) const
{
	return indent;
}

/* Text orientation option wrappers*/
void xf_t::SetTxtOrientation(txtori_option_t ori_option)
{
	// Set the related flag.
	if(ori_option != xf_t::xfiInit.txt_orient) {
		SetFlag(XF_ALIGN_ATRALC);
	}

	XL_ASSERT(ori_option >= 0);
	XL_ASSERT(ori_option < _NUM_TXTORI_OPTIONS);
	txt_orient = xf_t::TXTORI_OPTIONS_TABLE[ori_option];
}

unsigned8_t xf_t::GetTxtOrientation(void) const
{
	return txt_orient;
}

/* Fill Foreground color option wrappers*/
void xf_t::SetFillFGColor(color_name_t color)
{
	// Set the related flag.
	if(color != xf_t::xfiInit.fill_fgcolor)	{
		SetFlag(XF_ALIGN_ATRPAT);
	}

	XL_ASSERT(color >= 0);
	XL_ASSERT(color < _NUM_COLOR_NAMES);
	fill_fgcolor = xf_t::COLOR_OPTIONS_TABLE[color];
}

void xf_t::SetFillFGColor(unsigned8_t color)
{
	SetFlag(XF_ALIGN_ATRPAT);

	fill_fgcolor = color;
}

unsigned16_t xf_t::GetFillFGColorIdx(void) const
{
	return fill_fgcolor;
}

/* Fill Background color option wrappers*/
void xf_t::SetFillBGColor(color_name_t color)
{
	// Set the related flag.
	if(color != xf_t::xfiInit.fill_bgcolor)	{
		SetFlag(XF_ALIGN_ATRPAT);
	}

	XL_ASSERT(color >= 0);
	XL_ASSERT(color < _NUM_COLOR_NAMES);
	fill_bgcolor = xf_t::COLOR_OPTIONS_TABLE[color];
}

void xf_t::SetFillBGColor(unsigned8_t color)
{
	SetFlag(XF_ALIGN_ATRPAT);

	fill_bgcolor = color;
}

unsigned16_t xf_t::GetFillBGColorIdx(void) const
{
	return fill_bgcolor;
}

/* Fill Style option wrappers*/
void xf_t::SetFillStyle(fill_option_t fill)
{
	// Set the related flag.
	if(fill != xf_t::xfiInit.fillstyle)	{
		SetFlag(XF_ALIGN_ATRPAT);
	}

	XL_ASSERT(fill >= 0);
	XL_ASSERT(fill < _NUM_FILL_OPTIONS);
	fillstyle = xf_t::FILL_OPTIONS_TABLE[fill];
}

unsigned8_t xf_t::GetFillStyle(void) const
{
	return fillstyle;
}

/* Locked option wrappers*/
void xf_t::SetLocked(bool locked_opt)
{
	// Set the related flag.
	if(locked_opt != xf_t::xfiInit.locked) {
		SetFlag(XF_ALIGN_ATRPROT);
	}

	locked = locked_opt;
}

bool xf_t::IsLocked(void) const
{
	return locked;
}

/* Hidden option wrappers*/
void xf_t::SetHidden(bool hidden_opt)
{
	// Set the related flag.
	if(hidden_opt != xf_t::xfiInit.hidden) {
		SetFlag(XF_ALIGN_ATRPROT);
	}

	hidden = hidden_opt;
}

bool xf_t::IsHidden(void) const
{
	return hidden;
}

/* Wrap option wrappers*/
void xf_t::SetWrap(bool wrap_opt)
{
	// Set the related flag.
	if(wrap_opt != xf_t::xfiInit.wrap) {
		SetFlag(XF_ALIGN_ATRALC);
	}

	wrap = wrap_opt;
}

bool xf_t::IsWrap(void) const
{
	return wrap;
}

/* Cell option wrappers*/
void xf_t::SetCellMode(bool cellmode)
{
	is_cell = cellmode;
}

bool xf_t::IsCell(void) const
{
	return is_cell;
}

CExtFormat::CExtFormat(CDataStorage &datastore, const xf_t* xfdef) :
	CRecord(datastore)
{
	bool is_cell = xfdef->IsCell();
	//cerr << "CExtFormat:" << endl << xfdef->Description() << endl;

	SetRecordType(RECTYPE_XF);
	InitDummy(is_cell);
	SetRecordLength(GetDataSize()-RECORD_HEADER_SIZE);

	SetFontIndex(xfdef->GetFontIndex());
	SetFormatIndex(xfdef->GetFormatIndex());
	SetHorizAlign(xfdef->GetHAlign());
	SetVertAlign(xfdef->GetVAlign());
	SetIndent(xfdef->GetIndent());
	SetTxtOrientation(xfdef->GetTxtOrientation());

	SetFGColorIndex(xfdef->GetFillFGColorIdx());
	SetBGColorIndex(xfdef->GetFillBGColorIdx());
	SetFillPattern(xfdef->GetFillStyle());

	SetLocked(xfdef->IsLocked());
	SetHidden(xfdef->IsHidden());
	SetWrap(xfdef->IsWrap());

	SetBorder(BORDER_BOTTOM, xfdef->GetBorderStyle(BORDER_BOTTOM),
		xfdef->GetBorderColorIdx(BORDER_BOTTOM));
	SetBorder(BORDER_TOP, xfdef->GetBorderStyle(BORDER_TOP),
		xfdef->GetBorderColorIdx(BORDER_TOP));
	SetBorder(BORDER_LEFT, xfdef->GetBorderStyle(BORDER_LEFT),
		xfdef->GetBorderColorIdx(BORDER_LEFT));
	SetBorder(BORDER_RIGHT, xfdef->GetBorderStyle(BORDER_RIGHT),
		xfdef->GetBorderColorIdx(BORDER_RIGHT));

	SetFlags(xfdef->GetFlags());
	if (is_cell) {
		SetXFParent(xfdef->GetParentIndex());
	}
}

CExtFormat::~CExtFormat()
{
}

/*
 **********************************
 **********************************
 */
void CExtFormat::InitDummy(bool is_cell)
{
	// An style-XF record is initialized as below
	// Each field has to be modified individually before use it

	//The default style is a dummy. The flags that indicate what the style affects (byte 11)
	// are disabled (set to 1).
	static const unsigned8_t xfCellDefault[] = {
		/*    0         2         4         6         8         10        12        14         16       18        20 */
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	};
	static const unsigned8_t xfStyleDefault[] = {
		// Open Office offsets
		/*    0         2         4         6         8         10        12        14         16       18        20 */
		0x00, 0x00, 0x00, 0x00, 0xf4, 0xff, 0x20, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x20
		// STYLE_XF | INDEX=0xFFF -> Style (Excel BIFF spec says this should be FFF4, but we had the 'locked' bit turned on as well here before)
		// HALIGN -> General, VALIGN -> BOTTOM
		// Cells, use this value, Style, not used
		// Fill Pattern -> 1 Black, left shifted 2 bits, (well, fully colored, not a pattern)
		// 0x40 Pattern Color, then lowest bit of 0x41 (next)
		// 0x41 Pattern background color right shifted one bit
	};

	if(is_cell) {
		AddDataArray(xfCellDefault, sizeof(xfCellDefault));
	} else {
		AddDataArray(xfStyleDefault, sizeof(xfStyleDefault));
	}
}

/*
 **********************************
 * CExtFormat class implementation
 **********************************
 */

bool CExtFormat::IsCell()
{
	unsigned16_t val;

	GetValue16From(&val, XF_OFFSET_PROP);

	XL_ASSERT((val & XF_PROP_STYLE) ? (val & XF_PROP_XFPARENT) == (XF_PROP_XFPARENT_VALUE4STYLE << XF_PROP_SHIFTPOS_PARENT) : 1);
	return !(val & XF_PROP_STYLE);
}

void CExtFormat::SetXFParent(unsigned16_t parent)
{
	unsigned16_t val;

	GetValue16From(&val, XF_OFFSET_PROP);
	val &= ~XF_PROP_XFPARENT;
	val |= (parent << XF_PROP_SHIFTPOS_PARENT) & XF_PROP_XFPARENT;
	SetValueAt16(val, XF_OFFSET_PROP);
}

int CExtFormat::SetFontIndex(unsigned16_t fontindex)
{
	// Set the index value
	int errcode = SetValueAt16(fontindex, XF_OFFSET_FONT);

	return errcode;
}

/*
 **********************************
 **********************************
 */
unsigned16_t CExtFormat::GetFontIndex(void)
{
	unsigned16_t fontval;

	GetValue16From(&fontval, XF_OFFSET_FONT);

	return fontval;
}

int CExtFormat::SetFormatIndex(unsigned16_t formatindex)
{
	// Set the index value
	int errcode = SetValueAt16(formatindex, XF_OFFSET_FORMAT);

	return errcode;
}

unsigned16_t CExtFormat::GetFormatIndex(void)
{
	unsigned16_t formatval;

	GetValue16From(&formatval, XF_OFFSET_FORMAT);

	return formatval;
}

void CExtFormat::SetLocked(bool locked)
{
	unsigned16_t value;

	GetValue16From(&value, XF_OFFSET_PROP);
	if (locked) {
		value |= XF_PROP_LOCKED;
	} else {
		value &= ~XF_PROP_LOCKED;
	}
	SetValueAt16(value, XF_OFFSET_PROP);
}

void CExtFormat::SetHidden(bool hidden)
{
	unsigned16_t value;

	GetValue16From(&value, XF_OFFSET_PROP);
	if (hidden) {
		value |= XF_PROP_HIDDEN;
	} else {
		value &= ~XF_PROP_HIDDEN;
	}
	SetValueAt16(value, XF_OFFSET_PROP);
}

void CExtFormat::SetHorizAlign(unsigned8_t alignval)
{
	unsigned32_t value;

	GetValue32From(&value, XF_OFFSET_ALIGN);
	XL_ASSERT(XF_ALIGN_SHIFTPOS_HALIGN == 0);
	value = (value & (~(unsigned32_t)XF_ALIGN_HORIZONTAL)) | (alignval & XF_ALIGN_HORIZONTAL);
	SetValueAt32(value, XF_OFFSET_ALIGN);
}

void CExtFormat::SetVertAlign(unsigned8_t alignval)
{
	unsigned32_t value, alignval32;

	GetValue32From(&value, XF_OFFSET_ALIGN);
	alignval32 = alignval;
	alignval32 <<= XF_ALIGN_SHIFTPOS_VALIGN;            // Place the option at the right bit position
	value = (value & (~(unsigned32_t)XF_ALIGN_VERTICAL)) | (alignval32 & XF_ALIGN_VERTICAL);
	SetValueAt32(value, XF_OFFSET_ALIGN);
}

void CExtFormat::SetWrap(bool wrap)
{
	unsigned32_t value;

	GetValue32From(&value, XF_OFFSET_ALIGN);
	if (wrap) {
		value |= XF_ALIGN_WRAP;
	} else {
		value &= ~(unsigned32_t)XF_ALIGN_WRAP;
	}
	SetValueAt32(value, XF_OFFSET_ALIGN);
}

void CExtFormat::SetIndent(unsigned8_t indentval)
{
	unsigned32_t value, mask;

	if(indentval & XF_INDENT_LVL) {
		mask = XF_INDENT_LVL;
	} else
	if(indentval & XF_INDENT_SHRINK2FIT) {
		mask = XF_INDENT_SHRINK2FIT;
	} else
	if(indentval & (XF_INDENT_CONTEXT|XF_INDENT_L2R|XF_INDENT_R2L)) {
		mask = XF_INDENT_DIR;
	} else {
		mask = XF_INDENT_LVL | XF_INDENT_SHRINK2FIT | XF_INDENT_DIR;
	}

	mask <<= XF_INDENT_SHIFTPOS;

	GetValue32From(&value, XF_OFFSET_ALIGN);

	unsigned32_t indentval32 = indentval;
	indentval32 <<= XF_INDENT_SHIFTPOS; // Place the option at the right bit position
	value = (value & (~mask)) | (indentval32 & mask);

	SetValueAt32(value, XF_OFFSET_ALIGN);
}

void CExtFormat::SetTxtOrientation(unsigned8_t alignval)
{
	unsigned32_t value;

	GetValue32From(&value, XF_OFFSET_ALIGN);

	unsigned32_t alignval32 = alignval;
	alignval32 <<= XF_ORI_SHIFTPOS; // Place the option at the right bit position
	value = (value & (~(unsigned32_t)XF_ORI_MASK)) | (alignval32 & XF_ORI_MASK);

	SetValueAt32(value, XF_OFFSET_ALIGN);
}

void CExtFormat::SetFGColorIndex(unsigned16_t color)
{
	unsigned16_t value;

	GetValue16From(&value, XF_OFFSET_COLOR);

	// Clear the field for Foreground color
	value &= (~XF_COLOR_FOREGROUND);
	// Set the new color
	value |= (color & XF_COLOR_FOREGROUND);

	SetValueAt16(value, XF_OFFSET_COLOR);
}

void CExtFormat::SetBGColorIndex(unsigned16_t color)
{
	unsigned16_t value;

	color <<= XF_COLOR_SHIFTPOS_BG;

	GetValue16From(&value, XF_OFFSET_COLOR);

	// Clear the field for Foreground color
	value &= (~XF_COLOR_BACKGROUND);
	// Set the new color
	value |= (color & XF_COLOR_BACKGROUND);

	SetValueAt16(value, XF_OFFSET_COLOR);
}

void CExtFormat::SetFillPattern(unsigned8_t pattern)
{
	unsigned32_t value, pattern32 = pattern;

	GetValue32From(&value, XF_OFFSET_BORDERB);
	value &= ~XF_BORDER_FILLPATTERN;
	pattern32 <<= XF_SHIFTPOS_FILLPATTERN;
	value |= (pattern32 & XF_BORDER_FILLPATTERN);
	SetValueAt32(value, XF_OFFSET_BORDERB);
}

void CExtFormat::SetBorder(border_side_t border, unsigned16_t style, unsigned16_t color)
{
	unsigned32_t value, color32 = color, style32 = style;

	switch(border) {
	case BORDER_BOTTOM:
		GetValue32From(&value, XF_OFFSET_BORDERA);
		value &= (~(unsigned32_t)XF_BORDER_BOTTOMSTYLE);
		style32 <<= XF_STYLE_SHIFTPOS_BOTTOM;
		value |= (style32 & XF_BORDER_BOTTOMSTYLE);
		SetValueAt32(value, XF_OFFSET_BORDERA);

		GetValue32From(&value, XF_OFFSET_BORDERB);
		value &= (~(unsigned32_t)XF_BORDER_BOTTOMCOLOR);
		color32 <<= XF_COLOR_SHIFTPOS_BOTTOM;
		value |= (color32 & XF_BORDER_BOTTOMCOLOR);
		SetValueAt32(value, XF_OFFSET_BORDERB);
		break;

	case BORDER_TOP:
		GetValue32From(&value, XF_OFFSET_BORDERA);
		value &= (~(unsigned32_t)XF_BORDER_TOPSTYLE);
		style32 <<= XF_STYLE_SHIFTPOS_TOP;
		value |= (style32 & XF_BORDER_TOPSTYLE);
		SetValueAt32(value, XF_OFFSET_BORDERA);

		GetValue32From(&value, XF_OFFSET_BORDERB);
		value &= (~(unsigned32_t)XF_BORDER_TOPCOLOR);
		color32 <<= XF_COLOR_SHIFTPOS_TOP;
		value |= (color32 & XF_BORDER_TOPCOLOR);
		SetValueAt32(value, XF_OFFSET_BORDERB);
		break;

	case BORDER_LEFT:
		GetValue32From(&value, XF_OFFSET_BORDERA);
		value &= ~(unsigned32_t)(XF_BORDER_LEFTSTYLE|XF_BORDER_LEFTCOLOR);

		color32 <<= XF_COLOR_SHIFTPOS_LEFT;
		style32 <<= XF_STYLE_SHIFTPOS_LEFT;
		value |= (color32 & XF_BORDER_LEFTCOLOR) | (style32 & XF_BORDER_LEFTSTYLE);

		SetValueAt32(value, XF_OFFSET_BORDERA);
		break;

	case BORDER_RIGHT:
		GetValue32From(&value, XF_OFFSET_BORDERA);

		value &= ~(unsigned32_t)(XF_BORDER_RIGHTSTYLE|XF_BORDER_RIGHTCOLOR);
		color32 <<= XF_COLOR_SHIFTPOS_RIGHT;
		style32 <<= XF_STYLE_SHIFTPOS_RIGHT;
		value |= (color32 & XF_BORDER_RIGHTCOLOR) | (style32 & XF_BORDER_RIGHTSTYLE);

		SetValueAt32(value, XF_OFFSET_BORDERA);
		break;

	default:
		break;
	}
}

void CExtFormat::SetFlags(unsigned8_t flags)
{
	unsigned32_t value;
	unsigned32_t flags32 = flags;

	flags32 <<= XF_ALIGN_ATR_SHIFT;
	GetValue32From(&value, XF_OFFSET_ALIGN);
	value = (value & (~XF_ALIGN_ATR_MASK)) | (flags32 & XF_ALIGN_ATR_MASK);

	SetValueAt32(value, XF_OFFSET_ALIGN);
}