c/libxlsxwriter
1
0
Fork 0
mirror of https://github.com/jmcnamara/libxlsxwriter synced 2025-03-28 21:13:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial work on set_column().

Browse Source
This commit is contained in:
John McNamara 2014-06-15 21:24:21 +01:00
parent 5026e8dc31
commit e262b8e9b2
19 changed files with 565 additions and 2771 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.indent.pro vendored
View File

@ -45,6 +45,7 @@
-T lxw_app
-T lxw_border
-T lxw_cell
-T lxw_col_options
-T lxw_col_t
-T lxw_color_t
-T lxw_content_types
@ -62,6 +63,7 @@
-T lxw_rel_tuple
-T lxw_relationships
-T lxw_row
-T lxw_row_col_options
-T lxw_row_t
-T lxw_sst
-T lxw_styles

8
Makefile
View File

@ -19,7 +19,7 @@ all :
$(Q)make -C src
# Build the example programs.
examples:
examples :
$(Q)make -C examples
# Clean src and test directories.
@ -55,9 +55,13 @@ test_valgrind : all
$(Q)make -C test/functional/src test_valgrind
$(Q)make -C examples test_valgrind
# Minimal target for quick compile without creating the libs.
test_compile :
$(Q)make -C src test_compile
# Indent the source files with the .indent.pro settings.
indent:
$(Q)gindent src/*.c include/*.h
$(Q)gindent src/*.c include/*.h include/xlsxwriter/*.h
tags:
$(Q)rm -f TAGS

495
docs/src/cworkbook.dox
View File

@ -1,495 +0,0 @@
/**
* .. _workbook:
*
* The Workbook Class
* ==================
*
* The Workbook class is the main class exposed by the xlsxwriter module and it is
* the only class that you will need to instantiate directly.
*
* The Workbook class represents the entire spreadsheet as you see it in Excel and
* internally it represents the Excel file as it is written on disk.
*
* Constructor
*/
*
/**
* @brief Create a new xlsxwriter Workbook object.
*
*
* @param self Pointer to lxw_format.
* @param filename The name of the new Excel file to create.
* @param options Optional workbook parameters. See below.
* :rtype: A Workbook object.
*
*
* The ``Workbook:new()`` constructor is used to create a new Excel workbook with a
* given filename:
*
* @code
* import xlsxwriter
*
* workbook = xlsxwriter.Workbook('filename.xlsx');
* worksheet = workbook:add_worksheet();
*
* worksheet:write(0, 0, 'Hello Excel');
*
* @endcode
*
* @image html workbook01.png
*
* The constructor options are:
*
* * **constant_memory**: Reduces the amount of data stored in memory so that
* large files can be written efficiently:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {constant_memory = True});
*
* Note, in this mode a row of data is written and then discarded when a cell
* in a new row is added via one of the worksheet ``write_()`` methods.
* Therefore, once this mode is active, data should be written in sequential
* row order.
*
* See :ref:`memory_perf` for more details.
*
* @endcode
*
* * **tmpdir**: ``xlsxwriter`` stores worksheet data in a temporary files prior
* to assembling the final XLSX file. The temporary files are created in the
* system's temp directory. If the default temporary directory isn't accessible
* to your application, or doesn't contain enough space, you can specify an
* alternative location using the ``tempdir`` option:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {tmpdir = '/home/user/tmp'});
*
* The temporary directory must exist and will not be created.
*
* @endcode
*
* * **in_memory**: To avoid the use of temporary files in the assembly of the
* final XLSX file, for example on servers that don't allow temp files such as
* the Google APP Engine, set the ``in_memory`` constructor option to ``True``:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {in_memory = True});
*
* This option overrides the ``constant_memory`` option.
* @endcode
*
* * **strings_to_numbers**: Enable the
* :ref:`worksheet: <Worksheet>`:func:`write()` method to convert strings to
* numbers, where possible, using :func:`float()` in order to avoid an Excel
* warning about "Numbers Stored as Text". The default is ``False``:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {strings_to_numbers = True});
*
* @endcode
*
* * **strings_to_formulas**: Enable the
* :ref:`worksheet: <Worksheet>`:func:`write()` method to convert strings to
* formulas. The default is ``True``:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {strings_to_formulas = False});
*
* @endcode
*
* * **strings_to_urls**: Enable the
* :ref:`worksheet: <Worksheet>`:func:`write()` method to convert strings to
* urls. The default is ``True``:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {strings_to_urls = True});
*
* @endcode
*
* * **default_date_format**: This option is used to specify a default date
* format string for use with the
* :ref:`worksheet: <Worksheet>`:func:`write_datetime()` method when an
* explicit format isn't given. See :ref:`working_with_dates_and_time` for more
* details:
*
* @code
* xlsxwriter.Workbook(filename, {default_date_format = 'dd/mm/yy'});
*
* @endcode
*
* * **date_1904**: Excel for Windows uses a default epoch of 1900 and Excel for
* Mac uses an epoch of 1904. However, Excel on either platform will convert
* automatically between one system and the other. xlsxwriter stores dates in
* the 1900 format by default. If you wish to change this you can use the
* ``date_1904`` workbook option. This option is mainly for enhanced
* compatibility with Excel and in general isn't required very often:
*
* @code
* workbook = xlsxwriter.Workbook(filename, {date_1904 = True});
*
* @endcode
*
* When specifying a filename it is recommended that you use an ``.xlsx``
* extension or Excel will generate a warning when opening the file.
*
* It is possible to write files to in-memory strings using StringIO as follows:
*
* @code
* output = StringIO();
* workbook = xlsxwriter.Workbook(output);
* worksheet = workbook:add_worksheet();
*
* worksheet:write('A1', 'Hello');
* workbook:close();
*
* xlsx_data = output.getvalue();
*
* @endcode
*
* To avoid the use of any temporary files and keep the entire file in-memory use
* the ``in_memory`` constructor option shown above.
*
* See also :ref:`ex_http_server`.
*
*
* workbook:add_worksheet()
*/
*
/**
* @brief Add a new worksheet to a workbook:
*
*
* @param self Pointer to lxw_format.
* @param sheetname Optional worksheet name, defaults to Sheet1, etc.
* :rtype: A :ref:`worksheet <Worksheet>` object.
*
* The ``add_worksheet()`` method adds a new worksheet to a workbook:
*
* At least one worksheet should be added to a new workbook: The
* :ref:`Worksheet <worksheet>` object is used to write data and configure a
* worksheet in the workbook:
*
* The ``sheetname`` parameter is optional. If it is not specified the default
* Excel convention will be followed, i.e. Sheet1, Sheet2, etc.:
*
* @code
* worksheet1 = workbook:add_worksheet(); // Sheet1
* worksheet2 = workbook:add_worksheet('Foglio2'); // Foglio2
* worksheet3 = workbook:add_worksheet('Data'); // Data
* worksheet4 = workbook:add_worksheet(); // Sheet4
*
* @endcode
*
* @image html workbook02.png
*
* The worksheet name must be a valid Excel worksheet name, i.e. it cannot contain
* any of the characters ``' [ ] : * ? / \
* '`` and it must be less than 32 characters.
*
* In addition, you cannot use the same, case insensitive, ``sheetname`` for more
* than one worksheet:
*
* workbook:add_format()
*/
*
/**
* @brief Create a new Format object to formats cells in worksheets.
*
*
* @param self Pointer to lxw_format.
* @paramionary properties An optional dictionary of format properties.
* :rtype: A :ref:`format <Format>` object.
*
* The ``add_format()`` method can be used to create new :ref:`Format <Format>`
* objects which are used to apply formatting to a cell. You can either define
* the properties at creation time via a dictionary of property values or later
* via method calls:
*
* @code
* format1 = workbook:add_format(props); // Set properties at creation.
* format2 = workbook:add_format(); // Set properties later.
*
* @endcode
*
* See the :ref:`format` and :ref:`working_with_formats` sections for more details
* about Format properties and how to set them.
*
*
* workbook:add_chart()
*/
*
/**
* @brief Create a chart object that can be added to a worksheet:
*
*
* @param self Pointer to lxw_format.
* @paramionary options An dictionary of chart type options.
* :rtype: A :ref:`Chart <chart_class>` object.
*
* This method is use to create a new chart object that can be inserted into a
* worksheet via the :func:`insert_chart()` Worksheet method:
*
* @code
* chart = workbook:add_chart({type = 'column'});
*
* @endcode
*
* The properties that can be set are:
*
* @code
* type (required);
* subtype (optional);
*
* @endcode
*
* * ``type``
*
* This is a required parameter. It defines the type of chart that will be
* created:
*
* @code
* chart = workbook:add_chart({type = 'line'});
*
* The available types are:
*
* @code
* area
* bar
* column
* line
* pie
* radar
* scatter
* stock
*
* @endcode
*
* * ``subtype``
*
* Used to define a chart subtype where available:
*
* @code
* workbook:add_chart({type = 'bar', subtype = 'stacked'});
*
* @endcode
*
* See the :ref:`chart_class` for a list of available chart subtypes.
*
* See also :ref:`working_with_charts` and :ref:`chart_examples`.
*
* workbook:add_chartsheet()
*/
*
/**
* @brief Add a new add_chartsheet to a workbook:
*
*
* @param self Pointer to lxw_format.
* @param sheetname Optional chartsheet name, defaults to Chart1, etc.
* :rtype: A :ref:`chartsheet <Chartsheet>` object.
*
* The ``add_chartsheet()`` method adds a new chartsheet to a workbook:
*
* @image html chartsheet.png
*
* See :ref:`chartsheet` for details.
*
* The ``sheetname`` parameter is optional. If it is not specified the default
* Excel convention will be followed, i.e. Chart1, Chart2, etc.
*
* The chartsheet name must be a valid Excel worksheet name, i.e. it cannot
* contain any of the characters ``' [ ] : * ? / \
* '`` and it must be less than 32 characters.
*
* In addition, you cannot use the same, case insensitive, ``sheetname`` for more
* than one chartsheet.
*
*
* workbook:close()
*/
*
/**
* @brief Close the Workbook object and write the XLSX file.
*
*
* In general your Excel file will be closed automatically when your program ends
* or when the Workbook object goes out of scope, however the ``close()`` method
* can be used to explicitly close an Excel file:
*
* @code
* workbook:close();
*
* @endcode
*
* An explicit ``close()`` is required if the file must be closed prior to
* performing some external action on it such as copying it, reading its size or
* attaching it to an email.
*
* In addition, ``close()`` may occasionally be required to prevent Python's
* garbage collector from disposing of the Workbook, Worksheet and Format objects
* in the wrong order.
*
*
* workbook:set_properties()
*/
*
/**
* @brief Set the document properties such as Title, Author etc.
*
*
* @param self Pointer to lxw_format.
* @param properties Dictionary of document properties.
*
* The ``set_properties`` method can be used to set the document properties of the
* Excel file created by ``xlsxwriter``. These properties are visible when you
* use the ``Office Button -> Prepare -> Properties`` option in Excel and are
* also available to external applications that read or index windows files.
*
* The properties that can be set are:
*
* * ``title``
* * ``subject``
* * ``author``
* * ``manager``
* * ``company``
* * ``category``
* * ``keywords``
* * ``comments``
* * ``status``
*
* The properties are all optional and should be passed in dictionary format as
* follows:
*
* @code
* workbook:set_properties({
* title = 'This is an example spreadsheet',
* subject = 'With document properties',
* author = 'John McNamara',
* manager = 'Dr. Heinz Doofenshmirtz',
* company = 'of Wolves',
* category = 'Example spreadsheets',
* keywords = 'Sample, Example, Properties',
* comments = 'Created with Python and xlsxwriter'});
*
* @endcode
*
* @image html doc_properties.png
*
* See also :ref:`ex_doc_properties`.
*
* workbook:define_name()
*/
*
/**
* @brief Create a defined name in the workbook to use as a variable.
*
*
* @param self Pointer to lxw_format.
* @param name The defined name.
* @param formula The cell or range that the defined name refers to.
*
* This method is used to defined a name that can be used to represent a value, a
* single cell or a range of cells in a workbook: These defined names can then be
* used in formulas:
*
* @code
* workbook:define_name('Exchange_rate', '=0.96');
* worksheet:write('B3', '=B2*Exchange_rate');
*
* @endcode
*
* As in Excel a name defined like this is "global" to the workbook and can be
* referred to from any worksheet:
*
* @code
* // Global workbook name.
* workbook:define_name('Sales', '=Sheet1!$G$1:$H$10');
*
* @endcode
*
* It is also possible to define a local/worksheet name by prefixing it with the
* sheet name using the syntax ``'sheetname!definedname'``:
*
* @code
* // Local worksheet name.
* workbook:define_name('Sheet2!Sales', '=Sheet2!$G$1:$G$10');
*
* @endcode
*
* If the sheet name contains spaces or special characters you must follow the
* Excel convention and enclose it in single quotes:
*
* @code
* workbook:define_name("'New Data'!Sales", '=Sheet2!$G$1:$G$10');
*
* @endcode
*
* See also the ``defined_name.py`` program in the examples directory.
*
*
* workbook:worksheets()
*/
*
/**
* @brief Return a list of the worksheet objects in the workbook:
*
*
* :rtype: A list of :ref:`worksheet <Worksheet>` objects.
*
* The ``worksheets()`` method returns a list of the worksheets in a workbook:
* This is useful if you want to repeat an operation on each worksheet in a
* workbook:
*
* @code
* for worksheet in workbook:worksheets():
* worksheet:write('A1', 'Hello');
*
* @endcode
*
* workbook:set_calc_mode()
*/
*
/**
* @brief Set the Excel calculation mode for the workbook:
*
*
* @param self Pointer to lxw_format.
* @param mode The calculation mode string
*
* Set the calculation mode for formulas in the workbook: This is mainly of use
* for workbooks with slow formulas where you want to allow the user to calculate
* them manually.
*
* The ``mode`` parameter can be:
*
* * ``auto``: The default. Excel will re-calculate formulas when a formula or a
* value affecting the formula changes.
*
* * ``auto_except_tables``: Excel will automatically re-calculate formulas
* except for tables.
*
* * ``manual``: Only re-calculate formulas when the user requires it. Generally
* by pressing F9.
*
*
* workbook:use_zip64()
*/
*
/**
* @brief Allow ZIP64 extensions when writing xlsx file zip container.
*
*
* Use ZIP64 extensions when writing the xlsx file zip container and allow files
* greater than 4 GB.
*

2247
docs/src/cworksheet.dox
View File

File diff suppressed because it is too large Load Diff

2
include/xlsxwriter/workbook.h
View File

@ -61,7 +61,7 @@ enum lxw_close_error {
LXW_CLOSE_ERROR_NONE,
/** Error encountered when creating file zip container */
LXW_CLOSE_ERROR_ZIP
/* TODO. Need to add/document more. */
/* TODO. Need to add/document more. */
};
/**

48
include/xlsxwriter/worksheet.h
View File

@ -1,6 +1,6 @@
/*
* libxlsxwriter
*
*
* Copyright 2014, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
*/
@ -12,7 +12,7 @@
* layout.
*
* See @ref worksheet.h for full details of the functionality.
*
*
* @file worksheet.h
*
* @brief Functions related to adding data and formatting to a worksheet.
@ -24,7 +24,7 @@
* A Worksheet object isn’t created directly. Instead a worksheet is
* created by calling the workbook_add_worksheet() method from a
* Workbook object:
*
*
* @code
* #include "xlsxwriter.h"
*
@ -53,6 +53,11 @@
#include "format.h"
#include "utility.h"
#define LXW_COL_META_MAX 128
/** Default column width in Excel */
#define LXW_DEF_COL_WIDTH 8.43
/** Error codes from `worksheet_write*()` functions. */
enum lxw_write_error {
LXW_WRITE_ERROR_NONE = 0,
@ -85,6 +90,23 @@ enum cell_types {
TAILQ_HEAD(lxw_table_cells, lxw_cell);
TAILQ_HEAD(lxw_table_rows, lxw_row);
/** Options struct for the worksheet_set_column() and worksheet_set_row(). */
typedef struct lxw_row_col_options {
uint8_t hidden;
uint8_t level;
uint8_t collapsed;
} lxw_row_col_options;
typedef struct lxw_col_options {
lxw_col_t firstcol;
lxw_col_t lastcol;
double width;
lxw_format *format;
uint8_t hidden;
uint8_t level;
uint8_t collapsed;
} lxw_col_options;
/**
* @brief Struct to represent an Excel worksheet.
*
@ -110,6 +132,16 @@ typedef struct lxw_worksheet {
uint8_t selected;
uint8_t hidden;
lxw_col_options **col_options;
uint16_t col_options_max;
uint8_t *col_sizes;
uint16_t col_sizes_max;
lxw_format **col_formats;
uint16_t col_formats_max;
uint8_t col_size_changed;
STAILQ_ENTRY (lxw_worksheet) list_pointers;
} lxw_worksheet;
@ -409,9 +441,13 @@ int8_t worksheet_write_datetime(lxw_worksheet *worksheet,
* As such, if you write an empty cell without formatting it is ignored.
*
*/
int8_t worksheet_write_blank(lxw_worksheet *worksheet,
lxw_row_t row, lxw_col_t col, lxw_format *format);
lxw_row_t row, lxw_col_t col,
lxw_format *format);
int8_t worksheet_set_column(lxw_worksheet *self, lxw_col_t firstcol,
lxw_col_t lastcol, double width,
lxw_format *format, lxw_row_col_options *options);
lxw_worksheet *_new_worksheet(lxw_worksheet_init_data *init_data);
void _free_worksheet(lxw_worksheet *worksheet);
@ -429,6 +465,8 @@ STATIC void _worksheet_write_sheet_format_pr(lxw_worksheet *worksheet);
STATIC void _worksheet_write_sheet_data(lxw_worksheet *worksheet);
STATIC void _worksheet_write_page_margins(lxw_worksheet *worksheet);
STATIC void _write_row(lxw_worksheet *worksheet, lxw_row *row, char *spans);
STATIC void _write_col_info(lxw_worksheet *worksheet,
lxw_col_options *options);
STATIC lxw_row *_get_row(struct lxw_table_rows *table, lxw_row_t row_num);
#endif /* TESTING */

4
include/xlsxwriter/xmlwriter.h
View File

@ -71,9 +71,9 @@ struct xml_attribute *_new_attribute_dbl(const char *key, double value);
} while (0)
/* Macro to add attribute double values to xml_attribute_list. */
#define _PUSH_ATTRIBUTES_FLT(key, value) \
#define _PUSH_ATTRIBUTES_DBL(key, value) \
do { \
attribute = _new_attribute_flt((key), (value)); \
attribute = _new_attribute_dbl((key), (value)); \
STAILQ_INSERT_TAIL(&attributes, attribute, list_entries); \
} while (0)

