kmadej_fast_excel_fork 0.2.2

data/libxlsxwriter/include/xlsxwriter/xmlwriter.h

@@ -0,0 +1,178 @@
+/*
+ * libxlsxwriter
+ *
+ * Copyright 2014-2017, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
+ *
+ * xmlwriter - A libxlsxwriter library for creating Excel XLSX
+ *             XML files.
+ *
+ * The xmlwriter library is used to create the XML sub-components files
+ * in the Excel XLSX file format.
+ *
+ * This library is used in preference to a more generic XML library to allow
+ * for customization and optimization for the XLSX file format.
+ *
+ * The xmlwriter functions are only used internally and do not need to be
+ * called directly by the end user.
+ *
+ */
+#ifndef __XMLWRITER_H__
+#define __XMLWRITER_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "common.h"
+
+#define LXW_MAX_ATTRIBUTE_LENGTH 256
+#define LXW_ATTR_32              32
+
+#define LXW_ATTRIBUTE_COPY(dst, src)                    \
+    do{                                                 \
+        strncpy(dst, src, LXW_MAX_ATTRIBUTE_LENGTH -1); \
+        dst[LXW_MAX_ATTRIBUTE_LENGTH - 1] = '\0';       \
+    } while (0)
+
+
+ /* *INDENT-OFF* */
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* *INDENT-ON* */
+
+/* Attribute used in XML elements. */
+struct xml_attribute {
+    char key[LXW_MAX_ATTRIBUTE_LENGTH];
+    char value[LXW_MAX_ATTRIBUTE_LENGTH];
+
+    /* Make the struct a queue.h list element. */
+    STAILQ_ENTRY (xml_attribute) list_entries;
+};
+
+/* Use queue.h macros to define the xml_attribute_list type. */
+STAILQ_HEAD(xml_attribute_list, xml_attribute);
+
+/* Create a new attribute struct to add to a xml_attribute_list. */
+struct xml_attribute *lxw_new_attribute_str(const char *key,
+                                            const char *value);
+struct xml_attribute *lxw_new_attribute_int(const char *key, uint32_t value);
+struct xml_attribute *lxw_new_attribute_dbl(const char *key, double value);
+
+/* Macro to initialize the xml_attribute_list pointers. */
+#define LXW_INIT_ATTRIBUTES()                                 \
+    STAILQ_INIT(&attributes)
+
+/* Macro to add attribute string elements to xml_attribute_list. */
+#define LXW_PUSH_ATTRIBUTES_STR(key, value)                   \
+    do {                                                      \
+    attribute = lxw_new_attribute_str((key), (value));        \
+    STAILQ_INSERT_TAIL(&attributes, attribute, list_entries); \
+    } while (0)
+
+/* Macro to add attribute int values to xml_attribute_list. */
+#define LXW_PUSH_ATTRIBUTES_INT(key, value)                   \
+    do {                                                      \
+    attribute = lxw_new_attribute_int((key), (value));        \
+    STAILQ_INSERT_TAIL(&attributes, attribute, list_entries); \
+    } while (0)
+
+/* Macro to add attribute double values to xml_attribute_list. */
+#define LXW_PUSH_ATTRIBUTES_DBL(key, value)                   \
+    do {                                                      \
+    attribute = lxw_new_attribute_dbl((key), (value));        \
+    STAILQ_INSERT_TAIL(&attributes, attribute, list_entries); \
+    } while (0)
+
+/* Macro to free xml_attribute_list and attribute. */
+#define LXW_FREE_ATTRIBUTES()                                 \
+    while (!STAILQ_EMPTY(&attributes)) {                      \
+        attribute = STAILQ_FIRST(&attributes);                \
+        STAILQ_REMOVE_HEAD(&attributes, list_entries);        \
+        free(attribute);                                      \
+    }
+
+/**
+ * Create the XML declaration in an XML file.
+ *
+ * @param xmlfile A FILE pointer to the output XML file.
+ */
+void lxw_xml_declaration(FILE * xmlfile);
+
+/**
+ * Write an XML start tag with optional attributes.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ * @param attributes An optional list of attributes to add to the tag.
+ */
+void lxw_xml_start_tag(FILE * xmlfile,
+                       const char *tag,
+                       struct xml_attribute_list *attributes);
+
+/**
+ * Write an XML start tag with optional un-encoded attributes.
+ * This is a minor optimization for attributes that don't need encoding.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ * @param attributes An optional list of attributes to add to the tag.
+ */
+void lxw_xml_start_tag_unencoded(FILE * xmlfile,
+                                 const char *tag,
+                                 struct xml_attribute_list *attributes);
+
+/**
+ * Write an XML end tag.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ */
+void lxw_xml_end_tag(FILE * xmlfile, const char *tag);
+
+/**
+ * Write an XML empty tag with optional attributes.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ * @param attributes An optional list of attributes to add to the tag.
+ */
+void lxw_xml_empty_tag(FILE * xmlfile,
+                       const char *tag,
+                       struct xml_attribute_list *attributes);
+
+/**
+ * Write an XML empty tag with optional un-encoded attributes.
+ * This is a minor optimization for attributes that don't need encoding.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ * @param attributes An optional list of attributes to add to the tag.
+ */
+void lxw_xml_empty_tag_unencoded(FILE * xmlfile,
+                                 const char *tag,
+                                 struct xml_attribute_list *attributes);
+
+/**
+ * Write an XML element containing data and optional attributes.
+ *
+ * @param xmlfile    A FILE pointer to the output XML file.
+ * @param tag        The XML tag to write.
+ * @param data       The data section of the XML element.
+ * @param attributes An optional list of attributes to add to the tag.
+ */
+void lxw_xml_data_element(FILE * xmlfile,
+                          const char *tag,
+                          const char *data,
+                          struct xml_attribute_list *attributes);
+
+char *lxw_escape_control_characters(const char *string);
+
+char *lxw_escape_data(const char *data);
+
+/* *INDENT-OFF* */
+#ifdef __cplusplus
+}
+#endif
+/* *INDENT-ON* */
+
+#endif /* __XMLWRITER_H__ */

