/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * 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.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * File description:
 *
 *
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#define CPP_BRIDGE_XLS

// since xlslib.h does not include these for C files
#include "../common/xlsys.h"

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <string>

#include "../common/systype.h"
#include "../xlslib/common.h" 
#include "../xlslib/record.h"

#include "xlslib.h"

using namespace xlslib_core;
using namespace xlslib_strings;

extern "C" {
	// Workbook
	workbook *xlsNewWorkbook(void)								{ return new workbook; }
	void xlsDeleteWorkbook(workbook *w)							{ delete w; }
	
	worksheet *xlsWorkbookSheet(workbook *w, const char *sheetname) {
																	std::string str = sheetname;
																	return w->sheet(str);
																}
	worksheet *xlsWorkbookSheetW(workbook *w, const unichar_t *sheetname)
																{
																	ustring str = sheetname;
																	return w->sheet(str);
																}
	worksheet *xlsWorkbookGetSheet(workbook *w, unsigned16_t sheetnum)
																{ return w->GetSheet(sheetnum); }

	font_t *xlsWorkbookFont(workbook *w, const char *name)		{
																	std::string str = name;
																	return w->font(str);
																}
	format_t *xlsWorkbookFormat(workbook *w, const char *name)	{
																	std::string str = name;
																	return w->format(str);
																}
	format_t *xlsWorkbookFormatW(workbook *w, const unichar_t *name) {
																	ustring str = name;
																	return w->format(str);
																}
	xf_t *xlsWorkbookxFormat(workbook *w)						{ return w->xformat(); }
	xf_t *xlsWorkbookxFormatFont(workbook *w, font_t *font)		{ return w->xformat(font); }


#if defined(HAVE_WORKING_ICONV)
	int xlsWorkbookIconvInType(workbook *w, const char *inType)	{ return w->iconvInType(inType); }
#endif
	unsigned8_t xlsWorkbookProperty(workbook *w, property_t prop, const char *s)
																{ 
																	std::string str = s;
																	return w->property(prop, str) ? 1 : 0;
																}
	void xlsWorkBookWindPosition(workbook *w, unsigned16_t horz, unsigned16_t vert)
																{ w->windPosition(horz, vert); }
	void xlsWorkBookWindSize(workbook *w, unsigned16_t horz, unsigned16_t vert)
																{ w->windSize(horz, vert); }
	void xlsWorkBookFirstTab(workbook *w, unsigned16_t firstTab)
																{ w->firstTab(firstTab); }
	void xlsWorkBookTabBarWidth(workbook *w, unsigned16_t width)
																{ w->tabBarWidth(width); }
	int xlsWorkbookDump(workbook *w, const char *filename)			{
																	std::string str = filename;
																	return w->Dump(str);
																}
	// Worksheet
	void xlsWorksheetMakeActive(worksheet *w)					{ return w->MakeActive(); }
	cell_t *xlsWorksheetFindCell(worksheet *w, unsigned32_t row, unsigned32_t col)
																{ return w->FindCell(row, col); }
	void xlsWorksheetSplitWindow(worksheet *w, unsigned16_t row, unsigned16_t col)
																{ return w->SplitWindow(row, col); }
	// Cell operations
	void xlsWorksheetMerge(worksheet *w, unsigned32_t first_row, unsigned32_t first_col, unsigned32_t last_row, unsigned32_t last_col)		
																{ return w->merge(first_row, first_col, last_row, last_col); }
	void xlsWorksheetColwidth(worksheet *w, unsigned32_t col, unsigned16_t width, xf_t* pxformat)
																{ return w->colwidth(col, width, pxformat); }
	void xlsWorksheetRowheight(worksheet *w, unsigned32_t row, unsigned16_t height, xf_t* pxformat)
																{ return w->rowheight(row, height, pxformat); } 
	// Ranges
	range *xlsWorksheetRangegroup(worksheet *w, unsigned32_t row1, unsigned32_t col1, unsigned32_t row2, unsigned32_t col2)
																{ return w->rangegroup(row1, col1, row2, col2); }

	// Cells
	cell_t *xlsWorksheetLabel(worksheet *w, unsigned32_t row, unsigned32_t col, const char *strlabel, xf_t *pxformat)
																{ 
																	std::string str = strlabel;
																	return w->label(row, col, strlabel, pxformat);
																}
	cell_t *xlsWorksheetLabelW(worksheet *w, unsigned32_t row, unsigned32_t col, const unichar_t *strlabel, xf_t *pxformat)
																{ 
																	ustring str = strlabel;
																	return w->label(row, col, strlabel, pxformat);
																}
	cell_t *xlsWorksheetBlank(worksheet *w, unsigned32_t row, unsigned32_t col, xf_t *pxformat)
																{ return w->blank(row, col, pxformat); }

	cell_t *xlsWorksheetNumberDbl(worksheet *w, unsigned32_t row, unsigned32_t col, double numval, xf_t *pxformat)
																{ return w->number(row, col, numval, pxformat); }
	// 536870911 >= numval >= -536870912
	cell_t *xlsWorksheetNumberInt(worksheet *w, unsigned32_t row, unsigned32_t col, signed32_t numval, xf_t *pxformat)
																{ return w->number(row, col, numval, pxformat); }

	cell_t *xlsWorksheetBoolean(worksheet *w, unsigned32_t row, unsigned32_t col, int boolval, xf_t *pxformat)
																{ return w->boolean(row, col, !!boolval, pxformat); }

	cell_t *xlsWorksheetError(worksheet *w, unsigned32_t row, unsigned32_t col, errcode_t errval, xf_t *pxformat)
																{ return w->error(row, col, errval, pxformat); }

	note_t *xlsWorksheetNote(worksheet *w, unsigned32_t row, unsigned32_t col, const char *author, const char *remark, xf_t *pxformat)
																{ 
																	std::string auth = author;
																	std::string cmt = remark;

																	return w->note(row, col, auth, cmt, pxformat);
																}
	note_t *xlsWorksheetNoteW(worksheet *w, unsigned32_t row, unsigned32_t col, const unichar_t *author, const unichar_t *remark, xf_t *pxformat)
																{ 
																	ustring auth = author;
																	ustring cmt = remark;

																	return w->note(row, col, auth, cmt, pxformat); 
																}
	void xlsNoteSetFillColor(note_t *note, unsigned8_t red, unsigned8_t green, unsigned8_t blue)
																{
																	note->SetFillColor(red, green, blue);
																}
    formula_t *xlsWorksheetFormula(worksheet *w) { return w->formula_data(); }
    void xlsFormulaPushBoolean(formula_t *formula, bool value) { formula->PushBoolean(value); }
    void xlsFormulaPushMissingArgument(formula_t *formula) { formula->PushMissingArgument(); }
    void xlsFormulaPushError(formula_t *formula, unsigned8_t value) { formula->PushError(value); }
    void xlsFormulaPushNumberInt(formula_t *formula, signed32_t value) { formula->PushInteger(value); }
    void xlsFormulaPushNumberDbl(formula_t *formula, double value) { formula->PushFloatingPoint(value); }
    void xlsFormulaPushNumberArray(formula_t *formula, double *values, size_t count) 
                                                                {
                                                                    std::vector<double> vec;
                                                                    for (size_t i=0; i<count; i++)
                                                                        vec.push_back(values[i]);
                                                                    formula->PushFloatingPointArray(vec);
                                                                }
    void xlsFormulaPushOperator(formula_t *formula, expr_operator_code_t op) { formula->PushOperator(op); }
	
    void xlsFormulaPushCellReference(formula_t *formula, cell_t *cell, cell_addr_mode_t opt) { formula->PushCellReference(*cell, opt, CELLOP_AS_VALUE); }
    void xlsFormulaPushCellAreaReference(formula_t *formula, cell_t *upper_left_cell, 
            cell_t *lower_right_cell, cell_addr_mode_t opt) { formula->PushCellAreaReference(*upper_left_cell, *lower_right_cell, opt, CELLOP_AS_VALUE); }

    void xlsFormulaPushCellReferenceC(formula_t *formula, cell_t *cell, cell_addr_mode_t opt, cell_op_class_t op_class) { formula->PushCellReference(*cell, opt, op_class); }
    void xlsFormulaPushCellAreaReferenceC(formula_t *formula, cell_t *upper_left_cell,
            cell_t *lower_right_cell, cell_addr_mode_t opt, cell_op_class_t op_class) { formula->PushCellAreaReference(*upper_left_cell, *lower_right_cell, opt, op_class); }

    void xlsFormulaPushFunction(formula_t *formula, expr_function_code_t func) { formula->PushFunction(func, CELL_DEFAULT); }
    void xlsFormulaPushFunctionV(formula_t *formula, expr_function_code_t func, size_t arg_count) { formula->PushFunction(func, arg_count, CELL_DEFAULT); }
    void xlsFormulaPushFunctionC(formula_t *formula, expr_function_code_t func, cell_op_class_t op_class) { formula->PushFunction(func, op_class); }
    void xlsFormulaPushFunctionVC(formula_t *formula, expr_function_code_t func, size_t arg_count, cell_op_class_t op_class) { formula->PushFunction(func, arg_count, op_class); }
    void xlsFormulaPushCharacterArray(formula_t *formula, const char *text, size_t count)
                                                                { 
                                                                    std::string str = "";
                                                                    for (size_t i=0; i<count; i++) {
                                                                        str += text[i];
                                                                    }
                                                                    formula->PushText(str); 
                                                                }
    void xlsFormulaPushCharacterArrayW(formula_t *formula, const unichar_t *text, size_t count) 
                                                                { 
                                                                    ustring str = L"";
                                                                    for (size_t i=0; i<count; i++) {
                                                                        str += text[i];
                                                                    }
                                                                    formula->PushText(str); 
                                                                }
    void xlsFormulaPushText(formula_t *formula, const char *text) 
                                                                { 
                                                                    std::string str = text;
                                                                    formula->PushText(str); 
                                                                }
    void xlsFormulaPushTextW(formula_t *formula, const unichar_t *text) 
                                                                { 
                                                                    ustring str = text;
                                                                    formula->PushText(str); 
                                                                }
    void xlsFormulaPushTextArray(formula_t *formula, const char **text, size_t count) 
                                                                { 
                                                                    std::vector<std::string> vec;
                                                                    for (size_t i=0; i<count; i++) {
                                                                        std::string str = text[i];
                                                                        vec.push_back(str);
                                                                    }
                                                                    formula->PushTextArray(vec); 
                                                                }
    void xlsFormulaPushTextArrayW(formula_t *formula, const unichar_t **text, size_t count) 
                                                                { 
                                                                    std::vector<ustring> vec;
                                                                    for (size_t i=0; i<count; i++) {
                                                                        ustring str = text[i];
                                                                        vec.push_back(str);
                                                                    }
                                                                    formula->PushTextArray(vec); 
                                                                }

	cell_t *xlsWorksheetFormulaCell(worksheet *w, unsigned32_t row, unsigned32_t col, formula_t *formula, xf_t *pxformat)
																{
																	return w->formula(row, col, formula, false, pxformat);
																}
	cell_t *xlsWorksheetFormulaCellArray(worksheet *w, unsigned32_t row, unsigned32_t col, formula_t *formula, xf_t *pxformat)
																{
																	return w->formula(row, col, formula, true, pxformat);
																}
    void xlsWorksheetValidateCell(worksheet *w, cell_t *cell, unsigned32_t options,
            const formula_t *cond1, const formula_t *cond2,
            const char *prompt_title, const char *prompt_text,
            const char *error_title, const char *error_text)   
                                                               {
                                                                   range_t *rg = new range_t;
                                                                   rg->first_row = cell->GetRow();
                                                                   rg->last_row = cell->GetRow();
                                                                   rg->first_col = cell->GetCol();
                                                                   rg->last_col = cell->GetCol();
                                                                   std::string sPromptTitle = prompt_title ? prompt_title : "";
                                                                   std::string sPromptText = prompt_text ? prompt_text : "";
                                                                   std::string sErrorTitle = error_title ? error_title : "";
                                                                   std::string sErrorText = error_text ? error_text : "";
                                                                   w->validate(rg, options, cond1, cond2,
                                                                           sPromptTitle, sPromptText, sErrorTitle, sErrorText);
                                                                   delete rg;
                                                               }
    void xlsWorksheetValidateCellW(worksheet *w, cell_t *cell, unsigned32_t options, 
            const formula_t *cond1, const formula_t *cond2,
            const unichar_t *prompt_title, const unichar_t *prompt_text,
            const unichar_t *error_title, const unichar_t *error_text)   
                                                               {
                                                                   range_t *rg = new range_t;
                                                                   rg->first_row = cell->GetRow();
                                                                   rg->last_row = cell->GetRow();
                                                                   rg->first_col = cell->GetCol();
                                                                   rg->last_col = cell->GetCol();
                                                                   ustring sPromptTitle = prompt_title ? prompt_title : L"";
                                                                   ustring sPromptText = prompt_text ? prompt_text : L"";
                                                                   ustring sErrorTitle = error_title ? error_title : L"";
                                                                   ustring sErrorText = error_text ? error_text : L"";
                                                                   w->validate(rg, options, cond1, cond2,
                                                                           sPromptTitle, sPromptText, sErrorTitle, sErrorText);
                                                                   delete rg;
                                                               }
    void xlsWorksheetValidateCellArea(worksheet *w, cell_t *upper_left_cell, 
            cell_t *lower_right_cell, unsigned32_t options, 
            const formula_t *cond1, const formula_t *cond2,
            const char *prompt_title, const char *prompt_text,
            const char *error_title, const char *error_text)   
                                                               {
                                                                   range_t *rg = new range_t;
                                                                   rg->first_row = upper_left_cell->GetRow();
                                                                   rg->last_row = lower_right_cell->GetRow();
                                                                   rg->first_col = upper_left_cell->GetCol();
                                                                   rg->last_col = lower_right_cell->GetCol();
                                                                   std::string sPromptTitle = prompt_title ? prompt_title : "";
                                                                   std::string sPromptText = prompt_text ? prompt_text : "";
                                                                   std::string sErrorTitle = error_title ? error_title : "";
                                                                   std::string sErrorText = error_text ? error_text : "";
                                                                   w->validate(rg, options, cond1, cond2,
                                                                           sPromptTitle, sPromptText, sErrorTitle, sErrorText);
                                                                   delete rg;
                                                               }
    void xlsWorksheetValidateCellAreaW(worksheet *w, cell_t *upper_left_cell, 
            cell_t *lower_right_cell, unsigned32_t options, 
            const formula_t *cond1, const formula_t *cond2,
            const unichar_t *prompt_title, const unichar_t *prompt_text,
            const unichar_t *error_title, const unichar_t *error_text)   
                                                               {
                                                                   range_t *rg = new range_t;
                                                                   rg->first_row = upper_left_cell->GetRow();
                                                                   rg->last_row = lower_right_cell->GetRow();
                                                                   rg->first_col = upper_left_cell->GetCol();
                                                                   rg->last_col = lower_right_cell->GetCol();
                                                                   ustring sPromptTitle = prompt_title ? prompt_title : L"";
                                                                   ustring sPromptText = prompt_text ? prompt_text : L"";
                                                                   ustring sErrorTitle = error_title ? error_title : L"";
                                                                   ustring sErrorText = error_text ? error_text : L"";
                                                                   w->validate(rg, options, cond1, cond2,
                                                                           sPromptTitle, sPromptText, sErrorTitle, sErrorText);
                                                                   delete rg;
                                                               }
	void xlsWorksheetHyperLink(worksheet *w, cell_t *cell, const char *url, const char *mark)
																{ 
																	std::string sUrl = url;
																	std::string sMark = mark ? mark : "";

																	w->hyperLink(cell, sUrl, sMark); 
																}
	void xlsWorksheetHyperLinkW(worksheet *w, cell_t *cell, const unichar_t *url, const unichar_t *mark)
																{ 
																	ustring sUrl = url;
																	ustring sMark = mark ? mark : L"";

																	w->hyperLink(cell, sUrl, sMark); 
																}
	
	// Cells
	// xf_i interface
	void xlsCellFont(cell_t *c, font_t *fontidx)				{ return c->font(fontidx); }
	void xlsCellFormat(cell_t *c, format_number_t format)		{ return c->format(format); }
	void xlsCellFormatP(cell_t *c, format_t *format)			{ return c->format(format); }
	void xlsCellHalign(cell_t *c, halign_option_t ha_option)	{ return c->halign(ha_option); }
	void xlsCellValign(cell_t *c, valign_option_t va_option)	{ return c->valign(va_option); }	
	void xlsCellIndent(cell_t *c, indent_option_t in_option)	{ return c->indent(in_option); }	
	void xlsCellOrientation(cell_t *c, txtori_option_t ori_option)
																{ return c->orientation(ori_option); }
	void xlsCellFillfgcolor(cell_t *c, color_name_t color)		{ return c->fillfgcolor(color); }
	void xlsCellFillbgcolor(cell_t *c, color_name_t color)		{ return c->fillbgcolor(color); }
	void xlsCellFillstyle(cell_t *c, fill_option_t fill)		{ return c->fillstyle(fill); }
	void xlsCellLocked(cell_t *c, bool locked_opt)				{ return c->locked(locked_opt); }
	void xlsCellHidden(cell_t *c, bool hidden_opt)				{ return c->hidden(hidden_opt); }
	void xlsCellWrap(cell_t *c, bool wrap_opt)					{ return c->wrap(wrap_opt); }
	void xlsCellBorderstyle(cell_t *c, border_side_t side, border_style_t style)
																{ return c->borderstyle(side, style); }
	void xlsCellBordercolor(cell_t *c, border_side_t side, color_name_t color)
																{ return c->bordercolor(side, color); }
	void xlsCellBordercolorIdx(cell_t *c, border_side_t side, unsigned8_t color)
																{ return c->bordercolor(side, color); }
	//font_i interface
	void xlsCellFontname(cell_t *c, const char *fntname)		{
																	std::string str = fntname;
																	c->fontname(str);
																}
	void xlsCellFontheight(cell_t *c, unsigned16_t fntheight)	{ return c->fontheight(fntheight); }
	void xlsCellFontbold(cell_t *c, boldness_option_t fntboldness)
																{ return c->fontbold(fntboldness); }
	void xlsCellFontunderline(cell_t *c, underline_option_t fntunderline)
																{ return c->fontunderline(fntunderline); }
	void xlsCellFontscript(cell_t *c, script_option_t fntscript){ return c->fontscript(fntscript); }
	void xlsCellFontcolor(cell_t *c, color_name_t fntcolor)		{ return c->fontcolor(fntcolor); }
	void xlsCellFontitalic(cell_t *c, bool italic)				{ return c->fontitalic(italic); }
	void xlsCellFontstrikeout(cell_t *c, bool so)				{ return c->fontstrikeout(so); }
	void xlsCellFontoutline(cell_t *c, bool ol)					{ return c->fontoutline(ol); }
	void xlsCellFontshadow(cell_t *c, bool sh)					{ return c->fontshadow(sh); }

	unsigned32_t xlsCellGetRow(cell_t *c)						{ return c->GetRow(); }
	unsigned32_t xlsCellGetCol(cell_t *c)						{ return c->GetCol(); }
	// range
	void xlsRangeCellcolor(range *r, color_name_t color)		{ return r->cellcolor(color); }	
	// xformat
	void xlsXformatSetFont(xf_t *x, font_t* fontidx)			{ return x->SetFont(fontidx); }
	unsigned16_t xlsXformatGetFontIndex(xf_t *x)				{ return x->GetFontIndex(); }
	font_t* xlsXformatGetFont(xf_t *x)							{ return x->GetFont(); }
	/* Format Index wrappers*/
	void xlsXformatSetFormat(xf_t *x, format_number_t formatidx){ return x->SetFormat(formatidx); }
	void xlsXformatSetFormatP(xf_t *x, format_t *fmt)			{ return x->SetFormat(fmt); }
	/* Horizontal Align option wrappers*/
	void xlsXformatSetHAlign(xf_t *x, halign_option_t ha_option){ return x->SetHAlign(ha_option); }
	unsigned8_t xlsXformatGetHAlign(xf_t *x)					{ return x->GetHAlign(); }
	/* Vertical Align option wrappers*/
	void xlsXformatSetVAlign(xf_t *x, valign_option_t va_option){ return x->SetVAlign(va_option); }
	unsigned8_t xlsXformatGetVAlign(xf_t *x)					{ return x->GetVAlign(); }
	/* Indent option wrappers*/
	void xlsXformatSetIndent(xf_t *x, indent_option_t in_option){ return x->SetIndent(in_option); }
	unsigned8_t xlsXformatGetIndent(xf_t *x)					{ return x->GetIndent(); }
	/* Text orientation option wrappers*/
	void xlsXformatSetTxtOrientation(xf_t *x, txtori_option_t ori_option)
																{ return x->SetTxtOrientation(ori_option); }
	unsigned8_t xlsXformatGetTxtOrientation(xf_t *x)			{ return x->GetTxtOrientation(); }
	/* Fill Foreground color option wrappers*/
	void xlsXformatSetFillFGColor(xf_t *x, color_name_t color)	{ return x->SetFillFGColor(color); }
	unsigned16_t xlsXformatGetFillFGColorIdx(xf_t *x)			{ return x->GetFillFGColorIdx(); }
	/* Fill Background color option wrappers*/
	void xlsXformatSetFillBGColor(xf_t *x, color_name_t color)	{ return x->SetFillBGColor(color); }
	unsigned16_t xlsXformatGetFillBGColorIdx(xf_t *x)			{ return x->GetFillBGColorIdx(); }
	/* Fill Style option wrappers*/
	void xlsXformatSetFillStyle(xf_t *x, fill_option_t fill)	{ return x->SetFillStyle(fill); }
	unsigned8_t xlsXformatGetFillStyle(xf_t *x)					{ return x->GetFillStyle(); }
	/* Locked option wrappers*/
	void xlsXformatSetLocked(xf_t *x, bool locked_opt)			{ return x->SetLocked(locked_opt); }
	bool xlsXformatIsLocked(xf_t *x)							{ return x->IsLocked(); }
	/* Hidden option wrappers*/
	void xlsXformatSetHidden(xf_t *x, bool hidden_opt)			{ return x->SetHidden(hidden_opt); }
	bool xlsXformatIsHidden(xf_t *x)							{ return x->IsHidden(); }
	/* Wrap option wrappers*/
	void xlsXformatSetWrap(xf_t *x, bool wrap_opt)				{ return x->SetWrap(wrap_opt); }
	bool xlsXformatIsWrap(xf_t *x)								{ return x->IsWrap(); }
	/* Cell option wrappers*/
	void xlsXformatSetBorderStyle(xf_t *x, border_side_t side, border_style_t style)
																{ return x->SetBorderStyle(side, style); }
	void xlsXformatSetBorderColor(xf_t *x, border_side_t side, color_name_t color)
																{ return x->SetBorderColor(side, color); }
	void xlsXformatSetBorderColorIdx(xf_t *x, border_side_t side, unsigned8_t color)
																{ return x->SetBorderColor(side, color); }
	unsigned8_t xlsXformatGetBorderStyle(xf_t *x, border_side_t side)
																{ return x->GetBorderStyle(side); }
	unsigned16_t xlsXformatGetBorderColorIdx(xf_t *x, border_side_t side)
																{ return x->GetBorderColorIdx(side); }

	// Font
	void xlsFontSetName(font_t *f, const char *fntname)			{
																	std::string str = fntname;
																	f->SetName(str);
																}
	char *xlsFontGetName(font_t *f, char *dst, size_t dstsize)	{
																	const char *ptr = f->GetName().c_str();
																	size_t len = strlen(ptr) + 1;
																	if (len > dstsize)
																		len = dstsize;
																	memcpy(dst, ptr, len);
																	dst[dstsize - 1] = 0;
																	return dst;
																}										
	/* FONT height wrappers*/
	void xlsFontSetHeight(font_t *f, unsigned16_t fntheight)	{ return f->SetHeight(fntheight); }
	unsigned16_t xlsFontGetHeight(font_t *f)					{ return f->GetHeight(); }
	/* FONT boldstyle wrappers*/
	void xlsFontSetBoldStyle(font_t *f, boldness_option_t fntboldness)
																{ return f->SetBoldStyle(fntboldness); }
	unsigned16_t xlsFontGetBoldStyle(font_t *f)					{ return f->GetBoldStyle(); }
	/* FONT underline wrappers*/
	void xlsFontSetUnderlineStyle(font_t *f, underline_option_t fntunderline)
																{ return f->SetUnderlineStyle(fntunderline); }
	unsigned8_t xlsFontGetUnderlineStyle(font_t *f)				{ return f->GetUnderlineStyle(); }
	/* FONT script wrappers*/
	void xlsFontSetScriptStyle(font_t *f, script_option_t fntscript)
																{ return f->SetScriptStyle(fntscript); }
	unsigned16_t xlsFontGetScriptStyle(font_t *f)				{ return f->GetScriptStyle(); }
	/* FONT script wrappers*/
	void xlsFontSetColor(font_t *f, color_name_t fntcolor)		{ return f->SetColor(fntcolor); }
	unsigned16_t xlsFontGetColorIdx(font_t *f)					{ return f->GetColorIdx(); }
	void xlsFontSetItalic(font_t *f, bool italic)				{ return f->SetItalic(italic); }
	void xlsFontSetStrikeout(font_t *f, bool so)				{ return f->SetStrikeout(so); }
	/* FONT  attributes wrappers */
	// Macintosh only
	void xlsFontSetOutline(font_t *f, bool ol)					{ return f->SetOutline(ol); }
	void xlsFontSetShadow(font_t *f, bool sh)					{ return f->SetShadow(sh); }

// these are accessing private members. Is this intended?
	unsigned16_t xlsFontGetAttributes(font_t *f)				{ return f->GetAttributes(); }
#if defined(DEPRECATED)
	void xlsFontSetAttributes(font_t *f, unsigned16_t attr)		{ f->SetAttributes(attr); }
#endif
	//unsigned32_t xlsXformatGetSignature(xf_t *x)				{ return x->GetSignature(); }
	bool xlsXformatIsCell(xf_t *x)								{ return x->IsCell(); }
	void xlsXformatSetCellMode(xf_t *x, bool cellmode)			{ x->SetCellMode(cellmode); }
	unsigned16_t xlsXformatGetFormatIndex(xf_t *x)				{ return x->GetFormatIndex(); }
	format_number_t xlsXformatGetFormat(xf_t *x)				{ return x->GetFormat(); }
	void xlsCellSetXF(cell_t *c, xf_t *pxfval)					{ c->SetXF(pxfval); }
	unsigned16_t xlsCellGetXFIndex(cell_t *c)					{ return c->GetXFIndex(); }
	//void xlsCellFontattr(cell_t *c, unsigned16_t attr)		{ c->Fontattr(attr); }
}