2
src/Makefile
View File

@ -70,6 +70,8 @@ $(LIBXLSXWRITER_SO) : $(SOBJS)
$(LIBXLSXWRITER_TO) : $(TOBJS)
$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_DIR)/ioapi.o $(MINIZIP_DIR)/zip.o $^
# Minimal target for quick compile without creating the libs.
test_compile : $(OBJS)
# Targets for the object files.
%.o : %.c $(HDRS)

248
src/worksheet.c
View File

@ -39,6 +39,19 @@ _new_worksheet(lxw_worksheet_init_data *init_data)
worksheet->table = calloc(1, sizeof(struct lxw_table_rows));
GOTO_LABEL_ON_MEM_ERROR(worksheet->table, mem_error);
worksheet->col_options =
calloc(LXW_COL_META_MAX, sizeof(lxw_col_options *));
worksheet->col_options_max = LXW_COL_META_MAX;
GOTO_LABEL_ON_MEM_ERROR(worksheet->col_options, mem_error);
worksheet->col_sizes = calloc(LXW_COL_META_MAX, sizeof(double));
worksheet->col_sizes_max = LXW_COL_META_MAX;
GOTO_LABEL_ON_MEM_ERROR(worksheet->col_sizes, mem_error);
worksheet->col_formats = calloc(LXW_COL_META_MAX, sizeof(uint16_t *));
worksheet->col_formats_max = LXW_COL_META_MAX;
GOTO_LABEL_ON_MEM_ERROR(worksheet->col_formats, mem_error);
TAILQ_INIT(worksheet->table);
worksheet->file = NULL;
@ -69,10 +82,29 @@ _free_worksheet(lxw_worksheet *worksheet)
{
lxw_row *row;
lxw_cell *cell;
lxw_col_t col;
if (!worksheet)
return;
if (worksheet->col_options) {
for (col = 0; col < worksheet->col_options_max; col++) {
if (worksheet->col_options[col])
free(worksheet->col_options[col]);
}
}
free(worksheet->col_options);
free(worksheet->col_sizes);
if (worksheet->col_formats) {
for (col = 0; col < worksheet->col_formats_max; col++) {
if (worksheet->col_formats[col])
free(worksheet->col_formats[col]);
}
}
free(worksheet->col_formats);
if (worksheet->table) {
while (!TAILQ_EMPTY(worksheet->table)) {
@ -97,6 +129,7 @@ _free_worksheet(lxw_worksheet *worksheet)
free(worksheet->name);
free(worksheet);
worksheet = NULL;
}
/*
@ -668,6 +701,98 @@ _write_rows(lxw_worksheet *self)
}
}
/*
* Write the <col> element.
*/
STATIC void
_write_col_info(lxw_worksheet *self, lxw_col_options *options)
{
struct xml_attribute_list attributes;
struct xml_attribute *attribute;
double width = options->width;
uint8_t has_custom_width = LXW_TRUE;
int32_t xf_index = 0;
double max_digit_width = 7.0; /* For Calabri 11. */
double padding = 5.0;
/* Get the format index. */
if (options->format) {
xf_index = _get_xf_index(options->format);
}
/* Check if width is the Excel default. */
if (width == LXW_DEF_COL_WIDTH) {
/* The default col width changes to 0 for hidden columns. */
if (options->hidden)
width = 0;
else
has_custom_width = LXW_FALSE;
}
/* Convert column width from user units to character width. */
if (width > 0) {
if (width < 1) {
width = (uint16_t) (((uint16_t)
(width * (max_digit_width + padding) + 0.5))
/ max_digit_width * 256.0) / 256.0;
}
else {
width = (uint16_t) (((uint16_t)
(width * max_digit_width + 0.5) + padding)
/ max_digit_width * 256.0) / 256.0;
}
}
_INIT_ATTRIBUTES();
_PUSH_ATTRIBUTES_INT("min", 1 + options->firstcol);
_PUSH_ATTRIBUTES_INT("max", 1 + options->lastcol);
_PUSH_ATTRIBUTES_DBL("width", width);
if (xf_index)
_PUSH_ATTRIBUTES_INT("style", xf_index);
if (options->hidden)
_PUSH_ATTRIBUTES_STR("hidden", "1");
if (has_custom_width)
_PUSH_ATTRIBUTES_STR("customWidth", "1");
if (options->level)
_PUSH_ATTRIBUTES_INT("outlineLevel", options->level);
if (options->collapsed)
_PUSH_ATTRIBUTES_STR("collapsed", "1");
_xml_empty_tag(self->file, "col", &attributes);
_FREE_ATTRIBUTES();
}
/*
* Write the <cols> element and <col> sub elements.
*/
STATIC void
_write_cols(lxw_worksheet *self)
{
lxw_col_t col;
if (!self->col_size_changed)
return;
_xml_start_tag(self->file, "cols", NULL);
for (col = 0; col < self->col_options_max; col++) {
if (self->col_options[col])
_write_col_info(self, self->col_options[col]);
}
_xml_end_tag(self->file, "cols");
}
/*
* Check that row and col are within the allowed Excel range and store max
* and min values for use in other methods/elements.
@ -724,6 +849,9 @@ _worksheet_assemble_xml_file(lxw_worksheet *self)
/* Write the sheet format properties. */
_worksheet_write_sheet_format_pr(self);
/* Write the sheet column info. */
_write_cols(self);
/* Write the sheetData element. */
_worksheet_write_sheet_data(self);
@ -744,18 +872,20 @@ _worksheet_assemble_xml_file(lxw_worksheet *self)
* Write a number to a cell in Excel.
*/
int8_t
worksheet_write_number(lxw_worksheet *worksheet,
worksheet_write_number(lxw_worksheet *self,
lxw_row_t row_num,
lxw_col_t col_num, double value, lxw_format *format)
{
lxw_row *row;
lxw_cell *cell;
int8_t err = _check_dimensions(worksheet, row_num, col_num, 0, 0);
int8_t err;
err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
if (err)
return err;
row = _get_row(worksheet->table, row_num);
row = _get_row(self->table, row_num);
cell = _new_number_cell(row_num, col_num, value, format);
_insert_cell(row->cells, cell, col_num);
@ -767,7 +897,7 @@ worksheet_write_number(lxw_worksheet *worksheet,
* Write a string to an Excel file.
*/
int8_t
worksheet_write_string(lxw_worksheet *worksheet,
worksheet_write_string(lxw_worksheet *self,
lxw_row_t row_num,
lxw_col_t col_num, const char *string,
lxw_format *format)
@ -775,17 +905,19 @@ worksheet_write_string(lxw_worksheet *worksheet,
lxw_row *row;
lxw_cell *cell;
int32_t string_id;
int8_t err = _check_dimensions(worksheet, row_num, col_num, 0, 0);
int8_t err;
err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
if (err)
return err;
/* Treat a NULL string with formatting as a blank cell. */
if (!string && format)
return worksheet_write_blank(worksheet, row_num, col_num, format);
return worksheet_write_blank(self, row_num, col_num, format);
/* Get the SST string ID for the string. */
string_id = _get_sst_index(worksheet->sst, string);
string_id = _get_sst_index(self->sst, string);
if (string_id < 0)
return LXW_STRING_HASH_ERROR;
@ -793,7 +925,7 @@ worksheet_write_string(lxw_worksheet *worksheet,
if (strlen(string) > LXW_STR_MAX)
return LXW_STRING_LENGTH_ERROR;
row = _get_row(worksheet->table, row_num);
row = _get_row(self->table, row_num);
cell = _new_string_cell(row_num, col_num, string_id, format);
_insert_cell(row->cells, cell, col_num);
@ -805,7 +937,7 @@ worksheet_write_string(lxw_worksheet *worksheet,
* Write a formula with a numerical result to a cell in Excel.
*/
int8_t
worksheet_write_formula_num(lxw_worksheet *worksheet,
worksheet_write_formula_num(lxw_worksheet *self,
lxw_row_t row_num,
lxw_col_t col_num,
const char *formula,
@ -814,7 +946,9 @@ worksheet_write_formula_num(lxw_worksheet *worksheet,
lxw_row *row;
lxw_cell *cell;
char *formula_copy;
int8_t err = _check_dimensions(worksheet, row_num, col_num, 0, 0);
int8_t err;
err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
if (err)
return err;
@ -825,7 +959,7 @@ worksheet_write_formula_num(lxw_worksheet *worksheet,
else
formula_copy = __builtin_strdup(formula);
row = _get_row(worksheet->table, row_num);
row = _get_row(self->table, row_num);
cell = _new_formula_cell(row_num, col_num, formula_copy, format);
cell->formula_result.number = result;
@ -838,12 +972,12 @@ worksheet_write_formula_num(lxw_worksheet *worksheet,
*Write a formula with a default result to a cell in Excel .
*/ int8_t
worksheet_write_formula(lxw_worksheet *worksheet,
worksheet_write_formula(lxw_worksheet *self,
lxw_row_t row_num,
lxw_col_t col_num, const char *formula,
lxw_format *format)
{
return worksheet_write_formula_num(worksheet, row_num, col_num, formula,
return worksheet_write_formula_num(self, row_num, col_num, formula,
format, 0);
}
@ -852,7 +986,7 @@ worksheet_write_formula(lxw_worksheet *worksheet,
*/
int8_t
worksheet_write_blank(lxw_worksheet *worksheet,
worksheet_write_blank(lxw_worksheet *self,
lxw_row_t row_num, lxw_col_t col_num,
lxw_format *format)
{
@ -864,12 +998,12 @@ worksheet_write_blank(lxw_worksheet *worksheet,
if (!format)
return 0;
err = _check_dimensions(worksheet, row_num, col_num, 0, 0);
err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
if (err)
return err;
row = _get_row(worksheet->table, row_num);
row = _get_row(self->table, row_num);
cell = _new_blank_cell(row_num, col_num, format);
_insert_cell(row->cells, cell, col_num);
@ -881,7 +1015,7 @@ worksheet_write_blank(lxw_worksheet *worksheet,
* Write a date and or time to a cell in Excel.
*/
int8_t
worksheet_write_datetime(lxw_worksheet *worksheet,
worksheet_write_datetime(lxw_worksheet *self,
lxw_row_t row_num,
lxw_col_t col_num, lxw_datetime *datetime,
lxw_format *format)
@ -889,17 +1023,93 @@ worksheet_write_datetime(lxw_worksheet *worksheet,
lxw_row *row;
lxw_cell *cell;
double excel_date;
int8_t err = _check_dimensions(worksheet, row_num, col_num, 0, 0);
int8_t err;
err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
if (err)
return err;
excel_date = _datetime_to_excel_date(datetime, EPOCH_1900);
row = _get_row(worksheet->table, row_num);
row = _get_row(self->table, row_num);
cell = _new_number_cell(row_num, col_num, excel_date, format);
_insert_cell(row->cells, cell, col_num);
return 0;
}
/*
* Set the properties of a single column or a range of columns.
*/
int8_t
worksheet_set_column(lxw_worksheet *self,
lxw_col_t firstcol,
lxw_col_t lastcol,
double width,
lxw_format *format, lxw_row_col_options *options)
{
lxw_col_options *col_options;
uint8_t ignore_row = LXW_TRUE;
uint8_t ignore_col = LXW_TRUE;
lxw_col_t col;
int8_t err;
/* Ensure 2nd col is larger than first. */
if (firstcol > lastcol) {
lxw_col_t tmp = firstcol;
firstcol = lastcol;
lastcol = tmp;
}
/* Temp workaround. Only support 128 cols for now. */
if (lastcol > LXW_COL_META_MAX)
return -1;
/* Ensure that the cols are valid and store max and min values.
* NOTE: The check shouldn't modify the row dimensions and should only
* modify the column dimensions in certain cases. */
if (format != NULL || width > 0)
ignore_col = LXW_FALSE;
err = _check_dimensions(self, 0, firstcol, ignore_row, ignore_col);
if (!err)
err = _check_dimensions(self, 0, lastcol, ignore_row, ignore_col);
if (err)
return err;
col_options = calloc(1, sizeof(lxw_col_options));
RETURN_ON_MEM_ERROR(col_options, -1);
/* Store the column option based on the first column. */
col_options->firstcol = firstcol;
col_options->lastcol = lastcol;
col_options->width = width;
col_options->format = format;
if (options) {
col_options->hidden = options->hidden;
col_options->level = options->level;
col_options->collapsed = options->collapsed;
}
self->col_options[firstcol] = col_options;
/* Store the col sizes for use when calculating image vertices taking
* hidden columns into account. Also store the column formats. */
if (options->hidden)
width = 0;
for (col = firstcol; col <= lastcol; col++) {
self->col_sizes[col] = width;
self->col_formats[col] = format;
}
/* Store the column change to allow optimisations. */
self->col_size_changed = LXW_TRUE;
return 0;
}

21
test/functional/src/test_simple01.c Normal file
View File

@ -0,0 +1,21 @@
/*****************************************************************************
* Test cases for libxlsxwriter.
*
* Simple test case to test data writing.
*
* Copyright 2014, John McNamara, jmcnamara@cpan.org
*
*/
#include "xlsxwriter.h"
int main() {
lxw_workbook *workbook = new_workbook("test_simple01.xlsx");
lxw_worksheet *worksheet = workbook_add_worksheet(workbook, NULL);
worksheet_write_string(worksheet, 0, 0, "Hello", NULL);
worksheet_write_number(worksheet, 1, 0, 123, NULL);
return workbook_close(workbook);
}

35
test/functional/src/test_simple02.c Normal file
View File

@ -0,0 +1,35 @@
/*****************************************************************************
* Test cases for libxlsxwriter.
*
* Simple test case to test data writing.
*
* Copyright 2014, John McNamara, jmcnamara@cpan.org
*
*/
#include "xlsxwriter.h"
/* Ignore warnings about unused variables since this file is testing how
* unused formats are handled.
*/
#pragma GCC diagnostic ignored "-Wunused-variable"
int main() {
lxw_workbook *workbook = new_workbook("test_simple02.xlsx");
lxw_worksheet *worksheet1 = workbook_add_worksheet(workbook, NULL);
lxw_worksheet *worksheet2 = workbook_add_worksheet(workbook, "Data Sheet");
lxw_worksheet *worksheet3 = workbook_add_worksheet(workbook, NULL);
lxw_format *format = workbook_add_format(workbook);
format_set_bold(format);
worksheet_write_string(worksheet1, 0, 0, "Foo", NULL);
worksheet_write_number(worksheet1, 1, 0, 123, NULL);
worksheet_write_string(worksheet3, 1, 1, "Foo", NULL);
worksheet_write_string(worksheet3, 2, 1, "Bar", format);
worksheet_write_number(worksheet3, 3, 2, 234, NULL);
return workbook_close(workbook);
}

31
test/functional/src/test_simple04.c Normal file
View File

@ -0,0 +1,31 @@
/*****************************************************************************
* Test cases for libxlsxwriter.
*
* Simple test case to test data writing.
*
* Copyright 2014, John McNamara, jmcnamara@cpan.org
*
*/
#include "xlsxwriter.h"
int main() {
lxw_datetime datetime1 = {0, 0, 0, 12, 0, 0};
lxw_datetime datetime2 = {2013, 1, 27, 0, 0, 0};
lxw_workbook *workbook = new_workbook("test_simple04.xlsx");
lxw_worksheet *worksheet = workbook_add_worksheet(workbook, NULL);
lxw_format *format1 = workbook_add_format(workbook);
lxw_format *format2 = workbook_add_format(workbook);
format_set_num_format_index(format1, 20);
format_set_num_format_index(format2, 14);
worksheet_set_column(worksheet, 0, 0, 12, NULL, NULL);
worksheet_write_datetime(worksheet, 0, 0, &datetime1, format1);
worksheet_write_datetime(worksheet, 1, 0, &datetime2, format2);
return workbook_close(workbook);
}

29
test/functional/test_simple.py Normal file
View File

@ -0,0 +1,29 @@
###############################################################################
#
# Tests for libxlsxwriter.
#
# Copyright (c), 2014, John McNamara, jmcnamara@cpan.org
#
import base_test_class
class TestCompareXLSXFiles(base_test_class.XLSXBaseTest):
"""
Test file created with libxlsxwriter against a file created by Excel.
"""
def test_simple01(self):
self.run_exe_test('test_simple01')
def test_simple02(self):
self.run_exe_test('test_simple02')
# def test_simple03(self):
# self.run_exe_test('test_simple03')
def test_simple04(self):
self.run_exe_test('test_simple04')
# def test_simple05(self):
# self.run_exe_test('test_simple05')

BIN
test/functional/xlsx_files/simple01.xlsx Normal file
View File

Binary file not shown.

BIN
test/functional/xlsx_files/simple02.xlsx Normal file
View File

Binary file not shown.

BIN
test/functional/xlsx_files/simple03.xlsx Normal file
View File

Binary file not shown.

BIN
test/functional/xlsx_files/simple04.xlsx Normal file
View File

Binary file not shown.

BIN
test/functional/xlsx_files/simple05.xlsx Normal file
View File

Binary file not shown.

164
test/unit/worksheet/test_worksheet_write_col_info.cpp Normal file
View File

@ -0,0 +1,164 @@
/*
* Tests for the lib_xlsx_writer library.
*
* Copyright 2014, John McNamara, jmcnamara@cpan.org
*
*/
#include <gtest/gtest.h>
#include "../helper.h"
#include "xlsxwriter/worksheet.h"
#include "xlsxwriter/format.h"
// Test the _write_col_info() function.
TEST(worksheet, write_col_info01) {
char* got;
char exp[] = "<col min=\"2\" max=\"4\" width=\"5.7109375\" customWidth=\"1\"/>";
FILE* testfile = tmpfile();
lxw_col_options col_options = {.firstcol = 1,
.lastcol = 3,
.width = 5,
.format = NULL,
.hidden = 0,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}
TEST(worksheet, write_col_info02) {
char* got;
char exp[] = "<col min=\"6\" max=\"6\" width=\"8.7109375\" hidden=\"1\" customWidth=\"1\"/>";
FILE* testfile = tmpfile();
lxw_col_options col_options = {.firstcol = 5,
.lastcol = 5,
.width = 8,
.format = NULL,
.hidden = 1,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}
TEST(worksheet, write_col_info03) {
char* got;
char exp[] = "<col min=\"8\" max=\"8\" width=\"9.140625\" style=\"1\"/>";
FILE* testfile = tmpfile();
lxw_format *format = _new_format();
format->xf_index = 1;
lxw_col_options col_options = {.firstcol = 7,
.lastcol = 7,
.width = LXW_DEF_COL_WIDTH,
.format = format,
.hidden = 0,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}
TEST(worksheet, write_col_info04) {
char* got;
char exp[] = "<col min=\"9\" max=\"9\" width=\"9.140625\" style=\"1\"/>";
FILE* testfile = tmpfile();
lxw_format *format = _new_format();
format->xf_index = 1;
lxw_col_options col_options = {.firstcol = 8,
.lastcol = 8,
.width = LXW_DEF_COL_WIDTH,
.format = format,
.hidden = 0,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}
TEST(worksheet, write_col_info05) {
char* got;
char exp[] = "<col min=\"10\" max=\"10\" width=\"2.7109375\" customWidth=\"1\"/>";
FILE* testfile = tmpfile();
lxw_col_options col_options = {.firstcol = 9,
.lastcol = 9,
.width = 2,
.format = NULL,
.hidden = 0,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}
TEST(worksheet, write_col_info06) {
char* got;
char exp[] = "<col min=\"12\" max=\"12\" width=\"0\" hidden=\"1\" customWidth=\"1\"/>";
FILE* testfile = tmpfile();
lxw_col_options col_options = {.firstcol = 11,
.lastcol = 11,
.width = LXW_DEF_COL_WIDTH,
.format = NULL,
.hidden = 1,
.level = 0,
.collapsed = 0};
lxw_worksheet *worksheet = _new_worksheet(NULL);
worksheet->file = testfile;
_write_col_info(worksheet, &col_options);
RUN_XLSX_STREQ(exp, got);
_free_worksheet(worksheet);
}