data/libxlsxwriter/libxlsxwriter.podspec

@@ -0,0 +1,47 @@
+Pod::Spec.new do |s|
+  s.name                  = "libxlsxwriter"
+  s.version               = "0.6.9"
+  s.summary               = "Libxlsxwriter: A C library for creating Excel XLSX files."
+  s.ios.deployment_target = "6.0"
+  s.osx.deployment_target = "10.8"
+
+  s.description           = <<-DESC
+                            Libxlsxwriter is a C library that can be used to write text, numbers, formulas and hyperlinks to multiple worksheets in an Excel 2007+ XLSX file.
+
+                            It supports features such as:
+
+                            * 100% compatible Excel XLSX files.
+                            * Full Excel formatting.
+                            * Merged cells.
+                            * Defined names.
+                            * Autofilters.
+                            * Charts.
+                            * Worksheet PNG/JPEG images.
+                            * Memory optimisation mode for writing large files.
+                            * Source code available on [GitHub](https://github.com/jmcnamara/libxlsxwriter).
+                            * FreeBSD license.
+                            * ANSI C.
+                            * Works with GCC, Clang, Xcode, MSVC 2015, ICC, TCC, MinGW, MingGW-w64/32.
+                            * Works on Linux, FreeBSD, OpenBSD, OS X, iOS and Windows. Also works on MSYS/MSYS2 and Cygwin.
+                            * Compiles for 32 and 64 bit.
+                            * The only dependency is on `zlib`.
+                            DESC
+
+  s.homepage              = "http://libxlsxwriter.github.io"
+  s.documentation_url     = "http://libxlsxwriter.github.io"
+  s.license               = "FreeBSD"
+  s.author                = { "John McNamara" => "jmcnamara@cpan.org" }
+
+  s.source                = { :git => "https://github.com/jmcnamara/libxlsxwriter.git", :tag => "RELEASE_" + s.version.to_s }
+  s.source_files          = "src/**/*.c", "third_party/**/{zip.c,ioapi.c,tmpfileplus.c}", "include/**/*.h"
+
+  s.header_dir            = "xlsxwriter"
+  s.header_mappings_dir   = "include/xlsxwriter"
+  s.library               = "z"
+  s.compiler_flags        = "-DNOCRYPT=1", "-DNOUNCRYPT=1"
+  s.pod_target_xcconfig   = { 'USER_HEADER_SEARCH_PATHS' => '${PODS_ROOT}/libxlsxwriter/include' }
+  s.module_map            = "cocoapods/libxlsxwriter.modulemap"
+  s.prepare_command       = <<-CMD
+                            cp cocoapods/libxlsxwriter-umbrella.h include/xlsxwriter/libxlsxwriter-umbrella.h
+                          CMD
+end

data/libxlsxwriter/src/Makefile

@@ -0,0 +1,130 @@
+###############################################################################
+#
+# Makefile for libxlsxwriter library.
+#
+# Copyright 2014-2017, John McNamara, jmcnamara@cpan.org
+#
+
+# Keep the output quiet by default.
+Q=@
+ifdef V
+Q=
+endif
+
+# Directory variables.
+OBJS_DIR    = .
+INC_DIR     = ../include
+
+# The minizip directory.
+MINIZIP_DIR = ../third_party/minizip
+
+
+ifdef USE_STANDARD_TMPFILE
+# Use standard/C tmpfile().
+CFLAGS += -DUSE_STANDARD_TMPFILE
+else
+# Use tmpfileplus (the default).
+TMPFILEPLUS_DIR = ../third_party/tmpfileplus
+TMPFILEPLUS_OBJ = $(TMPFILEPLUS_DIR)/tmpfileplus.o
+TMPFILEPLUS_SO  = $(TMPFILEPLUS_DIR)/tmpfileplus.so
+endif
+
+# Flags passed to compiler.
+CFLAGS   += -g -O3 -Wall -Wextra -pedantic -ansi
+
+# Ignore icc remarks about inlining limits.
+ifeq ($(CC),icc)
+CFLAGS   +=-diag-disable=11074,11076
+endif
+
+# Library names.
+LIBXLSXWRITER_A  = libxlsxwriter.a
+LIBXLSXWRITER_SO = libxlsxwriter.so
+
+# Library with additional non-static functions for testing.
+LIBXLSXWRITER_TO = libxlsxwriter_test.a
+
+# Flags passed to static linker.
+ARFLAGS = rc
+
+# Flags passed to dynamic linker.
+FPIC = -fPIC
+SOFLAGS = -shared $(FPIC)
+
+# Get Env/OS name.
+UNAME := $(shell uname)
+
+# Change make options on OS X.
+ifeq ($(UNAME), Darwin)
+LIBXLSXWRITER_SO = libxlsxwriter.dylib
+SOFLAGS = -dynamiclib $(FPIC) -install_name /usr/lib/$(LIBXLSXWRITER_SO)
+endif
+
+# Check for MinGW/MinGW64/Cygwin environments.
+ifneq (,$(findstring MINGW, $(UNAME)))
+MING_LIKE = y
+endif
+ifneq (,$(findstring MSYS, $(UNAME)))
+MING_LIKE = y
+endif
+ifneq (,$(findstring CYGWIN, $(UNAME)))
+MING_LIKE = y
+endif
+
+# Change make options on MinGW/MinGW64/Cygwin.
+ifdef MING_LIKE
+LIBXLSXWRITER_SO = libxlsxwriter.dll
+FPIC =
+CC = gcc
+CFLAGS += -Wno-char-subscripts -Wno-long-long
+endif
+
+# Headers as dependecies.
+HDRS = $(wildcard ../include/xlsxwriter/*.h)
+
+# Ojects to compile.
+SRCS  = $(wildcard *.c)
+OBJS  = $(patsubst %.c,%.o,$(SRCS))
+SOBJS = $(patsubst %.c,%.so,$(SRCS))
+TOBJS = $(patsubst %.c,%.to,$(SRCS))
+# End of OBJS
+
+# Build the object files and the libraries.
+all : $(LIBXLSXWRITER_A) $(LIBXLSXWRITER_SO)
+	$(Q)cp $(LIBXLSXWRITER_A) $(LIBXLSXWRITER_SO) ../lib
+
+test_lib : libxlsxwriter_test.a
+
+# The static library.
+$(LIBXLSXWRITER_A) : $(OBJS)
+	$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_DIR)/ioapi.o  $(MINIZIP_DIR)/zip.o $(TMPFILEPLUS_OBJ) $^
+
+# The dynamic library.
+ifeq ($(findstring m32,$(CFLAGS)),m32)
+ARCH = -m32
+endif
+
+$(LIBXLSXWRITER_SO) : $(SOBJS)
+	$(Q)$(CC) $(SOFLAGS) $(ARCH) -o $@ $(MINIZIP_DIR)/ioapi.so $(MINIZIP_DIR)/zip.so $(TMPFILEPLUS_SO) $^ -lz
+
+# The test library.
+$(LIBXLSXWRITER_TO) : $(TOBJS)
+	$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_DIR)/ioapi.o  $(MINIZIP_DIR)/zip.o  $(TMPFILEPLUS_OBJ) $^
+
+# Minimal target for quick compile without creating the libs.
+test_compile : $(OBJS)
+
+# Targets for the object files.
+%.o  : %.c $(HDRS)
+	$(Q)$(CC) -I$(INC_DIR) $(CFLAGS) $(CXXFLAGS) -c $<
+
+%.so : %.c $(HDRS)
+	$(Q)$(CC) $(FPIC) -I$(INC_DIR) $(CFLAGS) $(CXXFLAGS) -c $< -o $@
+
+%.to : %.c $(HDRS)
+	$(Q)$(CC) -g -O3 -DTESTING -I$(INC_DIR) $(CFLAGS) $(CXXFLAGS) -c $< -o $@
+
+
+# Clean up any temp/build files.
+clean :
+	$(Q)rm -f *.o *.a *.so *.to *.dylib *.dll

data/libxlsxwriter/src/app.c

@@ -0,0 +1,443 @@
+/*****************************************************************************
+ * app - A library for creating Excel XLSX app files.
+ *
+ * Used in conjunction with the libxlsxwriter library.
+ *
+ * Copyright 2014-2017, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
+ *
+ */
+
+#include "xlsxwriter/xmlwriter.h"
+#include "xlsxwriter/app.h"
+#include "xlsxwriter/utility.h"
+
+/*
+ * Forward declarations.
+ */
+
+/*****************************************************************************
+ *
+ * Private functions.
+ *
+ ****************************************************************************/
+
+/*
+ * Create a new app object.
+ */
+lxw_app *
+lxw_app_new()
+{
+    lxw_app *app = calloc(1, sizeof(lxw_app));
+    GOTO_LABEL_ON_MEM_ERROR(app, mem_error);
+
+    app->heading_pairs = calloc(1, sizeof(struct lxw_heading_pairs));
+    GOTO_LABEL_ON_MEM_ERROR(app->heading_pairs, mem_error);
+    STAILQ_INIT(app->heading_pairs);
+
+    app->part_names = calloc(1, sizeof(struct lxw_part_names));
+    GOTO_LABEL_ON_MEM_ERROR(app->part_names, mem_error);
+    STAILQ_INIT(app->part_names);
+
+    return app;
+
+mem_error:
+    lxw_app_free(app);
+    return NULL;
+}
+
+/*
+ * Free a app object.
+ */
+void
+lxw_app_free(lxw_app *app)
+{
+    lxw_heading_pair *heading_pair;
+    lxw_part_name *part_name;
+
+    if (!app)
+        return;
+
+    /* Free the lists in the App object. */
+    if (app->heading_pairs) {
+        while (!STAILQ_EMPTY(app->heading_pairs)) {
+            heading_pair = STAILQ_FIRST(app->heading_pairs);
+            STAILQ_REMOVE_HEAD(app->heading_pairs, list_pointers);
+            free(heading_pair->key);
+            free(heading_pair->value);
+            free(heading_pair);
+        }
+        free(app->heading_pairs);
+    }
+
+    if (app->part_names) {
+        while (!STAILQ_EMPTY(app->part_names)) {
+            part_name = STAILQ_FIRST(app->part_names);
+            STAILQ_REMOVE_HEAD(app->part_names, list_pointers);
+            free(part_name->name);
+            free(part_name);
+        }
+        free(app->part_names);
+    }
+
+    free(app);
+}
+
+/*****************************************************************************
+ *
+ * XML functions.
+ *
+ ****************************************************************************/
+
+/*
+ * Write the XML declaration.
+ */
+STATIC void
+_app_xml_declaration(lxw_app *self)
+{
+    lxw_xml_declaration(self->file);
+}
+
+/*
+ * Write the <Properties> element.
+ */
+STATIC void
+_write_properties(lxw_app *self)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+    char xmlns[] = LXW_SCHEMA_OFFICEDOC "/extended-properties";
+    char xmlns_vt[] = LXW_SCHEMA_OFFICEDOC "/docPropsVTypes";
+
+    LXW_INIT_ATTRIBUTES();
+    LXW_PUSH_ATTRIBUTES_STR("xmlns", xmlns);
+    LXW_PUSH_ATTRIBUTES_STR("xmlns:vt", xmlns_vt);
+
+    lxw_xml_start_tag(self->file, "Properties", &attributes);
+
+    LXW_FREE_ATTRIBUTES();
+}
+
+/*
+ * Write the <Application> element.
+ */
+STATIC void
+_write_application(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "Application", "Microsoft Excel", NULL);
+}
+
+/*
+ * Write the <DocSecurity> element.
+ */
+STATIC void
+_write_doc_security(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "DocSecurity", "0", NULL);
+}
+
+/*
+ * Write the <ScaleCrop> element.
+ */
+STATIC void
+_write_scale_crop(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "ScaleCrop", "false", NULL);
+}
+
+/*
+ * Write the <vt:lpstr> element.
+ */
+STATIC void
+_write_vt_lpstr(lxw_app *self, const char *str)
+{
+    lxw_xml_data_element(self->file, "vt:lpstr", str, NULL);
+}
+
+/*
+ * Write the <vt:i4> element.
+ */
+STATIC void
+_write_vt_i4(lxw_app *self, const char *value)
+{
+    lxw_xml_data_element(self->file, "vt:i4", value, NULL);
+}
+
+/*
+ * Write the <vt:variant> element.
+ */
+STATIC void
+_write_vt_variant(lxw_app *self, const char *key, const char *value)
+{
+    /* Write the vt:lpstr element. */
+    lxw_xml_start_tag(self->file, "vt:variant", NULL);
+    _write_vt_lpstr(self, key);
+    lxw_xml_end_tag(self->file, "vt:variant");
+
+    /* Write the vt:i4 element. */
+    lxw_xml_start_tag(self->file, "vt:variant", NULL);
+    _write_vt_i4(self, value);
+    lxw_xml_end_tag(self->file, "vt:variant");
+}
+
+/*
+ * Write the <vt:vector> element for the heading pairs.
+ */
+STATIC void
+_write_vt_vector_heading_pairs(lxw_app *self)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+    lxw_heading_pair *heading_pair;
+
+    LXW_INIT_ATTRIBUTES();
+    LXW_PUSH_ATTRIBUTES_INT("size", self->num_heading_pairs * 2);
+    LXW_PUSH_ATTRIBUTES_STR("baseType", "variant");
+
+    lxw_xml_start_tag(self->file, "vt:vector", &attributes);
+
+    STAILQ_FOREACH(heading_pair, self->heading_pairs, list_pointers) {
+        _write_vt_variant(self, heading_pair->key, heading_pair->value);
+    }
+
+    lxw_xml_end_tag(self->file, "vt:vector");
+
+    LXW_FREE_ATTRIBUTES();
+}
+
+/*
+ * Write the <vt:vector> element for the named parts.
+ */
+STATIC void
+_write_vt_vector_lpstr_named_parts(lxw_app *self)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+    lxw_part_name *part_name;
+
+    LXW_INIT_ATTRIBUTES();
+    LXW_PUSH_ATTRIBUTES_INT("size", self->num_part_names);
+    LXW_PUSH_ATTRIBUTES_STR("baseType", "lpstr");
+
+    lxw_xml_start_tag(self->file, "vt:vector", &attributes);
+
+    STAILQ_FOREACH(part_name, self->part_names, list_pointers) {
+        _write_vt_lpstr(self, part_name->name);
+    }
+
+    lxw_xml_end_tag(self->file, "vt:vector");
+
+    LXW_FREE_ATTRIBUTES();
+}
+
+/*
+ * Write the <HeadingPairs> element.
+ */
+STATIC void
+_write_heading_pairs(lxw_app *self)
+{
+    lxw_xml_start_tag(self->file, "HeadingPairs", NULL);
+
+    /* Write the vt:vector element. */
+    _write_vt_vector_heading_pairs(self);
+
+    lxw_xml_end_tag(self->file, "HeadingPairs");
+}
+
+/*
+ * Write the <TitlesOfParts> element.
+ */
+STATIC void
+_write_titles_of_parts(lxw_app *self)
+{
+    lxw_xml_start_tag(self->file, "TitlesOfParts", NULL);
+
+    /* Write the vt:vector element. */
+    _write_vt_vector_lpstr_named_parts(self);
+
+    lxw_xml_end_tag(self->file, "TitlesOfParts");
+}
+
+/*
+ * Write the <Manager> element.
+ */
+STATIC void
+_write_manager(lxw_app *self)
+{
+    lxw_doc_properties *properties = self->properties;
+
+    if (!properties)
+        return;
+
+    if (properties->manager)
+        lxw_xml_data_element(self->file, "Manager", properties->manager,
+                             NULL);
+}
+
+/*
+ * Write the <Company> element.
+ */
+STATIC void
+_write_company(lxw_app *self)
+{
+    lxw_doc_properties *properties = self->properties;
+
+    if (properties && properties->company)
+        lxw_xml_data_element(self->file, "Company", properties->company,
+                             NULL);
+    else
+        lxw_xml_data_element(self->file, "Company", "", NULL);
+}
+
+/*
+ * Write the <LinksUpToDate> element.
+ */
+STATIC void
+_write_links_up_to_date(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "LinksUpToDate", "false", NULL);
+}
+
+/*
+ * Write the <SharedDoc> element.
+ */
+STATIC void
+_write_shared_doc(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "SharedDoc", "false", NULL);
+}
+
+/*
+ * Write the <HyperlinkBase> element.
+ */
+STATIC void
+_write_hyperlink_base(lxw_app *self)
+{
+    lxw_doc_properties *properties = self->properties;
+
+    if (!properties)
+        return;
+
+    if (properties->hyperlink_base)
+        lxw_xml_data_element(self->file, "HyperlinkBase",
+                             properties->hyperlink_base, NULL);
+}
+
+/*
+ * Write the <HyperlinksChanged> element.
+ */
+STATIC void
+_write_hyperlinks_changed(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "HyperlinksChanged", "false", NULL);
+}
+
+/*
+ * Write the <AppVersion> element.
+ */
+STATIC void
+_write_app_version(lxw_app *self)
+{
+    lxw_xml_data_element(self->file, "AppVersion", "12.0000", NULL);
+}
+
+/*****************************************************************************
+ *
+ * XML file assembly functions.
+ *
+ ****************************************************************************/
+
+/*
+ * Assemble and write the XML file.
+ */
+void
+lxw_app_assemble_xml_file(lxw_app *self)
+{
+
+    /* Write the XML declaration. */
+    _app_xml_declaration(self);
+
+    _write_properties(self);
+    _write_application(self);
+    _write_doc_security(self);
+    _write_scale_crop(self);
+    _write_heading_pairs(self);
+    _write_titles_of_parts(self);
+    _write_manager(self);
+    _write_company(self);
+    _write_links_up_to_date(self);
+    _write_shared_doc(self);
+    _write_hyperlink_base(self);
+    _write_hyperlinks_changed(self);
+    _write_app_version(self);
+
+    lxw_xml_end_tag(self->file, "Properties");
+}
+
+/*****************************************************************************
+ *
+ * Public functions.
+ *
+ ****************************************************************************/
+
+/*
+ * Add the name of a workbook Part such as 'Sheet1' or 'Print_Titles'.
+ */
+void
+lxw_app_add_part_name(lxw_app *self, const char *name)
+{
+    lxw_part_name *part_name;
+
+    if (!name)
+        return;
+
+    part_name = calloc(1, sizeof(lxw_part_name));
+    GOTO_LABEL_ON_MEM_ERROR(part_name, mem_error);
+
+    part_name->name = lxw_strdup(name);
+    GOTO_LABEL_ON_MEM_ERROR(part_name->name, mem_error);
+
+    STAILQ_INSERT_TAIL(self->part_names, part_name, list_pointers);
+    self->num_part_names++;
+
+    return;
+
+mem_error:
+    if (part_name) {
+        free(part_name->name);
+        free(part_name);
+    }
+}
+
+/*
+ * Add the name of a workbook Heading Pair such as 'Worksheets', 'Charts' or
+ * 'Named Ranges'.
+ */
+void
+lxw_app_add_heading_pair(lxw_app *self, const char *key, const char *value)
+{
+    lxw_heading_pair *heading_pair;
+
+    if (!key || !value)
+        return;
+
+    heading_pair = calloc(1, sizeof(lxw_heading_pair));
+    GOTO_LABEL_ON_MEM_ERROR(heading_pair, mem_error);
+
+    heading_pair->key = lxw_strdup(key);
+    GOTO_LABEL_ON_MEM_ERROR(heading_pair->key, mem_error);
+
+    heading_pair->value = lxw_strdup(value);
+    GOTO_LABEL_ON_MEM_ERROR(heading_pair->value, mem_error);
+
+    STAILQ_INSERT_TAIL(self->heading_pairs, heading_pair, list_pointers);
+    self->num_heading_pairs++;
+
+    return;
+
+mem_error:
+    if (heading_pair) {
+        free(heading_pair->key);
+        free(heading_pair->value);
+        free(heading_pair);
+    }
+}